December 2006 - Haskell-Cafe

File locked unnecessarily
by Arie Peterson 06 Dec '06

06 Dec '06

Hi, After a partial rewrite of my webserver, it is suffering from locked files: /path/to/file: openBinaryFile: resource busy (file is locked) The file in question really shouldn't be locked: - Only my server knows of the file's existence. - Only one thread accesses the file. - The thread accesses the file multiple times in quick succession, opening and closing it each time, but debugging statements show that it is properly closed before it is reopened. I tried opening, reading/writing and closing a file continuously for some time in an isolated environment, and that works without problems. Also, my server did not have this file locking problem before the rewrite, and the rewrite did not touch the part of the code that accesses the file. This suggests that the locking is somehow triggered by the specific access pattern of my code, if that is even possible. Does anyone know what could cause this locking and/or how to prevent it? I'm using ghc 6.4 on gentoo linux (amd64). Thanks and greetings, Arie

7 10

GADT vs Arrows for parsers/FSMs/etc.
by S. Alexander Jacobson 06 Dec '06

06 Dec '06

It seems like Haskell has two emerging idioms for parsing and fsms: GADTs and Arrows. I am thinking about using one of these idioms to represent server structure in a future version of HAppS but I'm not sure where to start. Why would one choose one or the other? -Alex- ______________________________________________________________ S. Alexander Jacobson tel:917-770-6565 http://alexjacobson.com

5 5

Typeclass question
by Jonathan Tang 06 Dec '06

06 Dec '06

