- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Inferred type is not general enough
by Ben Lippmeier 08 Jul '04

08 Jul '04

Ivan.. Uh.. by 'works' I meant 'compiles' :) Here is a fixed version.. As I understand it, the 2 parameter class (Location loc => Packet p loc) means "loc is a Location, and types p and loc are related by class Packet" with just that information, if you try (as you did) something like $ source TestPacket Then you've given the compiler the type for 'p' (TestPacket), but it won't go the distance and decide that type for 'loc' is TestLocation.. even though that's the only instance you've given it. You can tell the compiler that "The type of 'p' sets the type of 'loc'" with a "functional dependency".. which is the "| p -> loc" annotation at the end of the class definition in the new version below. There is a paper which covers exactly this problem, in detail. I suggest you read it (I did). "Type classes with functional dependencies", Mark P. Jones, 2000 You can get it from his homepage at, http://www.cse.ogi.edu/~mpj/ Ben. Ivan Tihonov wrote: > It compiles well, but doesn't work for me :( > BTW: (email answers are not always real-time :) ) new version: -------------------------------------- class Location a where point :: a -> String class Location loc => Packet p loc | p -> loc where source :: p -> loc destination :: p -> loc size :: Num b => p -> b ------------------------------------------------------ data TestLocation = TestSource | TestDestination deriving (Show) data TestPacket = TestPacket ------------------------------------------------------ instance Location TestLocation where point a = "location" instance Packet TestPacket TestLocation where source p = TestSource destination p = TestDestination size p = 99

1 0

Re: [Haskell-cafe] Folding function composition: L or R?
by Graham Klyne 07 Jul '04

07 Jul '04

At 14:24 07/07/04 +0200, Henning Thielemann wrote: >On Wed, 7 Jul 2004, Graham Klyne wrote: > > > [[ > > sss :: [ShowS] > > sss = map (++) ["abc","def","ghi","jkl"] > > > > ssr = foldr (.) id sss > > ssl = foldl (.) id sss > > > > sr = ssr "" > > sl = ssl "" > > > > -- sl == sr == "abcdefghijkl" > > -- is there any efficiency difference? > > ]] > > > > Conventional wisdom suggests that foldr is better, but I'm not sure if it > > really matters in this case. > >foldl performs worse, e.g. for infinite lists it will need infinite >time :-) Of course! And your answer makes me notice an important touchstone when dealing with such questions: "what happens with an infinite list?". Thanks! #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

Folding function composition: L or R?
by Graham Klyne 07 Jul '04

07 Jul '04

I have a sequence of functions that I wish to fold together using function composition (.). Does it matter if I use foldl or foldr? e.g. [[ sss :: [ShowS] sss = map (++) ["abc","def","ghi","jkl"] ssr = foldr (.) id sss ssl = foldl (.) id sss sr = ssr "" sl = ssl "" -- sl == sr == "abcdefghijkl" -- is there any efficiency difference? ]] Conventional wisdom suggests that foldr is better, but I'm not sure if it really matters in this case. #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

2 1

RE: [Haskell-cafe] readMVar and the devils
by Simon Marlow 07 Jul '04

07 Jul '04

On 06 July 2004 11:29, Conor T McBride wrote: > OK, here's what I want, what I do with it, and my attempt to deliver > it. But I'm not an expert, so please let me know if there's some > disastrous flaw... > > The signature/spec: > > type Hole x > > hole :: IO (Hole x) > -- returns a fresh empty hole for an x > askHole :: Hole x -> IO (Maybe x) > -- inspects the current contents (or none) of the hole; mustn't > -- block > tellHole :: Hole x -> x -> IO (Maybe x) > -- tries to write the hole, returns what was previously there; > -- if the hole was empty, the value supplied is installed > -- if the hole was full, it's unchanged (too late, pal!); > -- mustn't block > readHole :: Hole x -> IO x > -- blocks until the hole has been filled, then returns its > -- value > instance Eq (Hole x) > -- a kind of higher-level `pointer equality' The following should do the trick (but I wouldn't rule out any lurking race conditions, and perhaps there's an even simpler way to achieve this): data Hole x = Hole (MVar ()) -- wait on this for readHole (MVar (Maybe x)) -- always full, Just x <=> hole contains x instance Eq (Hole x) where (Hole m1 _) == (Hole m2 _) = m1 == m2 hole = do wait <- newEmptyMVar val <- newMVar Nothing return (Hole wait val) askHole (Hole wait val) = readMVar val tellHole (Hole wait val) x = do modifyMVar val $ \mb -> case mb of Nothing -> do putMVar wait (); return (Just x, Nothing) Just y -> return (Just y, Just y) readHole (Hole wait val) = do readMVar wait mb <- readMVar val return (fromJust mb) Cheers, Simon

1 0

problem with hsql on windows
by Shanon Fernald 07 Jul '04

07 Jul '04

I'm using: GHC 6.2.1 HSQL 1.4 on a Windows XP machine. I'm trying to the compile the HSQL example using the eclipse Haskell plug-in, but I get the following error message: Chasing modules from: Main.hs Compiling Queries ( ./Queries.hs, C:\workspace\dbtest\out/Queries.o ) ./Queries.hs:3: Failed to load interface for `Database.HSQL': Bad interface file: C:/ghc/ghc-6.2.1/imports/Database/HSQL/GHC/imports/Database/HSQL.hi mismatched interface file versions: expected 6021, found 6020 What it appears is that my HSQL has an interface matching GHC 6.2 maybe? I just downloaded the HSQL 1.4 from the sourceforge site. The windows exe version is HSQL-1.4.exe. Is this the correct version of HSQL? Am I matching the GHC and HSQL versions correctly? If so, do you know what else I might be doing wrong? I am able to compile other programs with no problem. Thanks for help. It is fun to learn a new language and my Haskell books are on order :)

1 0

Re: Roman Numerals and Haskell Syntax abuse
by George Russell 07 Jul '04

07 Jul '04

Christian Maeder wrote (snipped) > btw, now 127: > roman=(!5);n!a|n<1=""|n>=t=s!!(a+1):(n-t)!a|c>=t=s!!(2*d):c!a|1>0=n!(a-1)where d=a`div`2;s="ivxlcdm";c=10^d+n;t=5^(d+1)*2^(a-d) This is amazing! When I posted my first attempt of 181 characters I thought it might be minimal.

1 0

Random Numbers for the beginner ?
by Crypt Master 06 Jul '04

06 Jul '04

Hi I have tried I swear, even googled for 45 minutes, but I cant seem to get random numbers working. In the documentation is has: rollDice :: IO Int rollDice = getStdRandom (randomR (1,6)) But if I type "getStdRandom (randomR (1,6))" into hugs in the context of module which imports Random, I get get errors. ERROR - Unresolved overloading *** Type : (Random a, Num a) => IO a *** Expression : getStdRandom (randomR (1,6)) Roll dice takes no parameters and returns an IO Int. So in thoery (mine at least ;-) ) running this as an expresion should work. I should get an IO Int back from the interpreter ? So I added RollDice to my module. This doesnt error, but it doesnt return anything except blank spaces: HasGal> rollDice HasGal> Integers or nums should automatically have show correct? So this should show me something ? Ultimatly I want to get randomRs infinite list working so I can build randNums = (take (length popList) [1..]) where the length of pop list is how many random numbers I want. My code works as it, just need to replace [1..] with some random numbers. Thanks, C _________________________________________________________________ Add photos to your e-mail with MSN 8. Get 2 months FREE*. http://join.msn.com/?page=features/featuredemail

3 2

Re: [Haskell-cafe] Random Numbers for the beginner ?
by Jon Cast 06 Jul '04

06 Jul '04

sholderm(a)students.cs.uu.nl wrote: <snip> > Use > > (getStdRandom (randomR (1,6))) :: IO Int This much is fine, but... > instead. > > \begin{code} > module Main where > import Random > > > main :: IO () > main = do n <- (getStdRandom (randomR (1,6))) :: IO Int > ; print n > \end{code} Layout error: the semicolon must be indented further than the `n' is. Furthermore, the semicolon is unnecessary; if it's deleted, yielding > main :: IO () > main = do n <- (getStdRandom (randomR (1,6))) :: IO Int > print n the code works just fine. Jon Cast

1 0

Roman Numerals and Haskell Syntax abuse
by George Russell 06 Jul '04

06 Jul '04

The following declaration for a function for converting positive integers to Roman numerals is 181 characters long. Is there a shorter one? roman=f[(i-j,i)|i<-[2,4..8],j<-[2,1]]where f(d@((a,b):c))n|n<1=""|n>=t!!a=s!!a:f d(n-t!!a)|1>0=if n+t!!b>=t!!a then s!!b:f d(n+t!!b)else f c n;s="mdclxvi";t=[1000,500,100,50,10,5,1]

6 9

RE: [Haskell-cafe] readMVar and the devils
by Simon Marlow 06 Jul '04

06 Jul '04

On 02 July 2004 10:16, Conor T McBride wrote: > Hi folks > > I'm having a play with Concurrent Haskell, and came across this in the > library. > > readMVar :: MVar a -> IO a > This is a combination of takeMVar and putMVar; ie. it takes the > value from the MVar, puts it back, and also returns it. > > I was just wondering if I understand things correctly. Suppose myMVar > is nonempty and I have one thread executing > > do x <- takeMVar myMVar -- (A) > putMVar myMVar x -- (B) > return x > > and another executing > > putMVar myMVar y -- (C) > > Questions > > (1) Is it possible that an evil scheduler will execute (A) then (C) > and block on (B)? Yes. In fact, you don't need an evil scheduler, an ordinary scheduler will do this :-) > (2) Is it the case that if myMVar is nonempty and readMVar is chosen > for execution, that readMVar myMVar takes the value > from myMVar, guaranteed that the _same_ value will be put > back immediately, and also returned? Only if there are no other threads executing putMVar on myMVar concurrently. > (3) If yes to both, what combination of takeMVar and putMVar manages > to maintain the lock in between the two? There isn't one. readMVar is only atomic with respect to other well-behaved threads; that is, other threads doing strictly take-followed-by-put operations. There are lots of similar cases in the world of MVars. Our general approach is that we provide combinators which help you build correct code (eg. withMVar, modifyMVar), but you can always shoot yourself in the foot by using the lower-level operations. > I'm only asking, because I'm trying to cook up some kind of partial > evaluator for programs which are being simultaneously edited by > fiercely argumentative devils. Kind of `demonic laziness', where > the computations decide when _they_ feel like running (eg sometime > after the program turns up), rather than the `angelic laziness' we're > used to. I'd like to use MVars in a write-once-read-many style, so > that once someone fills in a bit of program, it stays put. I'd hate > for another devil to sneak in a replacement program just in the > twinkling of an eye between taking something out to read and putting > it back to be read again. > > I guess I could use some kind of extra semaphore MVar to ensure that > the reader has the lock on the program MVar, but that's more like > hard work. Is readMVar what I want? It sounds like you want a different abstraction, but one that can almost certainly be built using MVars. I'm not sure exactly what it is you need, but if you provide the signatures of the operations then I could probably sketch an implementation. Cheers, Simon

2 1

Re: [Haskell-cafe] readMVar and the devils
by MR K P SCHUPKE 06 Jul '04

06 Jul '04

at a guess the magic take put is: block ( do a <- takeMVar x putMVar x a ) return a Keean.

3 2

Re: Help in understanding a type error involving forall and class constraints
by oleg＠pobox.com 06 Jul '04

06 Jul '04

> Is it possible to return an arbitrary unboxed array that was > constructed in the ST monad (as an STUArray)? > The issue is that you end up with a MArray class constraint that > involves the state thread's 's' parameter, but this type > variable gets 'hidden' by runST which universally quantifies > over it. runST :: forall a. (forall s. ST s a) -> a That seems to be possible. Let us start with the original code: > buildUArray' bounds f = do > arr <- newArray_ bounds > mapM_ (\i -> writeArray arr i (f i)) (range bounds) > return arr > > buildUArray bounds f = do arr <- buildUArray' bounds f > unsafeFreeze arr If we check for the type of buildUArray *Foo> :t buildUArray buildUArray :: forall e a1 b m a. (MArray a e m, Ix a1, IArray b e) => (a1, a1) -> (a1 -> e) -> m (b a1 e) we see the problem. It is in the constraint MArray a e m. If we use that function in runST, as in foo bounds f = runST (buildUArray bounds f) the constraint 'MArray a e m' has to be provided by the function foo. However, 'm' in that constraint will be 'ST s', so the state variable escapes. Therefore, the typechecker rejects foo. We should notice that the type variable 'a' in the above type appears only in the constraint -- but not in the types. That is, 'a' will be _existentially_ quantified. Thus, we can provide the needed constraint via an explicit existential type. Here's the solution > data Allocator m i e = forall a. MArray a e m => > Allocator ((i, i) -> m (a i e)) > > buildUArray'' allocator bounds f = > case allocator of > Allocator alloc -> do > arr <- alloc bounds > mapM_ (\i -> writeArray arr i (f i)) (range bounds) > unsafeFreeze arr *Foo> :t buildUArray'' buildUArray'' :: forall e a b m. (Monad m, Ix a, IArray b e) => Allocator m a e -> (a, a) -> (a -> e) -> m (b a e) That type shows that now buildUArray'' is truly polymorphic over the array types; furthermore, the particular MArray type is irrelevant. As we can see, the MArray constraint is nowhere to be found -- just as we wanted to. we can define one particular allocator, specifically for STUArray > allc:: Ix i => Allocator (ST s) i Bool > allc = Allocator (newArray_:: Ix i => (i,i) -> ST s (STUArray s i Bool)) we can then write > foo bounds f = runST (buildUArray'' allc bounds f) > test = foo (1::Int,2::Int) (const True) :: Array Int Bool One can say that foo builds only arrays of Booleans. Can we have a function that builds polymorphic arrays? The answer is again yes. We merely need to make our allocator polymorphic with respect to the type of the array: > class STUGood e where > allcg::Ix i => Allocator (ST s) i e > instance STUGood Bool where > allcg = Allocator (newArray_:: Ix i => (i,i) -> ST s (STUArray s i Bool)) > instance STUGood Float where > allcg = Allocator (newArray_:: Ix i => (i,i)-> ST s (STUArray s i Float)) etc. > bar bounds f = runST (buildUArray'' allcg bounds f) *Foo> :t bar bar :: forall e i b. (IArray b e, STUGood e, Ix i) => (i, i) -> (i -> e) -> b i e The type of bar is indeed polymorphic with respect to the index, the sort of the array, and the type of the element of the array: > test2 x :: Array Int x = bar (1::Int,2::Int) (const x) *Foo> test2 (1.0::Float) array (1,2) [(1,1.0),(2,1.0)] *Foo> test2 True array (1,2) [(1,True),(2,True)] As we see, we indeed need to define instances of STUGood for Bool, Char, Float, Word32, etc. One might wish if the designers of the Haskell library introduced a class 'Unpackable'. In that case, we would have needed only one STUArray instance instance Unpackable e => MArray (STUArray s) e (ST s) The constraint Unpackable would have made solving your problem easier. For the sake of completeness, I'd like to mention another solution, using castSTUArray. Yet it smacks too much of dynamic typing...

1 0

Re: [Haskell-cafe] data vs newtype (was: newbie problems)
by MR K P SCHUPKE 05 Jul '04

05 Jul '04

>But you have to balance this against newtypes being neater. I meant more efficient... oh well! (data is generally neater) Keean.

1 0

Re: [Haskell-cafe] data vs newtype (was: newbie problems)
by MR K P SCHUPKE 05 Jul '04

05 Jul '04

One difference is that Constuctors for 'data' can be curries, whereas 'newtype' cannot: data X a b c = X a b c newtype X a b c = X (a,b,c) But you have to balance this against newtypes being neater. Also data can represend and abstract type: data X whereas newtype cannot, also data can represent unitary types: data Y = Y whereas newtype is limited to wrapping up void: newtype Z = Z () Keean.

1 0

Re: [Haskell-cafe] Using Product Algebraic types
by Crypt Master 05 Jul '04

05 Jul '04