I've got what's probably a beginner's question, but I'm out of ideas for solving it. It looks like it tripped me up in "Write Yourself a Scheme..." too, since the code there seems like it's arranged so I never ran into it... I've got a couple functions: binop :: (AmbrosiaData -> AmbrosiaData -> AmbrosiaM AmbrosiaData) -> AmbrosiaM () binop operator = do second <- popStack first <- popStack result <- operator first second pushStack result numNumOp :: Num a => (a -> a -> a) -> AmbrosiaData -> AmbrosiaData -> AmbrosiaM AmbrosiaData numNumOp op (Number val1) (Number val2) = return $ Number $ op val1 val2 numNumOp op (Float val1) (Float val2) = return $ Float $ op val1 val2 numNumOp op _ _ = throwError . TypeMismatch $ "Number" the intention being that I can define primitive operations for an interpreter with ("+", binop $ numNumOp (+)). In the Number case, val1 & val2 are Integers, while in the Float case, they're Floats. However, when I try to compile, I get: ./Primitives.hs:82: Cannot unify the type-signature variable `a' with the type `Integer' Expected type: Integer Inferred type: a In the application `op val1 val2' In the second argument of `($)', namely `op val1 val2' This makes no sense to me, since Integer is an instance of Num and op is defined as type Num a => a -> a -> a. Shouldn't the typechecker be able to instantiate 'a' with Integer and give the resulting type Integer -> Integer -> Integer, and then pass the final Integer to Number? Is my understanding of typeclasses off somehow? Any help would be appreciated. Regards, Jonathan

3 2

Would someone explain this code to me?
by Justin Bailey 06 Dec '06

06 Dec '06

I'm reading Chris Okasaki's "Purely Functional Data Structures", and some of his Haskell is confusing me. He defines the type Color and RedBlackSet as: data Color = R | B data RedBlackSet a = E | T Color (RedBlackSet a) a (RedBlackSet a) and then later he defines a function insertSet: insertSet x s = T B a y b where ins E = T R E x E ... T _ a y b = ins s What I don't understand is his use of the "T" constructor, both at insertSet x s = T B a y b and in the where statement: T _ a y b = ins s Is "T" being redefined, so the "T" called in the first line is a new function that happens to be called "T" which is defined in the where statement? If that was the case, I would expect this to work: insertSet x s = foo B a y b where ins E = foo R E x E ... foo _ a y b = ins s but it does not. If anyone can explain what's going on here, I'd appreciate it. Thank you! Justin

4 4

[Haskell] Defining Cg, HLSL style vectors in Haskell
by Slavomir Kaslev 06 Dec '06

06 Dec '06

Hello, I have to define a couple of float2, float3, float4 Cg, HLSL style vectors in Haskell. At first I was tempted to make them instances of Num, Floating, RealFrac, etc. but some of the functions defined in those classes have no sense for vectors. One such example is signum from class Num. There are several workarounds for this. One may come up with some meaning for vectors of such functions, for example: instance Num Float3 where ..... signum a | a == Float3 0 0 0 = 0 | otherwise = 1 This is silly. Other option, which I prefer, is to leave such functions undefined (that is signum=undefined, not just not defining them). Is this ok? Are there any other options? Another bugging thing is that some of the functions do have meaning for vectors but they need different signatures. For example (**) :: Floating a => a -> a -> a, for vectors should be (**) :: (Floating a, Vector v) => v -> a -> v, that is (**) applied for every component of the vector. Any workarounds for that? I know that I can scrap all those Num, Floating, RealFrac, etc. classes and define class Vector from scratch, but I really don't want to come up and use different names for +, -, etc. that will bloat the code. Last question: Does haskell have something like C++ templates? For example, some time in the future I may need types like int2, short3, etc., that behave just like float2, float3, but use different types for their components. I really, really wouldn't like to copy-paste the definitions of floatn and manually change their types to intn respectfully. Cheers. -- Slavomir Kaslev

8 14

state updates and efficiency
by Tim Newsham 06 Dec '06

06 Dec '06

I am writing some code with complex nested state. I have a question about performance with respect to the State monad and the Reader monad. This is somewhat long, so a quick summary of the question up front: Can the compiler optimize out state updates that dont change the state? The question inline with the code: > module Test where > import Control.Monad.State > import Control.Monad.Reader I have some nested state. This is a simplified example where we have one record inside another. In my real-world example there is more nesting and there are lists and maps involved as well. > data T1 = T1 { f1 :: Int, f2 :: T2 } deriving(Show) > data T2 = T2 { f3 :: Int, f4 :: Int } deriving(Show) I want to build generic modifiers and reuse them often. A good example is modifying a numeric value: > adjNum :: (Num a) => a -> State a () > adjNum n = modify (+ n) I'm going to be writing state code for my T1 structure which is my master structure. If I'm going to be able to reuse adjNum I am going to have to run a nested state action inside an enclosing state monad. I can build a lifter that does this as long as I know how to extract the nested state and set it back in the enclosing state: > withInnerM :: (o -> i) -> (i -> o -> o) -> State i a -> State o a > withInnerM gettor settor act = do > outer <- get > let inner = gettor outer > (ret, inner') = runState act inner > outer' = settor inner' outer > put outer' > return ret Now we can make lifters for each of the fields: > withF1M = withInnerM f1 (\f r -> r {f1=f}) > withF2M = withInnerM f2 (\f r -> r {f2=f}) > withF3M = withInnerM f3 (\f r -> r {f3=f}) > withF4M = withInnerM f4 (\f r -> r {f4=f}) which lets us write some state code for T1 using building blocks like adjNum. For example, the following code will add a value to f1, add another value to f2's f3 and finally return the value of f2's f4: > tweakT1 :: Int -> Int -> State T1 Int > tweakT1 v1 v3 = do > withF1M $ adjNum v1 > withF2M $ withF3M $ adjNum v3 > withF2M $ withF4M $ get My question here has to do with efficiency. In order to update f2's f3 a new T2 had to be constructed and used to construct a new T1. There's no way around this (I assume). But when doing a mere get of f4, there's no reason why we should have to build a new T2 and then a new T1 since nothign changed. But that's how the code is written. We could write a different lifter that does not perform a state put on the return path. If we did this with the state monad then someone could accidentally use that non-modify version of the lifter and lose an update. So instead I chose to use the Reader monad and let the type system enforce the difference between lifters that modify (M) and those that just read (R). This involved two kinds of lifters. The first lifter runs a Reader action inside of a State monad: > withRead :: Reader s a -> State s a > withRead act = do > s <- get > return $ runReader act s The second lifter runs a nested Reader action inside of an enclosing Reader monad. It is similar in spirit to withInnerM: > withInnerR :: (o -> i) -> Reader i a -> Reader o a > withInnerR gettor act = do > i <- asks gettor > return $ runReader act i again we can generate lifters for each field: > withF1R = withInnerR f1 > withF2R = withInnerR f2 > withF3R = withInnerR f3 > withF4R = withInnerR f4 And finally we can use a reader monad to eliminate the extra state updates from our previous tweakT1 implementation: > tweakT1' :: Int -> Int -> State T1 Int > tweakT1' v1 v3 = do > withF1M $ adjNum v1 > withF2M $ withF3M $ adjNum v3 > withRead $ withF2R $ withF4R $ ask > > main = do > let x = T1 1 (T2 3 4) > print $ runState (tweakT1 5 6) x > print $ runState (tweakT1' 5 6) x My question here is: is it worth it? If I run > v1 = T2 1 1 > v2 = v1 {f3 = 1} is the compiler smart enough to notice that the record update doesn't result in a change, and avoid constructing an entirely new T2? If so, then I think the original implementation TweakT1 would be about as efficient as the more complicated TweakT1'. Otherwise, I think the latter would be a lot more efficient when the state is large and complex. Tim Newsham http://www.thenewsh.com/~newsham/

2 2

what GUI library should i select?
by Bulat Ziganshin 06 Dec '06

06 Dec '06

Hello haskell-cafe, afaik, there are just two good enough libs - wxHaskell and GtkHs. can anyone point (or write) detailed comparison of their features? i plan to write large GUI program in Haskell and want to select best one. the requirements that i can imagine at this moment is the following: * my main target is Windows but ability to compile the same code both for Windows and Linux would be a plus * the program developed is a sort of advanced file manager, so i need treeview, table view and tabbed view controls * user likes beauty, so various bells-and-whistles are welcomed. in particular, it would be great to have skinnable interface * use of resource file for all texts to make internalization easier -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

15 39

(a -> [b]) -> [a -> b] ?
by Joachim Breitner 06 Dec '06

06 Dec '06

Hi, while pondering over the four fours problem, I wondered: Is there a function of type (a -> [b]) -> [a -> b] It looks a bit like sequence when applied in the ((->) a) Monad: sequence :: [a -> b] -> a -> [b] but I was looking for the other direction. I came up with: \g -> map (\n a -> g a !! n) [1..] which has the desired type and functionality, but it looks rather inelegant and messy. Any better ideas? Thanks, Joachim -- Joachim "nomeata" Breitner mail: mail(a)joachim-breitner.de | ICQ# 74513189 | GPG-Key: 4743206C JID: joachimbreitner(a)amessage.de | http://www.joachim-breitner.de/ Debian Developer: nomeata(a)debian.org

6 7

Beginner: IORef constructor?
by TJ 06 Dec '06

06 Dec '06

First of all, sorry if this is a really silly question, but I couldn't figure it out from experimenting in GHCi and from the GHC libraries documentation (or Google). Is there an IORef consturctor? Or is it just internal to the Data.IORef module? I want a "global variable", so I did the following: ------ module VirtualWorld where import Data.IORef theWorld = IORef [] -- This will be writeIORef'ed with a populated list as the user modifies the world. ----- It doesn't work. GHCi says that the IORef constructor is not in scope. I did a ":module Data.IORef" and then "IORef []" and it still gives me the same error. I'm using GHC 6.6 on Windows.

5 12

There's nothing wrong with infinite types!
by Stefan O'Rear 06 Dec '06

06 Dec '06

I'm sure anyone who's used Haskell for any significant length of time has received this error message: Occurs check: cannot construct the infinite type: t = t -> t1 I for one took that as a challenge, and have implemented a type inference engine for infinite types. Expr> s (a -> b -> c) -> (a -> b) -> a -> c Expr> skk a -> a Expr> s(skk)(skk) (fix a . (a -> b)) Expr> Points of interest: * There are NO error conditions. it-unifier can assign a type to every syntactically valid expression of combinatory logic. * Typechecking is guaranteed to terminate in a linear number of steps, an (apparently) stronger guarantee than that provided by DHM. * (Mostly theoretical, since it-unify does not yet support sums or products): Fixpoint types subsume declared recursive datatypes. e.g: type List a = fix l . Either () (a,l) darcs get http://members.cox.net/stefanor/fixtypes/

2 1