------------- <sigh> I always get a bad feeling when people start to think about efficiency right from the beginning: First get your program correct and readable, then measure, and only then optimize (if at all). Programmers are notoriously bad when guessing about efficiency, which even more true for lazy functional programs. </sigh> ------------ Sorry to have produced the *sigh* factor. I asked the question only to start learning, which your answer has certainly helped me with. Maybe I can present a differnt persepctive on performance though. I have to say up front though that if I was interested in squeezing the last drop of performance out of everything I wouldnt be learning haskell as all the web sites warn you about this :-) I do beleive in clarity, readbaility, correctness, time to develop etc.., it just that performance is one of those factors. My day job is all mostly about performance (from iterative programming perspective), I make complex business applications useable from a perfromance perspective. While most people say "just buy more hardware" or make it "correct or readable" first, my experince shows this leads to a lot of wasted effort which could have been avoided with a few seconds thought. Have you ever tried telling an IT Director that his 500 000 - 1 000 000 pound equipment purchase isnt cutting it for a "simple" business application :-) Let me tell you, they can have really selective hearing when it suits them :-) In my world, getting a program "correct" includes effieincy within reason. For exmaple, a 5 minute response time for interactive process can be pushed on employees with a relativilty minial cost of a small loss in productivity. However 5 minutes as a response for customer sitting on your web site is going to cost you millions and probably put you out of business. There are dozens of senarios like this where a "correct" program is as good as no program if it doesnt perform fast enough. What you say about guessing at performance is correct. I have given lectures on performance which start off with slides which say the trick to performance tuning is: "Measure, Measure, Measure" But I have found through experience (in the iterative world) that certian patterns of bad performance are easily avoided at development time because we know from experince they are bad at runtime. Performance has 3 flavours in my mind: 1) Hard Core 2) Design (Algortihms and data representation) 3) Common sense coding The fiirst, Hard code, invovles assemlber optimizations, branch reductions using boolean algebra etc.. No one argues these are mostly not worth the effort and so these are mostly ingnored expect for very special cercumstances. The phrase "buy more hardware" applies in this case 99% of the time. At the other end of the spectrum you have design. Few people will argue that getting your design right up front is very important. Changing Algorithms or Data Representation usually invovles changes of a significance that you have wasted your time on the "incorrect" version as you are starting mostly from scratch. Admitatly this looks a lot easier in haskell than in other impertive lanaguages. The 3rd area is where I differ from most people. Common sense coding is simply not calculating or looking something up over and over in an inner loop etc... While the programs can be changed afterwards to incorporate these, a few seconds thought by the developer avoids the bottle neck in the first place. An Example of the impact of such ineffiencies is this: Recenetly I "optimized" an interactive job which was taking over 10 minutes to run. Without understanding much about it (its highly complex) I was able to bring it down to < 1 minute applying simple common sense things. I never changed or looked at the "logic" behind it. Happy user base = productive company :-) That said haskell compiler seem pretty smart from what you have shown me so far ... which is a welcome change :-) Thanks for your reponse. This is the most helpfull community I have encountered so far .. :-) _________________________________________________________________ Help STOP SPAM with the new MSN 8 and get 2 months FREE* http://join.msn.com/?page=features/junkmail

1 0

newbie problems
by paolo veronelli 05 Jul '04

05 Jul '04

I'd like to have a simple definition of the meanings of 'type' and 'data' and maybe a clarifing example on their use. I've read the Zipper doc on he wiki ,but I can't make it work on n-ary trees,and most of all they are not any clear the performance hits on using more complex 'data' Thanks Paolino

3 2

RE: [Haskell-cafe] Using Product Algebraic types
by Crypt Master 05 Jul '04

05 Jul '04

Hi Man, your a genius :-) Thanks for the help , still dijesting it. Interestingly enough I was playing with how to use sacnl1 just before I got this message from you, but as you mentioned I was battling with "kind" errors so I never got to test my idea besides on paper. Am I correct in assuming that your definition of Popoulation is now using tuple and not product types ? If so it it better to use tuples ? In the book the craft of func programing, it shows product type examples like this: data People = Person Name Age type Name = String type Age = Int Later it shows polymoric definitions like this: data Pairs a = Pr a a You mentioned that I had applied the polymorphic type "a" to Fitness, but but in the above example of person and people they have done the exactly what I did ? Used a space to seperate elements. So I am a little confused as to why mine didnt work. Regarding the use of newtype and data I saw another thread on this and I will use that get some insights on the differences. Your "rw" took some following until I realised currying was invovled *grin* > rw (Population xs) = Population (scanl1 f xs) > where f (n, a) = (+ n) `pair` id Can I ask one question, I am not concerned with performance at this point, but what sort of overhead does a function like id have. It seems unneccesary to me ( I am not critising your solution, I am vert thankfull for your help ) in a large populations you will land up doing a fair amount of extra but simple "reductions" ( I hope thats the right word. ) just to "copy" the unkown "a". Or does it have to be a function for some reason and so you had to use "id" ? Thanks, S ----Original Message Follows---- Crypt Master, CM> I need to be able to work with a list of items whos CM> structure is onyl partially know. That is at the level CM> of this module I dont care about what rest of it is. CM> So I have this: < type Fitness = Integer < data Population a = Population [Fitness a] Well, first of all: this will not compile. You've declared Fitness to be an synonym of Integer and Integer is not a parametric data type, i.e. it has kind *. In your definition for Population, however, you apply Fitness to a type argument. This will give you a kind error. CM> Hopefully this reads Population is constructed using CM> the Population constructor and is a list who elements CM> each conists a fitness value and some other value. So, no, it does not. I guess this is what you want: > type Fitness = Integer > data Population a = Population [(Fitness, a)] > deriving (Show) Now Population constructs a Population value from a list of which the elements are pairs of a Fitness value and a value of a specified type a. CM> Since I cant do poloymorphioc types with synonyms I CM> went with the data type. Well, actually, you can: > type Population' a = [(Fitness, a)] but type synonyms have the restriction that they cannot be partially applied. Another option might be > newtype Population'' a = Population'' [(Fitness, a)] which is only slightly different from the definition above involving data. CM> My current task is to build a roulette wheel CM> distribution of the fitness value. Basically I want to CM> build and incremental summing of the fitness value so CM> that each individual is paired with its upper range CM> like so CM> CM> Population [10 x, 20 y, 30 z] CM> New Population = [10 x, 20+10 y, 30+30 z] This can be accomplished by > rw :: Population a -> Population a > rw (Population xs) = Population (scanl1 f xs) > where f (n, a) = (+ n) `pair` id where pair is the maps a pair of functions to a function on pairs: > pair :: (a -> c) -> (b -> d) -> (a, b) -> (c, d) > f `pair` g = h > where h (a, b) = (f a, g b) A little test: > main :: IO () > main = print > $ rw (Population [(10, 2), (20, 3), (30, 5)]) This prints: "Population [(10,2),(30,3),(60,5)]". HTH, Stefan _________________________________________________________________ MSN 8 helps eliminate e-mail viruses. Get 2 months FREE*. http://join.msn.com/?page=features/virus

4 5

Working debuggers?
by Jim Apple 05 Jul '04

05 Jul '04

I downloaded and compiled buddha, but it apparently does not support Control.Monad.State. I downloaded Hat, but it requires hmake. Hmake fails to build (GHC 6.2.1). Any suggestions? Jim

2 1

Question on Exercise from SOE
by Nathan Weston 05 Jul '04

05 Jul '04

I am learning haskell (and functional programming), from the School of Expression book. There's an exercise to rewrite the following function (for computing the area of a polygon) using map, fold, etc: data Shape = Polygon [Vertex] area (Polygon (v1:vs)) = polyArea vs where polyArea :: [Vertex] -> Float polyArea (v2:v3:vs') = triArea v1 v2 v3 + polyArea (v3:vs') polyArea _ = 0 My first thought is to use fold here, since this function accumulates a result as it traverses the list. But fold consumes one element of the list at a time, while area needs to examine the first three elements of the list, and consume two of them at a time. Is there a more general alternative to fold? Or is there some trick I'm missing here? Thanks, Nathan

3 2

Pruning the tree
by paolo veronelli 05 Jul '04

05 Jul '04

Now I have my infinite tree inf t =Leaf "1" treeGrower :: Tree String-> Tree String treeGrower (Leaf a )= treeGrower (Fork (Leaf (a++"1")) (Leaf (a++"2"))) treeGrower (Fork l r) = Fork (treeGrower l) (treeGrower r) data Tree a = Fork (Tree a) (Tree a) | Leaf a deriving Show inf=treeGrower t I'd like to prune it to a level to have a show of a piece like piece= prune 5 inf How prune is to be coded ?? Thanks Paolino

2 1

Question on Exercise from SOE
by Crypt Master 04 Jul '04

04 Jul '04

Hi Not looking to get flamed, just offering my opinion. I got the SOE first, and while I like the higher level of it, the way he thinks etc... I found it hard to learn haskell from it. I just recieved "Haskell: The Craft of cuntional Programming" this weekend, and have made huge leaps forward (for me) based on the information within. I would have prefered to start with this book in place of SOE. So my advice is SOE is great but back it up with The craft .. S _________________________________________________________________ Add photos to your e-mail with MSN 8. Get 2 months FREE*. http://join.msn.com/?page=features/featuredemail

3 2

Using Product Algebraic types
by Crypt Master 04 Jul '04

04 Jul '04

Hi My question is how do I select or work with product Alhebraic types ? Let you give you some context: I need to be able to work with a list of items whos structure is onyl partially know. That is at the level of this module I dont care about what rest of it is. So I have this: type Fitness = Integer data Population a = Population [Fitness a] Hopefully this reads Population is constructed using the Population constructor and is a list who elements each conists a fitness value and some other value. Since I cant do poloymorphioc types with synonyms I went with the data type. My current task is to build a roulette wheel distribution of the fitness value. Basically I want to build and incremental summing of the fitness value so that each individual is paired with its upper range like so Population [10 x, 20 y, 30 z] New Population = [10 x, 20+10 y, 30+30 z] My first thought was a list comprehension: rwList :: Population -> Population rwList (Population popList) = Population [ (rwListSum i) | i <- popList] rwListSum :: [a] -> [a] rwListSum (fitness individual) = (fitness*2, individual) ingoring for a minute that this wont achieve the above goal, I immediatly ran into the issue of how do I represent in the inner portion of the Population List, i.e "Fitness a". "(fitness individual)" doesnt work ? I tried treating it as 2 normal arguments, but of course how can I return it then ... ? A function can only return one thing. If its not a tuple then it wont work. Hence my question of how you represent product types ? I did come up with one idea, that is of making the internal part a type on its own so now I have this: type Fitness = Integer data InternalIndividual a = InternalIndividual Fitness a data Population a = Population [InternalIndividual a] ... rwList :: Population -> Population rwList (Population popList) = Population [ (rwListSum i) | i <- popList] rwListSum :: InternalIndividual -> InternalIndividual rwListSum (InternalIndividual fitness individual) = (InternalIndividual fitness*2 individual) To my surpirse this compiles. I have been able to fully test it yet though. So is there a way to do this without a extra type ? Is there a better way to represent this ? Thanks for your time, PS Sorry for all the dumb questions, I always find asking better than just wondering for ages. _________________________________________________________________ MSN 8 with e-mail virus protection service: 2 months FREE* http://join.msn.com/?page=features/virus

2 1

A binary tree
by paolo veronelli 04 Jul '04

04 Jul '04

I want to build a binary tree where each leaf is a string of "L" and "R" defining their position from the top This should be done without context isn't it? data Tree a = Fork (Tree a) (Tree a) | Leaf a deriving Show t =Leaf "" treeGrower :: Tree a -> Tree a treeGrower (Leaf a )= treeGrower (Fork (Leaf (a++"1")) (Leaf (a++"2"))) treeGrower (Fork l r) = Fork (treeGrower l) (treeGrower r) ghci says: Cannot unify the type-signature variable `a' with the type `[a1]' Expected type: [a1] Inferred type: a In the first argument of `(++)', namely `a' In the first argument of `Leaf', namely `(a ++ "1")' I don't get it.........

2 1

Re: [Haskell-cafe] newbie problems
by MR K P SCHUPKE 03 Jul '04

03 Jul '04

The zipper should work on n-ary trees. all the zipper does is store the tree as (Context,Subtree) so you just need to adapt that to a Rose-Tree. you could do something like (and I am thinking out loud here as I havent written zipper code for rose trees)... data Context x = Root | Parent x (Context x) [Rose x] [Rose x] data Rose x = Node x [Rose x] so at any given point in the tree the context is either Root, or the Parent (with the value at that node, the parents context, then the left siblings and right siblings as lists) As to the difference between types and values, a type limits the permitted values. For example a :: [Int] a is a list of integers. now data IntList = Value Int | List [Int] IntList can be a single int or a list of ints... data IntList = Value Int | List [IntList] Now intlist can be a value or a list of IntLists... we are dealing with the type of permitted data not the data itself. when we define a value for example: a :: IntList a = Value 3 This must obey the construction rules given in the data type "IntList" So you see when a data declaration refers to itself it is not a "pointer" but an inclusion of the type for example: a :: IntList a = List [Value 3,List [Value 2,Value 1],Value 4] is a valid instance of IntList, but notice that although the 'type' refers to itself the value is not self-referential. Thats not to say self referential values are not possible - but lets avoid confusing the issue with such things. Keean.

2 1

Running Total or Incremental Sum as a higher order type ?
by Crypt Master 03 Jul '04

03 Jul '04

Hi I was attempting to get a running a total of a list i.e for [1,2,3] the result should be [1,3,6] -- [1, 1+2, 2+3] I build this function: incrementalSum [] x = [] incrementalSum (x:xs) runningTotal = currentSum : incrementalSum xs currentSum where currentSum = runningTotal + x I was trying to see how I could higher order functions for this but came up empty. Surely this is a pattern which has been abstracted ? I feel I have missed the obvious here. Thanks, S _________________________________________________________________ MSN 8 helps eliminate e-mail viruses. Get 2 months FREE*. http://join.msn.com/?page=features/virus

2 1

RE: [Haskell-cafe] List syntax -- [] vs ()
by Crypt Master 03 Jul '04

03 Jul '04

Hi Thanks. A light bulb just went on :). I am still in awe of how much "special syntax" is made of such simple base. Haskell certainly is an interesting thing to learn, its like fractals, complexity and beuty from simplicity. S ----Original Message Follows---- Crypt Master, CM> I have noticed that lists seem to swtich between CM> using [] and using (). for example: CM> CM> listSum [] = 0 CM> listSum (x:xs) = x + listsum xs The parentheses are just 'normal' parentheses that are needed because application binds stronger than (:). Without the parentheses, you would get listSum x : xs which is the same as (listSum x) : xs . HTH, Stefan _________________________________________________________________ MSN 8 helps eliminate e-mail viruses. Get 2 months FREE*. http://join.msn.com/?page=features/virus

1 0

List syntax -- [] vs ()
by Crypt Master 03 Jul '04

03 Jul '04

Hi I have noticed that lists seem to swtich between using [] and using (). for example: listSum [] = 0 listSum (x:xs) = x + listsum xs but when specificy lists you use [] as in [1,2,3]. or type signatures are [a] -> [a] It also seems when they mentioned on the right hand side it also always []. Is it just for pattern matching that you use the "tuple" syntax ? How does haskell know we dont mean a tuple ? Or do we mean a tuple when we say (x:xs) ? Thanks _________________________________________________________________ MSN 8 with e-mail virus protection service: 2 months FREE* http://join.msn.com/?page=features/virus

2 1

Re: [Haskell-cafe] Newbie questions
by Crypt Master 03 Jul '04

03 Jul '04

Hi Thanks for responding and taking the time to respond so fully. Its much appreciated! >From what I can see, a key difficulty you're having is with the >"evolvepopulation" function. You've given it the type a -> a, which >pretty much requires it to be an identity function, because it's not >allowed to make any assumptions about the values it takes. I was going trying for generic as possible, I am keen to expore how much more expressive one can be in functional lanaguages. >To make things easier to read, try defining types for Population and >Individual (they can always be generalized later). > type Individual = Int > type Population = [Individual] A use fill tip, thanks. [Snip] >It looks like you're defining evolution as the composition of mutate, >cross, and select, but got tripped up by the order of evaluation. >Specifically, "mutate cross select p" is the same as "((mutate cross) >select) p", which probably isn't what you want. It only recently dawned on me that functions are left asscoaitive and your absolutly right its not what i had in mind. >If you have: > mutate :: Population -> Population > cross :: Population -> Population > select :: Population -> Population >Then you could define > evolve p = mutate (cross (select p)) > > -- alternative: > -- evolve = mutate . cross . select I now get what the f.g is as well :-) Thanks, the alternate format with the original has just clicked something else into place. >Starting from an initial population, you want to generate a sequence by >iterating evolve, starting from an initial population. Haskell provides >a function "iterate" for this purpose, or you can define your own. Yeah other posters suggested this as well. I now have the the same function as you mentioned which is very nice: gaSolutionSpaceFrom :: a -> [a] gaSolutionSpaceFrom = iterate evolvePopulation [snip] >I found it helpful to remember that you can think of a function f :: a >-> b -> c as taking two arguments of types a and b and returning a >result c, or as taking a single argument of type a and returning a >result of type b -> c. Once you become comfortable with partial >application, a lot of Haskell code starts to make more sense. I understood the partial application when explained in simple terms, but I find I have a hard time when it used in more coimplicated examples. The currying in the "The Haskell School of Expression" left with a big "Huh", even though a simple application makes sense to me. "The craft of Functional Programming" it seesm thicker more methdoical, so I may get some more of the basics down in the next few weeks. Thanks again. ------------------------------ Message: 8 Date: Sat, 03 Jul 2004 08:38:55 +0000 From: "Crypt Master" <cryptmaster(a)hotmail.com> Subject: Re: [Haskell-cafe] Newbie questions To: duncan.coutts(a)worcester.oxford.ac.uk Cc: haskell-cafe(a)haskell.org Message-ID: <BAY18-F13KHmj9n1xxW00056ac5(a)hotmail.com> Content-Type: text/plain; format=flowed [Snip] People say function application in Haskell is written without brackets but this can be misleading, here you do need brackets to indicate that 'gaSolutionSpace [1,2,3,4,5]' is one argument and not two. So you should write: take 5 (gaSolutionSpace [1,2,3,4,5]) [Snip] Thanks alot, this was very helpfull. It also makes more sense now that I looked up the associativity of functions and found it to be left assoc. For some reason I assumed it would automaically bracket form the right as such (take (5 (gaSolutionSpace [1,2,3,4,5]))) but its actually this (((take 5) gaSolutionSpace) [1,2,3,4,5]) Thanks again. _________________________________________________________________ Tired of spam? Get advanced junk mail protection with MSN 8. http://join.msn.com/?page=features/junkmail ------------------------------ Message: 9 Date: Sat, 03 Jul 2004 08:46:24 +0000 From: "Crypt Master" <cryptmaster(a)hotmail.com> Subject: [Haskell-cafe] Re: Newbie questions To: wferi(a)afavant.elte.hu Cc: haskell-cafe(a)haskell.org Message-ID: <BAY18-F16gyf2M0KFHR000262c6(a)hotmail.com> Content-Type: text/plain; format=flowed >-- gaSolutionSpace :: [a] -> [a] >>gaSolutionSpace x = x : gaSolutionSpace (evolvepopulation x) -Stop deceiving yourself until it's too late. -Why did you comment out the type annotation? *Sheepish Grin* its historical, my original thought and attempt was that you would recieve a list of populations and evolve it to a bigger list of populations. Hence the [a] -> [a]. It didnt work out too well as this is what I came up with: gaSolSpace [x:xs] = gaSolutionSpace [x : evolePopulation x] Eventually i realised that I needed to evolve a single population, not a list, which let to a -> [a] and thanks to Keith I now have this: gaSolutionSpaceFrom :: a -> [a] gaSolutionSpaceFrom = iterate evolvePopulation Thanks _________________________________________________________________ Add photos to your e-mail with MSN 8. Get 2 months FREE*. http://join.msn.com/?page=features/featuredemail ------------------------------ _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe End of Haskell-Cafe Digest, Vol 11, Issue 3 ******************************************* _________________________________________________________________ Help STOP SPAM with the new MSN 8 and get 2 months FREE* http://join.msn.com/?page=features/junkmail

1 0

Re: [Haskell-cafe] Newbie questions
by Crypt Master 03 Jul '04

03 Jul '04

Hi Very very helpful, thanks. I wasnt sure about the "From" on the end, but I get the subtle change in way you see it. Much better than mine. Using you other advice I got: gaSolutionSpaceFrom :: a -> [a] gaSolutionSpaceFrom p = iterate evolvePopulation p and even managed to curry it :-) : gaSolutionSpaceFrom :: a -> [a] gaSolutionSpaceFrom = iterate evolvePopulation Thanks again. -------------- Kieth: [Snip] I think you mean: gaSolutionSpaceFrom :: a -> [a] gaSolutionSpaceFrom x = x : gaSolutionSpaceFrom (evolvepopulation x) gaSolutionSpace = gaSolutionSpaceFrom createRandomPopulation Note that "a" above should be replaced with your population type. Also note the "iterate" function in the standard library does just this. _________________________________________________________________ Tired of spam? Get advanced junk mail protection with MSN 8. http://join.msn.com/?page=features/junkmail

1 0

Re: Newbie questions
by Crypt Master 03 Jul '04

03 Jul '04

>-- gaSolutionSpace :: [a] -> [a] >>gaSolutionSpace x = x : gaSolutionSpace (evolvepopulation x) -Stop deceiving yourself until it's too late. -Why did you comment out the type annotation? *Sheepish Grin* its historical, my original thought and attempt was that you would recieve a list of populations and evolve it to a bigger list of populations. Hence the [a] -> [a]. It didnt work out too well as this is what I came up with: gaSolSpace [x:xs] = gaSolutionSpace [x : evolePopulation x] Eventually i realised that I needed to evolve a single population, not a list, which let to a -> [a] and thanks to Keith I now have this: gaSolutionSpaceFrom :: a -> [a] gaSolutionSpaceFrom = iterate evolvePopulation Thanks _________________________________________________________________ Add photos to your e-mail with MSN 8. Get 2 months FREE*. http://join.msn.com/?page=features/featuredemail

1 0

Re: [Haskell-cafe] Newbie questions
by Crypt Master 03 Jul '04

03 Jul '04

[Snip] People say function application in Haskell is written without brackets but this can be misleading, here you do need brackets to indicate that 'gaSolutionSpace [1,2,3,4,5]' is one argument and not two. So you should write: take 5 (gaSolutionSpace [1,2,3,4,5]) [Snip] Thanks alot, this was very helpfull. It also makes more sense now that I looked up the associativity of functions and found it to be left assoc. For some reason I assumed it would automaically bracket form the right as such (take (5 (gaSolutionSpace [1,2,3,4,5]))) but its actually this (((take 5) gaSolutionSpace) [1,2,3,4,5]) Thanks again. _________________________________________________________________ Tired of spam? Get advanced junk mail protection with MSN 8. http://join.msn.com/?page=features/junkmail

1 0

Newbie questions
by Crypt Master 03 Jul '04

03 Jul '04

Hi I consider myself a pretty good imperative programmer, been at it for decades, and am tryibng my hand at Haskell now. Unfrituantly I am not "getting" it all that quickly despite having the multimedia haskell book. To start ghetting some hands on, I thought iI owuld do something which i have done many times before in imperatives, a basic Genetic Algorithm Library. Unfortunatly I am comming unstuck straight away and was hoping some of you kind folk could point in the direction of dry land :-) iIf your not familiar with GAs its not too important, simply a GA searches over the whole solution space randomly. Well not quiet, its a guided search, its guided by evolution ie by the fitness of each indicidual of a random initial population. Evolution is simulated by 3 basic operators, selection, cross over and mutation. selection is which indiviuals get to breed, cross over is how they breed, and mutation is just things intetresting. So after reading the multimedia book, Iimmediately thought of a defining the solution space as a infinite list. I was hoping then I could do things like take 5 gaSolutionSpace to get 5 iterations or generations. My first attempt tied to use lis syntax [], but it wouldnt compile and after seeing "numsFrom" ina tutorial I redefined it as such. Here is what I have so far: -- gaSolutionSpace :: [a] -> [a] -- gaSolutionSpace [] = gaSolutionSpace createRandomPopulation -- recursive base case gaSolutionSpace x = x : gaSolutionSpace (evolvepopulation x) evolvepopulation :: a -> a evolvepopulation p = mutate cross select p -- createRandomPopulation :: [Num a] createRandomPopulation = [1,23,4,5,6] cross p = p mutate p = p select p = p ---- The take operator doesnt work on this. from hugs: HAGA> take 5 gaSolutionSpace [1,2,3,4,5] ERROR - Type error in application *** Expression : take 5 gaSolutionSpace [1,2,3,4,5] *** Term : take *** Type : Int -> [e] -> [e] *** Does not match : a -> b -> c -> d I am not sure I follow this. I assume its cause I didnt use the list notation in definaing gaSolutionSpace. Any ideas on how to do that. ? What about using map. It occurs to me that you can define gaSolutionspace as a map of the evolvolepopuloation function acrossan infinite solution space, but I dont know how to makethis infinte list to map over ...? There ar 2 papaers on GAs in haskell, but they use monads. I realise for performance I will probably have to use them too, but for now I would liek to do it without mondas even if performance isnt optimal. Sorry again for the newbie questions, but any help is appreciated. Stephen _________________________________________________________________ Help STOP SPAM with the new MSN 8 and get 2 months FREE* http://join.msn.com/?page=features/junkmail

5 4

Audio signal processing in Haskell
by Henning Thielemann 02 Jul '04

02 Jul '04

As I can see a question similar to mine was already raised here: http://www.haskell.org/pipermail/glasgow-haskell-users/2004-February/006305… I also encountered the elegance that Haskell's laziness provides for signal processing. I use lists for the signals. With help of Haskore I put together a small song and it needed 5 minutes for rendering the quite simple music of about 30 seconds. Don't care about the exact numbers but I find it rather slow. What is the most promising strategy to speed up the computation without loosing the elegance of Haskell's lists? 1. Upgrading GHC from 6.0 to the current version? 2. Use of simplification rules? How can I find out what new rules may be useful? The several dumps that GHC can generate are a bit hard to understand. :-( Is there some more detailed information about what rules GHC already applies than what one can get with -ddump-simpl-stats and -ddump-rules? 3. More strictness? Is a custom list structure with strict entries and maybe with only one constructor (thus always infinite) a considerable alternative? This would disallow the use of lots of functions that deal with lists, including State monad functions. 4. A list of arrays? Then signal processes with feedback like an echo are much more difficult.

2 3

Relating functors in Category Theory to Functor
by David Menendez 02 Jul '04

02 Jul '04

Until recently, I've had difficulty relating the concept of a "functor" from Category Theory to the class Functor in Haskell. I've figured out a relationship that seems to make sense, but I wanted to check with the list to make sure I'm not on the wrong track. In Category Theory, a functor F between categories C and D has two parts: (1) a mapping F[ob] from the objects of C to the objects of D (2) a mapping F[mor] from the morphisms of C to the morphisms of D For any morphism f: a -> b in C, there is a morphism F(f): F(a) -> F(b) in D. For two morphisms f and g in C, F(f . g) = F(f) . F(g) in D. We can interpret Haskell as a category with types as objects and functions as morphisms. For example, isDigit :: Char -> Bool. So, for some Functor f, the type constructor f corresponds to F[ob], and fmap to F[mor]. For any function g :: a -> b, fmap g :: f a -> f b, and fmap (g . h) = fmap g . fmap h. -- For two functors F, G: C -> D, there is a natural transformation tau from F to G, if for every object a in C, there is morphism tau[a]: F(a) -> G(a) in D. In Haskell, natural transformations are polymorphic functions, tau :: f a -> g a. For example, maybeToList :: Maybe a -> [a]. -- A monad is a functor, F: C -> C, plus two natural transformations mu: F^2 -> F and eta: I -> F (I being the identity functor for C). In Haskell, F[ob] becomes the type constructor, F[mor] becomes fmap (or liftM), mu becomes join :: f (f a) -> f a, and eta becomes return :: a -> f a. So, am I on the right track here? -- David Menendez <zednenem(a)psualum.com> <http://www.eyrie.org/~zednenem/>

5 6

readMVar and the devils
by Conor T McBride 02 Jul '04

02 Jul '04

Hi folks I'm having a play with Concurrent Haskell, and came across this in the library. readMVar :: MVar a -> IO a This is a combination of takeMVar and putMVar; ie. it takes the value from the MVar, puts it back, and also returns it. I was just wondering if I understand things correctly. Suppose myMVar is nonempty and I have one thread executing do x <- takeMVar myMVar -- (A) putMVar myMVar x -- (B) return x and another executing putMVar myMVar y -- (C) Questions (1) Is it possible that an evil scheduler will execute (A) then (C) and block on (B)? (2) Is it the case that if myMVar is nonempty and readMVar is chosen for execution, that readMVar myMVar takes the value from myMVar, guaranteed that the _same_ value will be put back immediately, and also returned? (3) If yes to both, what combination of takeMVar and putMVar manages to maintain the lock in between the two? I'm only asking, because I'm trying to cook up some kind of partial evaluator for programs which are being simultaneously edited by fiercely argumentative devils. Kind of `demonic laziness', where the computations decide when _they_ feel like running (eg sometime after the program turns up), rather than the `angelic laziness' we're used to. I'd like to use MVars in a write-once-read-many style, so that once someone fills in a bit of program, it stays put. I'd hate for another devil to sneak in a replacement program just in the twinkling of an eye between taking something out to read and putting it back to be read again. I guess I could use some kind of extra semaphore MVar to ensure that the reader has the lock on the program MVar, but that's more like hard work. Is readMVar what I want? Another more general question would be `is this an utterly stupid thing to do in practice?'. I mean, just consider an evaluator for some simple language (eg arithmetic expressions), implemented by forking a thread for every subcomputation, and using MVars to transmit the values. Is that diabolically slow compared to a normal evaluator? I guess I'll try it, but I was wondering if anyone had any useful experience to share? Cheers Conor

2 1

some newbie FFI questions
by John Kozak 01 Jul '04

01 Jul '04

I'm trying to experiment with image processing in haskell (with which I haven't much experience). I've written some FFI code to talk to the ImageMagick library which provokes a few questions (environment is ghc 6.2.1 on debian): 1. Speed: I'm reading in a 2000x1500 pixel image, and have defined a Pixel type like this: data Pixel a = Pixel !a !a !a deriving Show I use ImageMagick to load the image, then build an Array of Pixel Floats. Building the array takes 45 seconds on a 2.5Ghz P4 with code compiled -O2, which seems slow to me - are my expectations unrealistic? I've tried various UNPACK things which didn't make much difference. 2. How do I convert a CFloat into a Float? 3. I get the wrong answer ;-) I expect the C and haskell code below to produce the same pixel data, but they don't (the C code is right). C code: #include <stdio.h> #include <wand/magick_wand.h> int main(int argc,char *argv[]) { MagickWand *wand = NewMagickWand(); int width,height; float *pixels; int i,j; if (argc!=2) { fprintf(stderr,"bad args\n"); exit(100); } if (!MagickReadImage(wand,argv[1])) { fprintf(stderr,"can't read file\n"); exit(1); } height = MagickGetImageHeight(wand); width = MagickGetImageWidth(wand); printf("dimension: %dx%d\n",width,height); pixels = (float*) malloc(3*width*height*sizeof(float)); if (!MagickGetImagePixels(wand,0,0,width,height,"RGB",FloatPixel,(unsigned char*) pixels)) { fprintf(stderr,"can't get pixels\n"); exit(1); } printf("%f %f %f\n",pixels[0],pixels[1],pixels[2]); printf("%f %f %f\n",pixels[4],pixels[5],pixels[6]); printf("%f %f %f\n",pixels[7],pixels[8],pixels[9]); } haskell code: -- requires flags: -fffi -fglasgow-exts import Foreign import Foreign.C import MarshalArray import Char import List import Array import Bits data Pixel a = Pixel !a !a !a deriving Show data MagickWand -- opaque foreign import ccall "wand/magick_wand.h NewMagickWand" newMagickWand :: IO (Ptr MagickWand) foreign import ccall "wand/magick_wand.h DestroyMagickWand" destroyMagickWand :: (Ptr MagickWand) -> IO () foreign import ccall "wand/magick_wand.h MagickSetFilename" setFilename :: Ptr MagickWand -> CString -> IO () foreign import ccall "wand/magick_wand.h MagickReadImage" readImage :: Ptr MagickWand -> CString -> IO CInt foreign import ccall "wand/magick_wand.h MagickGetImageWidth" getWidth :: Ptr MagickWand -> CULong foreign import ccall "wand/magick_wand.h MagickGetImageHeight" getHeight :: Ptr MagickWand -> CULong foreign import ccall "wand/magick_wand.h MagickGetImagePixels" getPixels :: Ptr MagickWand -> CULong -> CULong -> CULong -> CULong -> CString -> CInt -> (Ptr a) -> IO CInt -- StorageType: enum Char=1,Short,Integer,Long,Float=5,Double type Frame a = Array (Int,Int) (Pixel a) getPixel :: ([a],Int) -> Pixel a getPixel (floats,i) = Pixel (floats!!(i*3)) (floats!!(i*3+1)) (floats!!(i*3+2)) getFrame :: (Storable a) => (Ptr a) -> Int -> Int -> IO (Frame a) getFrame arr h w = do putStr ("getFrame: "++(show (w,h))++"\n") floats <- peekArray (3*h*w) arr return (array ((1,1),(h,w)) [((i,j),getPixel (floats,((w*i)+j))) | i<-[1..h],j<-[1..w]]) loadFrameFloat :: FilePath -> IO (Frame CFloat) loadFrameFloat filename = do wand <- newMagickWand f <- (newCString filename) ok <- readImage wand f let w = (fromInteger.toInteger) (getWidth wand) h = (fromInteger.toInteger) (getHeight wand) in do arr <- mallocArray (w*h*3) :: (IO (Ptr CFloat)) rgb <- (newCString "RGB") ok1 <- getPixels wand 0 0 (getHeight wand) (getWidth wand) rgb 5 arr -- PixelFloat==5 frame <- getFrame arr h w free arr destroyMagickWand wand return frame thanks, John

4 3

My old chess player
by paolo veronelli 01 Jul '04

01 Jul '04

Ok Crypt Master give the hint to pronounce something ,because I feel a complete stupid in front of Functional Programming' though I'm a trained imperative one. I've read the nice paper www.cs.chalmers.se/~rjmh/Papers/whyfp.html and remember may years ago the hard job done to make my chess engine work ,but that was imperative C that's why it was hard ,isn't it? John Huges say the way for trees is data Albero position=Foglia position |Ramo position [Albero position] This is like Quantum-Mechanics for my head but it works ,I've tried. figliatore creatore (Foglia position) = Ramo position (map (figliatore creatore) (creatore (Foglia Position)) This I don't know how to try it but I'm faithfully blind........ Now I would like to make a change to fit my player,but the wall is too high. My function 'creatore' in fact would take a list of moves and a starting position as argument, not a nice ready position. My imperative engine stored leaves with a pointer to their mothers so that it was easy to track the list of moves. Now maybe I have to change Albero definition in data Albero move mother=Foglia move mother |Ramo move mother [Albero move mother] Is this the way? the road tracker is going to be pather (Foglia move mother)= if mother==() = () else = (pather madre ):madre This doesn't compile!! And I don't write the new 'figliatore' not to insult anyone Thanks For Comments Paolino Using M2, Opera's revolutionary e-mail client: http://www.opera.com/m2/

1 0

Newbie questions
by Crypt Master 01 Jul '04

01 Jul '04

Hi I consider myself a pretty good imperative programmer, been at it for decades, and am tryibng my hand at Haskell now. Unfrituantly I am not "getting" it all that quickly despite having the multimedia haskell book. To start ghetting some hands on, I thought iI owuld do something which i have done many times before in imperatives, a basic Genetic Algorithm Library. Unfortunatly I am comming unstuck straight away and was hoping some of you kind folk could point in the direction of dry land :-) iIf your not familiar with GAs its not too important, simply a GA searches over the whole solution space randomly. Well not quiet, its a guided search, its guided by evolution ie by the fitness of each indicidual of a random initial population. Evolution is simulated by 3 basic operators, selection, cross over and mutation. selection is which indiviuals get to breed, cross over is how they breed, and mutation is just things intetresting. So after reading the multimedia book, Iimmediately thought of a defining the solution space as a infinite list. I was hoping then I could do things like take 5 gaSolutionSpace to get 5 iterations or generations. My first attempt tied to use lis syntax [], but it wouldnt compile and after seeing "numsFrom" ina tutorial I redefined it as such. Here is what I have so far: -- gaSolutionSpace :: [a] -> [a] -- gaSolutionSpace [] = gaSolutionSpace createRandomPopulation -- recursive base case gaSolutionSpace x = x : gaSolutionSpace (evolvepopulation x) evolvepopulation :: a -> a evolvepopulation p = mutate cross select p -- createRandomPopulation :: [Num a] createRandomPopulation = [1,23,4,5,6] cross p = p mutate p = p select p = p ---- The take operator doesnt work on this. from hugs: HAGA> take 5 gaSolutionSpace [1,2,3,4,5] ERROR - Type error in application *** Expression : take 5 gaSolutionSpace [1,2,3,4,5] *** Term : take *** Type : Int -> [e] -> [e] *** Does not match : a -> b -> c -> d I am not sure I follow this. I assume its cause I didnt use the list notation in definaing gaSolutionSpace. Any ideas on how to do that. ? What about using map. It occurs to me that you can define gaSolutionspace as a map of the evolvolepopuloation function acrossan infinite solution space, but I dont know how to makethis infinte list to map over ...? There ar 2 papaers on GAs in haskell, but they use monads. I realise for performance I will probably have to use them too, but for now I would liek to do it without mondas even if performance isnt optimal. Sorry again for the newbie questions, but any help is appreciated. Stephen _________________________________________________________________ Add photos to your e-mail with MSN 8. Get 2 months FREE*. http://join.msn.com/?page=features/featuredemail

1 0

RE: [Haskell-cafe] some newbie FFI questions
by Simon Marlow 01 Jul '04

01 Jul '04

On 01 July 2004 11:53, John Kozak wrote: > I'm trying to experiment with image processing in haskell (with which > I haven't much experience). I've written some FFI code to talk to > the ImageMagick library which provokes a few questions (environment is > ghc 6.2.1 on debian): > > 1. Speed: I'm reading in a 2000x1500 pixel image, and have defined a > Pixel type like this: > > data Pixel a = Pixel !a !a !a deriving Show > > I use ImageMagick to load the image, then build an Array of Pixel > Floats. Building the array takes 45 seconds on a 2.5Ghz P4 with > code compiled -O2, which seems slow to me - are my expectations > unrealistic? I've tried various UNPACK things which didn't make > much difference. It depends how you want to use the image data, but this is almost certainly not the best representation. The fastest choice would be simply 'Ptr CFloat' (i.e. do no conversion or marshalling at all). This is essentially what your C program is doing. In Haskell you can allocate the memory using allocaBytes or mallocForeignPtr (no free required). Your other choices are: - IOUArray Int Float Fast access, but you need to convert the entire array into one of these, and back again if you need to pass it back to C. - (IOUArray Int Float, IOUArray Int Float, IOUArray Int Float) i.e. split the planes. Might be useful, depending on how you access the array. Conversion required again. - StorableArray Int CFloat You can convert the 'Ptr CFloat' you get back from C directly into a StorableArray, which gives you easy access using the mutable array primitives in Haskell, and an easy way to pass the array back to C using withStorableArray. Unfortunately accessing StorableArrays isn't as fast as it could be. And there ought to be a way to convert between StorableArray and IOUArray. This is one area that could do with some attention. - Array Pixel, and data Pixel = Pixel {-# UNPACK #-}!Float ... Not too great, because you have a few extra layers of indirection compared to IOUArrays, even with the UNPACKs. - Array (Float,Float,Float) Terrible :-) > 2. How do I convert a CFloat into a Float? Using realToFrac, I guess. > 3. I get the wrong answer ;-) I expect the C and haskell code below > to produce the same pixel data, but they don't (the C code is > right). I suggest fixing a more efficient representation first. This will reduce the amount of manipulation of the data, and either make the bug go away or make it easier to find. Cheers, Simon

1 0

Re: [Haskell-cafe] some newbie FFI questions
by MR K P SCHUPKE 01 Jul '04

01 Jul '04

Yes, deriving unboxable would be nice... I think for images though it is not too much of a problem to work with a record of arrays rather that an array of records. Keean.

1 0

Re: [Haskell-cafe] some newbie FFI questions
by MR K P SCHUPKE 01 Jul '04

01 Jul '04

Oh... also when using unboxed arrays you may well have to have a separate array for each colour plane (r,g,b,a) as I think unboxed arrays can only contain primitive types - although I am not certain about this - it may be enough to have the contents strict. Keean.

2 1

Re: [Haskell-cafe] some newbie FFI questions
by MR K P SCHUPKE 01 Jul '04

01 Jul '04

If you are using GHC the fastest way I know to do this is to build the array using a mutable-unboxed array in the state-monad. Then freeze the array and return an unboxed immutable array. This is a lot faster than building the array by copying (every time you set a value in an immutable array the whole array much be copied - for a sizeable image this is quite a lot of work!) Keean.

1 0

Re: [Haskell] Help in understanding a type error involving forall and class constraints
by Duncan Coutts 30 Jun '04

30 Jun '04

On Wed, 2004-06-30 at 12:00, MR K P SCHUPKE wrote: > Ahh.. I see whats happening: > > MArray (STUArray s) a (ST s) => String -> String -> ST s (UArray (Int,Int) a) > > IArray UArray a => String -> String -> a > > nothing here is specifying a... you cannot leave a polymorphic in this case. > > You need to supply the constraint "MArray (STUArray s) a (ST s)" to distString > but "s" is not in context... Right, because the return type of distString Int is an instance of MArray. But if we try to make 'a' polymorphic then we can't specify the constraint because it involves 's'. So the obvious follow-on question, is is there any intermediate point where 's' is in scope where we can supply a type annotation to supply the context or is it simply impossible? To restate the question for Haskell-Cafe readers: Is it possible to return an arbitrary unboxed array that was constructed in the ST monad (as an STUArray)? The issue is that you end up with a MArray class constraint that involves the state thread's 's' parameter, but this type variable gets 'hidden' by runST which universally quantifies over it. runST :: forall a. (forall s. ST s a) -> a Duncan

1 1

Switching monadic encapsulations
by Graham Klyne 28 Jun '04

28 Jun '04

Is there a function that switches monadic layering? f :: (Monad m1,Monad m2) => m1 (m2 a) -> m2 (m1 a) Does this even make sense in the general case? I'm thinking along the lines of a generalization of sequence to non-list monads. This question arises from a desire to generalize some error handling code, starting with: liftES :: (a->Either String [a]) -> Either String [a] -> Either String [a] where (Either String) as used as an error monad. A simple implementation of this might be: liftES _ (Left er) = Left er liftES f (Right as) = sequence $ map f as but I notice that liftES looks a little bit like liftM, and sequence does for the List monad what I am seeking to generalize: sequence :: [m a] -> m [a] and map looks like a version of liftM specialized to lists: liftM f = \a -> do { a1 <- a ; return (f a1) } = \a -> ( a >>= \a1 -> return (f a1) ) when m is a list monad: = \a -> concat (map (\a1 -> [f a1]) a) Similarly, concat appears to be a monadic join on lists. My listES might be partially generalized to something like: liftX :: (r -> m [r]) -> m [r] -> m [r] liftX mf = \mb -> do { b1 <- mb ; liftM concat $ sequence $ map mf b } the liftM here being used to apply 'concat' to achieve m [[r]] -> m [r]. I can see a possible replacement of concat with join and map with liftM, but I don't see any purely monadic equivalent for 'sequence'. Hence the original question. #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

3 2

RE: [Haskell-cafe] readEitherChan
by Simon Marlow 28 Jun '04

28 Jun '04

On 25 June 2004 21:20, S. Alexander Jacobson wrote: > On Fri, 25 Jun 2004, Simon Marlow wrote: >> It seems to me that with MVars you can implement pretty much any >> abstraction you need, including choice, and it's not clear that there >> would be any advantage to providing any more primitives. That's >> based on my experience so far, anyway - I know there are people out >> there that have made rather more heavy use of MVars than I have (eg. >> George Russell). > > Well we appear to be having a problem implementing > a takeEitherMVar or readEitherChan without adding > a new abstraction.... I strongly suspect that it can't be done, at least not if you want to have (a) non-busy waiting, and (b) async exception safety. My point was that I believe in order to support takeEitherMVar as a primitive, we would have to add essentially the same machinery to MVars that you would need if you were to implement it as an abstraction on top of MVars in Haskell. Cheers, Simon

1 0

RE: [Haskell-cafe] need help on exercise
by Graham Klyne 28 Jun '04

28 Jun '04

Your problem seems to be related to the Num class, and the fact that the compiler can't figure out what '5' is -- see pp 223/224 of Simon Thompson's book. The code below offers two possible resolutions, one commented: [[ class Show a => Visible a where toString :: a -> String size :: a -> Int toString x = show x size x = 1 {- instance Visible Int where toString x = show x size _ = 1 -} instance Num a => Visible a where toString x = show x size _ = 1 {- t1 - toString (5::Int) -} t1 = toString 5 ]] #g -- At 23:58 27/06/04 -0400, kasager wrote: >Hi, in my last posting i asked for help with exercise 12.5 however, i forgot >to give my code... here is my code and the error messege that hugs gives when >i try to run it (it compiles fine, however when i test it, it gives an >error)... > >Code: > >class Show a => Visible a where > toString :: a -> String > size :: a -> Int > > toString x = show x > size x = 1 > >instance Visible Int where > toString x = show x > size _ = 1 > >-- i have tried writing this without the show function, and the same error >messege still is given... i also have other instances in the class, which >work >fine and should not effect this issue... > >Error: > >Prelude> :l "C:\\WorkArea\\Haskell\\homework\\ch12_5.hs" >Main> toString 5 >ERROR - Unresolved overloading >*** Type : (Num a, Visible a) => [Char] >*** Expression : toString 5 > > >If you can help in any way or give any suggestions its greatly appreciated... >once again thanks much. ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

need help on exercise
by kasager 26 Jun '04

26 Jun '04

Hi, I am working on exercise 12.5 from "Haskell, The Craft of Functional Programming, second edition" by Simon Thompson. It asks to make Int an instance in the Visible class. I have tried multiple ways of doing this however I keep receiving the same error messege when I compile my program, saying that my types do not match and i have given a (Num a, Visible a) => String, when it is supposed to be an Int -> String. If anyone could help me with this issue it would be greatly appreciated. Thanks, Kelly

2 1

RE: [Haskell-cafe] readEitherChan
by Simon Marlow 25 Jun '04

25 Jun '04

On 24 June 2004 21:24, S. Alexander Jacobson wrote: > Cool! Why does it have an efficiency problem? Because it does busy-waiting. > And I would also observe that this solution > doesn't work for readEitherChan because there is > no tryReadChan. The naive tryReadChan > > tryReadChan chan = if isEmptyChan chan then return Nothing else > return $ readChan chan > > leaves you vulnerable to race conditions. > > It looks like we have now have two very similar > functions that, because they need the concrete > representation, need to be added in the library: > tryReadChan and tryReadSampleVar. > > Is there a systemic reason why these two very > similar functions are absent? There is no point > in my trying to add them if there is some *in > principle* difficulty. There's no fundamental difficulty that I'm aware of. The lack of these functions is probably down to historical reasons: tryTakeMVar and tryPutMVar are recent additions to the old MVar interface. > The concurrent paper seems > to indicate that there is something fundamentally > suspect about a choice operator as a primitive. > Is that issue related? The argument is based on the difficulty of implementing choice in a multithreaded or distributed setting, and the fact that simplifications to make the implementation easier tend to interfere with abstraction. It seems to me that with MVars you can implement pretty much any abstraction you need, including choice, and it's not clear that there would be any advantage to providing any more primitives. That's based on my experience so far, anyway - I know there are people out there that have made rather more heavy use of MVars than I have (eg. George Russell). > Also, you wouldn't need these functions if > Haskell's concurency model was defined to be > non-preemptive. How come forkIO was not > specifically defined to be non-preemptive (with > forkOS dependent on the local OS native threading > model)? So threads forked by forkIO would be non-preemptive with respect to what? Other threads forked by forkIO, or forkOS? forkOS is a very recent addition, BTW. Its primary purpose is to make a "bound" thread, to give the programmer a handle on which OS thread is used to make foreign calls. See this paper we submitted to the Haskell Workshop this year: http://www.haskell.org/~simonmar/papers/conc-ffi.ps.gz Hope that sheds some light. Cheers, Simon

2 1

RE: [Haskell-cafe] Haskell and concurrency
by Simon Marlow 25 Jun '04

25 Jun '04

On 25 June 2004 11:52, Graham Klyne wrote: > Anyway, I was wondering if any of the work on concurrent Haskell or > concurrent functional programming addresses similar systems or ideas, > in which implementation/hardware concurrency is decoupled from > application concurrency requirements, and particularly with a view to > applications requiring very low-overhead fine-grained concurrency? Concurrent Haskell is designed to provide exactly the kind of lightweight concurrency you're after. It won't be as quick as a custom application-specific threading model in the way you describe, but it's a *lot* faster than using one OS-thread for each thread in your system. And if you find it to be still too slow for your application, we know of several ways to speed it up... Cheers, Simon

2 1

RE: [Haskell-cafe] how to get started: a text application
by Bayley, Alistair 25 Jun '04

25 Jun '04

> From: Max Ischenko [mailto:max@ucmg.com.ua] > > Well, yes. In Markdown, like in most other "rich-text" > formats symbols are overloaded a lot. After all, it has to > constrain itself to "plain text". > > I'm going to try a "two-stage tokenization" (not sure how to > name this correctly). Basically, first I'd split the raw text > into "symbols" (like space, char, digit, left-bracket) and > then turn these symbols into tokens (like paragraph, > reference, start bold text, end bold text, etc.) Markdown looks a lot like Wiki source to me i.e. it looks like the text source for a Wiki page. It seems to serve the same purpose i.e. well-formatted plain text intended for conversion to HTML. Many (most?) Wiki engines use straightforward regex substitution to convert the text source into HTML, rather than implement a lexer/parser/pretty-printer combination. Obviously this makes for a fairly simple implementation. Mind you, some of the regex's are quite complex... See, for example: Source for Moin-moin, which runs the Haskell wiki: http://cvs.sf.net/viewcvs.py/moin/MoinMoin/parser/wiki.py?view=markup Original c2.com wiki (actual source a bit hard to find): http://www.c2.com/cgi/wiki?TextFormattingRegularExpressions ... which leads to: http://www.c2.com/cgi/wiki?TextFormattingRegularExpressionsDiscussion http://www.c2.com/cgi/wiki?AlternativesToRegularExpressions ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

3 3