- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Type error in final generator
by Loganathan Lingappan 09 Dec '07

09 Dec '07

Thanks Bryan and Derek. This works! Logo ----- Original Message ---- From: Derek Elkins <derek.a.elkins(a)gmail.com> To: Bryan O'Sullivan <bos(a)serpentine.com> Cc: Loganathan Lingappan <loganathan.lingappan(a)yahoo.com>; haskell-cafe(a)haskell.org Sent: Saturday, December 8, 2007 4:53:54 PM Subject: Re: [Haskell-cafe] Type error in final generator On Sat, 2007-12-08 at 16:39 -0800, Bryan O'Sullivan wrote: > Loganathan Lingappan wrote: > > > main = do > > hSetBuffering stdin LineBuffering > > numList <- processInputs > > foldr (+) 0 numList > > The type of main is understood to be IO (), so it can't return anything. > You could work around this by rewriting the last line above as follows: > > print (foldr (+) 0 numList) > > This prints the number, which is presumably what you want, and print has > type IO (), so it works out nicely here. Nitpicking: Actually, as the error message says, the type of main is IO a so it can 'return' -anything- and that will be discarded as the type makes clear. The issue is that foldr (+) 0 numList :: Integer and that's not IO a for any a. Either way, Bryan's suggestion is probably what you want.

1 0

Type error in final generator
by Loganathan Lingappan 09 Dec '07

09 Dec '07

Hi, I am new to Haskell. I wrote the following code: module Main where import IO main = do hSetBuffering stdin LineBuffering numList <- processInputs foldr (+) 0 numList processInputs = do putStrLn "Enter a number:" strNum <- getLine let num = read strNum if num == 0 then return [] else do rest <- processInputs return (num : rest) And am getting the following errors: ERROR "Ex310.hs":6 - Type error in final generator *** Term : foldr (+) 0 numList *** Type : Integer *** Does not match : IO a Any pointers to the source of this error would be appreciated. Thanks, Logo

3 2

general-revised
by Ryan Bloor 09 Dec '07

09 Dec '07

hi I have four functions below: What I want to do is have a way to parse more than one digit or more than one string head in ParseTrue. Any ideas... removeSpace:: String -> StringremoveSpace = dropWhile (`elem` space) where space = [' '] match :: String -> String -> (Bool, String)match word str | ((isPrefixOf) (removeSpace word) (removeSpace str)) = (True,rest) | otherwise = (False,str) where rest = drop (length (removeSpace word)) (removeSpace str) parseDigit :: String -> [(Int, String)]parseDigit (x:xs) | isDigit x = [(read [x],xs)] | otherwise = [] parseTrue :: String -> (Bool, String)parseTrue x = match "True" x Ryan _________________________________________________________________ Celeb spotting – Play CelebMashup and win cool prizes https://www.celebmashup.com

1 0

Over-allocation
by Gracjan Polak 09 Dec '07

09 Dec '07

Hi, My program is eating too much memory: copyfile source.txt dest.txt +RTS -sstderr Reading file... Reducing structure... Writting file... Done in 20.277s 1,499,778,352 bytes allocated in the heap 2,299,036,932 bytes copied during GC (scavenged) 1,522,112,856 bytes copied during GC (not scavenged) 17,846,272 bytes maximum residency (198 sample(s)) 2860 collections in generation 0 ( 10.37s) 198 collections in generation 1 ( 8.35s) 50 Mb total memory in use INIT time 0.00s ( 0.00s elapsed) MUT time 1.26s ( 1.54s elapsed) GC time 18.72s ( 18.74s elapsed) EXIT time 0.00s ( 0.00s elapsed) Total time 19.98s ( 20.28s elapsed) %GC time 93.7% (92.4% elapsed) Alloc rate 1,186,898,778 bytes per MUT second Productivity 6.3% of total user, 6.2% of total elapsed The source.txt is 800kb, and I expect files of size 100 times more, say 80MB, so using -H800M will not help here much. The profile -p says: Wed Nov 21 14:23 2007 Time and Allocation Profiling Report (Final) copyfile +RTS -p -RTS source.txt dest.txt total time = 4.48 secs (224 ticks @ 20 ms) total alloc = 1,500,359,340 bytes (excludes profiling overheads) COST CENTRE MODULE %time %alloc xparse PdfModel 78.1 95.0 followed by a lot of 0.0 numbers. Then the faulty xparse: xparse uniq borders body bin = do parseOperatorEq "xref" p <- P.many (parseXRefSection uniq) parseOperatorEq "trailer" e <- parseDict let entries = IntMap.fromList (map (\(a,b,c) -> (a,c)) (concat p)) return (Body e entries) where the P is Text.ParserCombinators.ReadP made to work with [Word8]. How do I know WHAT is making so much allocation in this function? My files are xml-like in structure. The task currently is to read, parse, write the file. I can provide more details for interested souls. How do I make my program make less allocations? -- Gracjan

5 12

general
by Ryan Bloor 09 Dec '07

09 Dec '07

hi I have a problem. Function A is a function that passes its input into B Function B is a function that does something once. How do I make it so function A is done multiple times without adding a third function? Ryan _________________________________________________________________ Who's friends with who and co-starred in what? http://www.searchgamesbox.com/celebrityseparation.shtml

3 2

do notation strangeness
by Felipe Lessa 09 Dec '07

09 Dec '07

Hello! I see from http://www.haskell.org/haskellwiki/Monads_as_computation#Do_notation that do { v <- x ; <stmts> } = x >>= \v -> do { <stmts> } However, look at this GHCi session: Prelude> let return' = return :: a -> Maybe a Prelude> do {1 <- return 1; return' "ok"} Just "ok" Prelude> return 1 >>= \1 -> return' "ok" Just "ok" Prelude> do {1 <- return 3; return' "ok"} Nothing Prelude> return 3 >>= \1 -> return' "ok" *** Exception: <interactive>:1:13-30: Non-exhaustive patterns in lambda Hmmm... let's try with IO: Prelude> let return' = return :: a -> IO a Prelude> do {1 <- return 1; return' "ok"} "ok" Prelude> return 1 >>= \1 -> return' "ok" "ok" Prelude> do {1 <- return 3; return' "ok"} *** Exception: user error (Pattern match failure in do expression at <interactive>:1:4) Prelude> return 3 >>= \1 -> return' "ok" *** Exception: <interactive>:1:13-30: Non-exhaustive patterns in lambda Oh! What about lists? Prelude> let return' = return :: a -> [a] Prelude> do {1 <- return 1; return' "ok"} ["ok"] Prelude> return 1 >>= \1 -> return' "ok" ["ok"] Prelude> do {1 <- return 3; return' "ok"} [] Prelude> return 3 >>= \1 -> return' "ok" *** Exception: <interactive>:1:13-30: Non-exhaustive patterns in lambda Something seems wrong to me here. What am I missing? Thanks! -- Felipe.

3 5

a Char->Char function?
by Galchin Vasili 08 Dec '07

08 Dec '07

Hello, I am writing a function(actually much more than this): bozo :: Char -> Char bozo 0x02 = 'a' ... However, I get complaints from ghc suggesting that I should add an "instance declaration (Num, Char). I (mistaking) thought I understood the Haskell class hierarchy and the associated constraints .. but apparently not .. => help please. Should Kind regards, Vasya

2 1

Re: [Haskell-cafe] parser
by Chris Eidhof 08 Dec '07

08 Dec '07

On 7 dec 2007, at 23:51, Ryan Bloor wrote: > i am using hugs and the isDigit and anything 'is' doesn't work... > they must have forgot to add them in! Does GHC work with them. Yes, it's in base. Alternatively, you could write the functions yourself, they're not that hard. > p.s... that book looks fantastic... bette than the ones i got from > the library; too specific. > also... when and where do i use my predetermined types(EBool) and > how...? I think that is explained in the book. It's also not too hard to figure out yourself. A good strategy for writing Haskell programs in general is to think of the types first: what types should your functions have? Often this will help you in thinking of a good implementation. The first thing you want to do, is parametrize the return-type of your parser. Instead of having type Parser = [(ETerm, String)] you probably want: type Parser a = String -> [(a, String)]. With that type, you could do something like: parseDigit :: Parser Int parseMany :: Parser a -> Parser [a] parseOr :: Parser a -> Parser a -> Parser a You can use these types to come up with the functions. -chris > > > Ryan > > > > > > > CC: haskell-cafe(a)haskell.org > > From: chris(a)eidhof.nl > > To: ryanbloor(a)hotmail.com > > Subject: Re: [Haskell-cafe] parser > > Date: Fri, 7 Dec 2007 23:31:38 +0100 > > > > > > On 7 dec 2007, at 22:55, Ryan Bloor wrote: > > > > > hi > > > > > > The thing is... it will be a simple parser really. The expressions > > > are already defined and we can't use parsec imports. Below is the > > > types I have. > > > I have a function that removes initial spaces from the start of a > > > string. A function that checks if a substring is part of another > > > string, which use the remove space function also. > > > The next function is: which uses the type: > > > > > > type Parser = String -> [(Expr,String)] > > So what does this type really mean? You give it a string, and it > will > > return a list of (Expr, String). I would guess that the list is all > > possible outcomes, and the String in (Expr, String) is probably the > > rest of the parsed data. If you want to find a correct parse, you > > probably want to select the first element from that list that has an > > empty rest. > > > > You could write a parser that parses single digits: > > > > parseDigit :: String -> [(Int, String)] > > parseDigit (x:xs) | isDigit x = [read x] > > > > Of course you have to define the other cases for parseDigit. If you > > had a parseMany function that parses many things of the same type, > you > > could combine that with parseDigit to parse natural numbers. The > other > > thing you are really going to need is a choice-operator. In your > > example, you want to parse terms that are either numbers or "term + > > term": > > > > parseTerm = parseNaturalNumber `parseOr` parseAddition > > > > It's probably best to read a good book or tutorial on parsers. There > > is an excellent textbook on grammars and parsing in Haskell [1], it > > probably explains exactly what you want. > > > > -chris > > > > [1] Johan Jeuring, Doaitse Swierstra: Grammars and Parsing: http://www.cs.uu.nl/docs/vakken/gont/diktaat.pdf > > > > > > > > > > > readExpression :: String -> Expr > > > > > > e.g. readExpression "True" = EBool True > > > e.g. readExpression "(23 + 67)" = EAdd (EInt 23) (EInt 67) > > > > > > > > > ------------------------ > > > Types------------------------------------------ > > > > > > data Type = TNone -- badly typed values > > > | TInt -- integer values > > > | TBool -- boolean values > > > deriving Show > > > data Expr = EInt {vInt :: Int} -- integer values > > > | EBool {vBool :: Bool} -- boolean values > > > | EAdd Expr Expr -- (e1 + e2) > > > | EMin Expr Expr -- (e1 - e2) > > > | EMul Expr Expr -- (e1 * e2) > > > | EAnd Expr Expr -- (e1 && e2) > > > | EOr Expr Expr -- (e1 || e2) > > > | ENot Expr -- not e1 > > > | EComp Expr Expr -- (e1 == e2) > > > | ETest Expr Expr Expr -- if e1 then e2 else e3 > > > | ENone -- badly formed expressions > > > > > > > > > > > > > > > > > > > > > > CC: haskell-cafe(a)haskell.org > > > > From: chris(a)eidhof.nl > > > > To: ryanbloor(a)hotmail.com > > > > Subject: Re: [Haskell-cafe] parser > > > > Date: Fri, 7 Dec 2007 22:17:54 +0100 > > > > > > > > > > > > On 6 dec 2007, at 18:06, Ryan Bloor wrote: > > > > > Can anyone advise me on how to check whether a string contains > > > ints, > > > > > chars, bools, etc.... > > > > > > > > > > "2345 + 6767" shoudl give IntAdd (2345) (6767) > > > > > "2345" should give IntT 2345 > > > > You need to write a parser. There are a lot of libraries that > will > > > > help you write a parser. One library that is often used for > writing > > > > parsers in Haskell is called Parsec [1]. There's good > > > documentation on > > > > that site on how to use it. Parsec is already included in you > > > > distribution. Good luck! > > > > > > > > -chris > > > > > > > > [1]: http://legacy.cs.uu.nl/daan/parsec.html > > > > > > > > > Get closer to the jungle… I'm a Celebrity Get Me Out Of Here! > > > > > Can you guess the film? Search Charades!

2 1

Re: [Haskell-cafe] parser
by Chris Eidhof 08 Dec '07

08 Dec '07

On 7 dec 2007, at 22:55, Ryan Bloor wrote: > hi > > The thing is... it will be a simple parser really. The expressions > are already defined and we can't use parsec imports. Below is the > types I have. > I have a function that removes initial spaces from the start of a > string. A function that checks if a substring is part of another > string, which use the remove space function also. > The next function is: which uses the type: > > type Parser = String -> [(Expr,String)] So what does this type really mean? You give it a string, and it will return a list of (Expr, String). I would guess that the list is all possible outcomes, and the String in (Expr, String) is probably the rest of the parsed data. If you want to find a correct parse, you probably want to select the first element from that list that has an empty rest. You could write a parser that parses single digits: parseDigit :: String -> [(Int, String)] parseDigit (x:xs) | isDigit x = [read x] Of course you have to define the other cases for parseDigit. If you had a parseMany function that parses many things of the same type, you could combine that with parseDigit to parse natural numbers. The other thing you are really going to need is a choice-operator. In your example, you want to parse terms that are either numbers or "term + term": parseTerm = parseNaturalNumber `parseOr` parseAddition It's probably best to read a good book or tutorial on parsers. There is an excellent textbook on grammars and parsing in Haskell [1], it probably explains exactly what you want. -chris [1] Johan Jeuring, Doaitse Swierstra: Grammars and Parsing: http://www.cs.uu.nl/docs/vakken/gont/diktaat.pdf > > > readExpression :: String -> Expr > > e.g. readExpression "True" = EBool True > e.g. readExpression "(23 + 67)" = EAdd (EInt 23) (EInt 67) > > > ------------------------ > Types------------------------------------------ > > data Type = TNone -- badly typed values > | TInt -- integer values > | TBool -- boolean values > deriving Show > data Expr = EInt {vInt :: Int} -- integer values > | EBool {vBool :: Bool} -- boolean values > | EAdd Expr Expr -- (e1 + e2) > | EMin Expr Expr -- (e1 - e2) > | EMul Expr Expr -- (e1 * e2) > | EAnd Expr Expr -- (e1 && e2) > | EOr Expr Expr -- (e1 || e2) > | ENot Expr -- not e1 > | EComp Expr Expr -- (e1 == e2) > | ETest Expr Expr Expr -- if e1 then e2 else e3 > | ENone -- badly formed expressions > > > > > > > > CC: haskell-cafe(a)haskell.org > > From: chris(a)eidhof.nl > > To: ryanbloor(a)hotmail.com > > Subject: Re: [Haskell-cafe] parser > > Date: Fri, 7 Dec 2007 22:17:54 +0100 > > > > > > On 6 dec 2007, at 18:06, Ryan Bloor wrote: > > > Can anyone advise me on how to check whether a string contains > ints, > > > chars, bools, etc.... > > > > > > "2345 + 6767" shoudl give IntAdd (2345) (6767) > > > "2345" should give IntT 2345 > > You need to write a parser. There are a lot of libraries that will > > help you write a parser. One library that is often used for writing > > parsers in Haskell is called Parsec [1]. There's good > documentation on > > that site on how to use it. Parsec is already included in you > > distribution. Good luck! > > > > -chris > > > > [1]: http://legacy.cs.uu.nl/daan/parsec.html > > > Get closer to the jungle… I'm a Celebrity Get Me Out Of Here!

1 0

fundeps and overlapping/undecidable instances
by Jim Burton 08 Dec '07

08 Dec '07

I have some type-level sets using fundeps working whereby equality and membership etc are predicate functions. This seems to leads to an explosion of ugly code, with `If' class constraints etc getting out of hand -- I want to treat these as relations instead so providing the definition describes everything that is 'in' and nothing that is 'out'. I've been using Oleg's paper on lightweight static resources [1] as a template for this. I want to do something like this (supposing I have an EQ relation, (:::) for consing): class Member x y instance EQ x y => Member x (y:::ys) instance Member x ys => Member x (y:::ys) But I can certainly see why this isn't possible (It's the equivalent of pattern-matching on the constraints I suppose). Do type families provide a way to do this kind of thing or do I need a different strategy altogether, involving GADTs or whatever? Thanks, [1] http://okmij.org/ftp/Computation/resource-aware-prog/tfp.pdf -- View this message in context: http://www.nabble.com/fundeps-and-overlapping-undecidable-instances-tf49629… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 3

parser
by Ryan Bloor 08 Dec '07

08 Dec '07

hi Can anyone advise me on how to check whether a string contains ints, chars, bools, etc.... "2345 + 6767" shoudl give IntAdd (2345) (6767) "2345" should give IntT 2345 Ryan _________________________________________________________________ Who's friends with who and co-starred in what? http://www.searchgamesbox.com/celebrityseparation.shtml

3 2

Why is this strict in its arguments?
by Paulo J. Matos 08 Dec '07

08 Dec '07

Hello all, As you might have possibly read in some previous blog posts: http://users.ecs.soton.ac.uk/pocm06r/fpsig/?p=10 http://users.ecs.soton.ac.uk/pocm06r/fpsig/?p=11 we (the FPSIG group) defined: data BTree a = Leaf a | Branch (BTree a) a (BTree a) and a function that returns a list of all the paths (which are lists of node values) where each path element makes the predicate true. findAllPath :: (a -> Bool) -> (BTree a) -> Maybe [[a]] findAllPath pred (Leaf l) | pred l = Just [[l]] | otherwise = Nothing findAllPath pred (Branch lf r rt) | pred r = let lfpaths = findAllPath pred lf rtpaths = findAllPath pred rt in if isNothing lfpaths && isNothing rtpaths then Nothing else if isNothing lfpaths then Just (map (r:) $ fromJust rtpaths) else if isNothing rtpaths then Just (map (r:) $ fromJust lfpaths) else Just (map (r:) $ fromJust rtpaths ++ fromJust lfpaths) | otherwise = Nothing Later on we noticed that this could be simply written as: findAllPath :: (a -> Bool) -> (BTree a) -> [[a]] findAllPath pred = g where g (Leaf l) | pred l = [[l]] g (Branch lf r rt) | pred r = map (r:) $ (findAllPath pred lf) ++ (findAllPath pred rt) g _ = [] without even using maybe. However, 2 questions remained: 1 - why is the first version strict in its arguments? 2 - if it really is strict in its arguments, is there any automated way to know when a function is strict in its arguments? Cheers, -- Paulo Jorge Matos - pocm at soton.ac.uk http://www.personal.soton.ac.uk/pocm PhD Student @ ECS University of Southampton, UK

21 43

type class question
by Peter Padawitz 08 Dec '07

08 Dec '07

What is wrong here? ghci tries (and fails) to deduce certain types for the comp functions that I did not expect. |type Block = [Command] data Command = Skip | Assign String IntE | Cond BoolE Block Block | Loop BoolE Block data IntE = IntE Int | Var String | Sub IntE IntE | Sum [IntE] | Prod [IntE] data BoolE = BoolE Bool | Greater IntE IntE | Not BoolE class Java block command intE boolE where block_ :: [command] -> block skip :: command assign :: String -> intE -> command cond :: boolE -> block -> block -> command loop :: boolE -> block -> command intE_ :: Int -> intE var :: String -> intE sub :: intE -> intE -> intE sum_ :: [intE] -> intE prod :: [intE] -> intE boolE_ :: Bool -> boolE greater :: intE -> intE -> boolE not_ :: boolE -> boolE compBlock :: Block -> block compBlock = block_ . map compCommand compCommand :: Command -> command compCommand Skip = skip compCommand (Assign x e) = assign x (compIntE e) compCommand (Cond be c c') = cond (compBoolE be) (compCommand c) (compCommand c') compCommand (Loop be c) = loop (compBoolE be) (compCommand c)-} compIntE :: IntE -> intE compIntE (IntE i) = intE_ i compIntE (Var x) = var x compIntE (Sub e e') = sub (compIntE e) (compIntE e') compIntE (Sum es) = sum_ (map compIntE es) compIntE (Prod es) = prod (map compIntE es) compBoolE :: BoolE -> boolE compBoolE (BoolE b) = boolE_ b compBoolE (Greater e e') = greater (compIntE e) (compIntE e') compBoolE (Not be) = not_ (compBoolE be) |

8 16

ANN: Shu-thing 1.0 and Monadius 0.9
by gwern0＠gmail.com 08 Dec '07

08 Dec '07

Hi everyone. With the permission of the authors, I'd like to announce the release & upload to Hackage of two games written in Haskell (you may've seen them mentioned here once or twice before): *Monadius *Shu-thing They are both scrolling 2 dimensional arcade shooting games which use 3D vector graphics. Shu-thing is a fairly simpler upwards scrolling shooter with one level and geometric objects; Monadius is a sort of clone/homage to the classic arcade game Gradius, and I find it quite fun (although I have yet to beat it). You can find screenshots and original here: *<http://www.geocities.jp/takascience/index_en.html#haskell> The Hackage pages: *<http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Monadius-0.9.200…> *<http://hackage.haskell.org/cgi-bin/hackage-scripts/package/Shu-thing-1.0.20…> -- They both have dependencies on GLUT, and it's definitely advisable to have 3D acceleration enabled on your system. I've only tested them with GHC 6.8.1 and up (where they work fine) on my Gentoo Linux box. You should be able to 'cabal install' Shu-thing, but Monadius doesn't compile successfully for reasons I don't understand. -- My changes to the programs in question are not terribly major - largely Cabalizing them, formatting and making stylistic changes, stomping most -Wall messages, and occasionally changing algorithms or attempting to optimize them. In the case of Monadius, I removed all the Windows-specific material (the audio files were apparently copyright violations, so no big loss) and improved storage of replay files. I'd like to thank Takayuki Muranushi for answering my questions about the code and giving permission to update them. I hereby release all my changes into the public domain. -- gwern

4 4

distinguish functions from non-functions in a class/instances
by Philipp N. 07 Dec '07

07 Dec '07

Hello, i'm trying to wrap functions (a -> b -> ... -> z) of any arity to functions of type ([String] -> y), where list of strings replaces the typed arguments. one attempt looks like this (here written with type families, you can replace it by functional dependencies or what ever): type family Res x type instance Res x = x type instance Res (x->y) = Res y class Nary x where nary :: x -> [String] -> Res x instance Nary x where nary x [] = x instance Nary (x->y) where nary f (x:xs) = nary (f $ read x) xs i hope you can get the idea. the problem is, that you cannot distinguish type (x->y) from z, so these instances are overlapping. the odd thing is. you can get this to work, if you have a terminating type as result type (for example (IO x)). then you can work with all types (IO x), (a -> IO x), (a -> b -> IO x), ... but i don't want this delimiter IO! any ideas? greetings Philipp N. -- View this message in context: http://www.nabble.com/distinguish-functions-from-non-functions-in-a-class-i… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

5 5

surprised by type class binding -- is this a bug?
by Greg Meredith 07 Dec '07

07 Dec '07

Haskellians, i'm sure i don't understand type classes, yet. Still, i was surprised at ghci's response to the code below. Clues gratefully accepted. Best wishes, --greg -- transcript -- Prelude> :l grn -- [1 of 1] Compiling GeneticRegulatoryNetwork ( grn.hs, interpreted ) -- grn.hs:33:35: -- Couldn't match expected type `b1' (a rigid variable) -- against inferred type `b' (a rigid variable) -- `b1' is bound by the type signature for `sequence' at grn.hs:25:36 -- `b' is bound by the instance declaration at grn.hs:31:0 -- Expected type: [b1] -- Inferred type: [b] -- In the expression: molecules -- In the definition of `sequence': -- sequence (Site l1 molecules) = molecules -- Failed, modules loaded: none. -- Prelude> {-# OPTIONS -fglasgow-exts -fallow-undecidable-instances #-} -- -*- mode: Haskell;-*- -- Filename: grn.hs -- Authors: lgm -- Creation: Thu Dec 6 15:38:26 2007 -- Copyright: Not supplied -- Description: -- ---------------------------------------------------------------- module GeneticRegulatoryNetwork where data Segment p = Nil | Section [p] (Segment p) deriving (Eq, Show) class BindingMolecule b l | b -> l where name :: b -> l complement :: b -> b complements :: b -> Bool class Locale s l1 l2 | s -> l1 l2 where label :: s -> l1 sequence :: (BindingMolecule b l2) => s -> [b] provides :: (BindingMolecule b l2) => s -> [b] -> Bool matches :: (BindingMolecule b l2) => s -> [b] -> Bool data (BindingMolecule b l2) => Site b l1 l2 = Site l1 [b] deriving (Eq, Show) instance (BindingMolecule b l2) => Locale (Site b l1 l2) l1 l2 where label (Site l1 _) = l1 sequence (Site l1 molecules) = molecules provides (Site l1 molecules) molecules' = False -- tbd matches (Site l1 molecules) molecules' = False -- tbd -- L.G. Meredith Managing Partner Biosimilarity LLC 505 N 72nd St Seattle, WA 98103 +1 206.650.3740 http://biosimilarity.blogspot.com

1 1

how to compile this in yhc?
by Thomas Hartman 07 Dec '07

07 Dec '07

Is there some way to compile the following function in yhc? works in ghc with glasgow exts deactivated, yhc complains context for Prelude.read needed (in final line) readfloat :: String -> Maybe Float readfloat x | null parse || not (null leftover) = fail $ "myRead: "++x | otherwise = return v where parse@((v,leftover):ps) = readsPrec 0 x thanks! --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

1 0

Announce: PDXFunc: Portland FP Users Group
by Don Stewart 07 Dec '07

07 Dec '07

Who: Portland Functional Programmers Group Web: http://groups.google.com/group/pdxfunc Time and location: Monday, December 10th, 7pm at CubeSpace, 622 SE Grand, Portland, OR 97214. Directions: http://www.cubespacepdx.com/directions Topic Functional concurrency with Haskell Portland isn't going to miss out on the fun!

1 0

Graph theory analysis of Haskell code
by Ivan Miljenovic 07 Dec '07

07 Dec '07

This isn't strictly Haskell related, but anyway. Next year I will be doing my honours in mathematics. One possible topic for my thesis that I've thought of - and my supervisor is quite enthused about - is to use graph theory to analyse various textual sources, starting with source code but leaving the framework open enough to be able to extend it to other sources (e.g. email address books). How I envisage it happening is that a parser would be used to find all "functions" in the given code, treat these as nodes in the graph and then use directed edges to indicate which functions call other functions. This resultant graph can then be analysed in various ways suitable to the context (e.g. find that a library module can be split into two since there are two completely separate trees present in the graph that don't interact at all, or if a function is only ever called by one other function then it can be subsumed into it). So, here is the question I ask of all of you: is this feasible? Do you know if anything like this has ever been attempted before? I know there are some other usages of graph theory related to source code (e.g. McCabes complexity metric [1]), but I couldn't seem to find anything related to what I'm proposing. I intend to code this up in Haskell (possibly using FGL: I know of it, but haven't really looked at it) and use Haskell as my primary target for analysis, so in a sense the resultant graph could be seen as a Haskell equivalent to UML. [1] http://en.wikipedia.org/wiki/Cyclomatic_complexity -- Ivan Lazar Miljenovic

7 10

Hoogle works once more
by Neil Mitchell 07 Dec '07

07 Dec '07

Hi, I've just finished updating Hoogle (http://haskell.org/hoogle/) to work with the latest GHC API, in particular all the base split that has occurred and the few functions that were added. It took rather longer than I would have liked, because of paper deadlines etc, but its now sufficiently automated that it should only take a few seconds next time the libraries move in new directions. So now, if there is a function you are looking for in the core libraries which you can't find, tell me. Equally, if any of the documentation links lead to a 404, please do tell me. Hoogle still doesn't search all the hackage packages (that is the ultimate intention), just a selection of packages. The darcs URL's of the packages it searches are: http://darcs.haskell.org/packages/base/ http://darcs.haskell.org/packages/array/ http://darcs.haskell.org/packages/bytestring/ http://darcs.haskell.org/packages/Cabal/ http://darcs.haskell.org/packages/containers/ http://darcs.haskell.org/packages/directory/ http://darcs.haskell.org/packages/filepath/ http://darcs.haskell.org/packages/mtl/ http://darcs.haskell.org/packages/old-locale/ http://darcs.haskell.org/packages/old-time/ http://darcs.haskell.org/packages/packedstring/ http://darcs.haskell.org/packages/parallel/ http://darcs.haskell.org/packages/parsec/ http://darcs.haskell.org/packages/process/ http://darcs.haskell.org/packages/random/ http://darcs.haskell.org/packages/stm/ http://darcs.haskell.org/packages/template-haskell/ http://darcs.haskell.org/packages/time/ I picked this list based on a couple of critera: 1) The library MUST have documentation under http://haskell.org/ghc/docs/latest/html/libraries 2) The library should have shipped with GHC at some point recently (6.6 or 6.8) 3) The library is generally useful, not task specific (Gtk2hs, OpenGL are task specific) 4) If a library is Core to GHC, it should probably be in that list Quite a few libraries were close decisions, aided by nothing more than my mood at the time. In particular things like packedstring might be worth removing, and things like cgi or html/xhtml might be worth adding. Since this is a tool for the whole community, it makes sense that the whole community has input on what that list should be. Whatever list is decided upon, it will only be for the near future. Once Hoogle 4 is finished, every library on Hackage will be searched as an equal. Thanks Neil

6 7

who are the contributors to the Unix package?
by Galchin Vasili 07 Dec '07

07 Dec '07

Hello, Who started this effort? Who is currently doing work on the Unix package? Kind regards, Vasya

2 1

Pattern matching error
by georg86 07 Dec '07

07 Dec '07

Hello! I need to write a function which should is supposed to merge multiple entries with the same key (out of a sorted key-value-list) into one single entry. However, I keep getting a pattern matching error. (For example, for input [('b',[5]),('b',[4]),('b',[1]),('b',[6])]: "Program error: pattern match failure: kgroup [('b',[5,4]),('b',[1]),('b',[6])]") Thank you very much for your help. kmerge::Eq a => [(a,[b])]->[(a,[b])] kmerge [] = [] kmerge ((x,[y]):[]) = [(x,[y])] kmerge ((x,[y]):(u,[v]):xs) | x == u = kmerge ((x,[y,v]):xs) | otherwise = (x,[y]):(u,[v]):kmerge xs -- View this message in context: http://www.nabble.com/Pattern-matching-error-tf4957268.html#a14196413 Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

4 3

Template Haskell examples?
by Brent Yorgey 07 Dec '07

07 Dec '07

Hi all, I'm looking for good examples of using Template Haskell to evaluate CAFs at compile time, e.g. if I have some expensive-to-calculate lookup table which I'd rather have evaluated at comile time and included in the executable as a constant value, rather than having it computed every time the executable is run. I know I've seen examples of this before, but now that I would actually like to study such an example, I can't seem to find any. Any suggestions? Or can anyone make up a simple example on the spot? =) thanks, -Brent

2 1

Problems building and using ghc-6.9
by Daniel Fischer 07 Dec '07

07 Dec '07

Hi, so today I built ghc-6.9.20071124. First, make died because HsColour version >= 1.8 was needed, couldn't determine the version. I had HsColour 1.6, got myself 1.8, built and installed. make died again, same problem. I added ("v", Version) to the optionTable in HsColour.hs and it worked :) Then I tried to build zlib-0.4.0.1: $ runghc ./Setup.hs configure --user --prefix=$HOME Configuring zlib-0.4.0.1... Setup.hs: At least the following dependencies are missing: base >=2.0&&<2.2 ??? okay, there was something with flag bytestring-in-base, removed that, so that build-depends was base < 2.0 || >= 2.2, bytestring >= 0.9, then $ runghc ./Setup.hs configure --user --prefix=$HOME Configuring zlib-0.4.0.1... Setup.hs: At least the following dependencies are missing: base <2.0||>=2.2, bytestring >=0.9 but: $ ghc-pkg list /home/dafis/lib/ghc-6.9.20071124/package.conf: ALUT-2.1.0.0, Cabal-1.3, GLUT-2.1.1.1, HUnit-1.2.0.0, OpenAL-1.3.1.1, OpenGL-2.2.1.1, QuickCheck-1.1.0.0, array-0.1, base-3.0, bytestring-0.9, cgi-3001.1.5.1, containers-0.1, directory-1.0, fgl-5.4.1.1, filepath-1.1, (ghc-6.9.20071124), haskell-src-1.0.1.1, haskell98-1.0.1, hpc-0.5, html-1.0.1.1, mtl-1.1.0.0, network-2.1.0.0, old-locale-1.0, old-time-1.0, packedstring-0.1, parallel-1.0.0.0, parsec-2.1.0.0, pretty-1.0, process-1.0, random-1.0, readline-1.0.1, regex-base-0.72.0.1, regex-compat-0.71.0.1, regex-posix-0.72.0.2, rts-1.0, stm-2.1.1.0, template-haskell-2.2, time-1.1.2.0, unix-2.2, xhtml-3000.0.2.1 and in stringsearch-0.2: $ runghc ./Setup.lhs configure --user --prefix=$HOME Configuring stringsearch-0.2... Setup.lhs: At least the following dependencies are missing: base -any What's going on?? How can I build packages with ghc-6.9? Or do I have to go back to 6.8.1? Thanks, Daniel

2 1

Clean Dynamics and serializing code to disk
by gwern0＠gmail.com 06 Dec '07

06 Dec '07

Hey everyone; recently I've been toying around with various methods of writing a shell and reading the academic literature on such things. The best prior art on the subject seems to be the ESTHER shell (see <http://citeseer.ist.psu.edu/689593.html>, <http://citeseer.ist.psu.edu/744494.html>, <ftp://ftp.cs.kun.nl/pub/Clean/papers/2003/vWeA2003-Esther.pdf>). Now, ESTHER is a really cool looking shell, but it has two main problems for me: 1) Source doesn't seem to be available anywhere online 2) It's written in Clean and not Haskell No problem. All the hard stuff is done, and there's like a good 50 pages of documentation, so how hard could it be? Clean is practically Haskell anyway. But immediately I ran into a road-block: "The shell is built on top of Clean's hybrid static/dynamic type system and its dynamic I/O run-time support. It allows programmers to save any Clean expression, i.e a graph that can contain data, references to functions, and closures to disk. Clean expressions can be written to disk as a _dynamic_, which contains a representation of their (polymorphic) static type, while preserving sharing. Clean programs can load dynamics from disk and use run-time type pattern matching to reintegrate it into the statically-typed program." The Data.Dynamic library seems to do everything as far as dynamic types and run-time pattern matching goes, but I haven't figured out how one could write Haskell expressions to disk, like Clean's system <http://www.st.cs.ru.nl/papers/2002/verm2002-LazyDynamicIO.ps.gz> apparently allows. Does anyone know if there are any neat or tricky ways this could be done? Projects, extensions, whatever? On #haskell, quicksilver did tell me of one neat way to serialize various stuff through Data.Binary by using ADTs along the lines of the following simple example: -- module Main (main) where import Data.Binary data Math = Add | Subtract | Multiply deriving Show eval :: (Num a) => Math -> a -> a -> a eval f = case f of Add -> (+) Subtract -> (-) Multiply -> (*) instance Binary Math where put Add = putWord8 0 put Subtract = putWord8 1 put Multiply = putWord8 2 get = do tag_ <- getWord8 case tag_ of 0 -> return Add 1 -> return Subtract 2 -> return Multiply main = do encodeFile "tmp.s" [Add, Subtract, Multiply] a <- decodeFile "tmp.s" putStr $ show (a :: [Math]) -- Since from my Lisp days I know that code is data, it strikes me that one could probably somehow smuggle Haskell expressions via this route although I am not sure this is a good way to go or even how one would do it (to turn, say, a list of the chosen ADT back into real functions, you need the 'eval' function, but apparently eval can only produce functions of the same type - so you'd need to either create as many adts and instances as there are varieties of type signatures in Haskell '98 and the libraries, I guess, or somehow encode in a lambda calculus). Is that a route worth pursuing? -- gwern

4 4

HOgg 0.3.0 Released
by Conrad Parker 06 Dec '07

06 Dec '07

HOgg 0.3.0 Released ------------------- The HOgg package provides a commandline tool for manipulating Ogg files, and a corresponding Haskell library. HOgg is in hackage, or on the web at: http://www.kfish.org/~conrad/software/hogg/ This is the second public release. The focus is on correctness of Ogg parsing, production and editing. The capabilities of the hogg commandline tool are roughly on par with those of the oggz* [0] tools. Although hogg does not yet provide an equivalent to oggz-validate, it has subcommands for chopping out a section of a file, and for adding skeleton metadata. HOgg supports chained and multiplexed Ogg bitstreams conformant with RFC3533[1]. HOgg can parse headers for CMML, FLAC, OggPCM, Speex, Theora and Vorbis media codecs, and can read and write Ogg Skeleton bitstreams. [0] Oggz: http://www.annodex.net/software/liboggz/index.html [1] RFC3533: http://www.ietf.org/rfc/rfc3533.txt New in this release ------------------- The hogg tool contains new subcommands: chop, addskel and list-codecs. Additionally, subcommands for inspecting streams (hogg dump, hogg pagedump) can now take start and end time options. $ hogg help chop chop: Extract a section (specify start and/or end time) Usage: hogg chop [options] filename ... Examples: Extract the first minute of file.ogg: hogg chop -e 1:00 file.ogg Extract from the second to the fifth minute of file.ogg: hogg chop -s 2:00 -e 5:00 -o output.ogg file.ogg Extract only the Theora video stream, from 02:00 to 05:00, of file.ogg: hogg chop -c theora -s 2:00 -e 5:00 -o output.ogg file.ogg Extract, specifying SMPTE-25 frame offsets: hogg chop -c theora -s smpte-25:00:02:03::12 -e smpte-25:00:05:02::04 -o output.ogg file.ogg Options: -h, -? --help Display this help and exit -V --version Output version information and exit -c Content-Type --content-type=Content-Type Select the logical bitstreams for a specified content type -s Timestamp --start=Timestamp Specify a start time -e Timestamp --end=Timestamp Specify an end time -o filename --output=filename Specify output filename Additionally, the HOgg package now contains support for building with GHC version 6.8, and the Codec.Container.Ogg library contains various internal improvements. Installation ------------ I am very interested in hearing about problems with building or installing the package, particularly from people who are not yet familiar with building from Haskell source. You need ghc instead of gcc; it compiles to a binary: $ ./Setup.hs configure $ ./Setup.hs build $ sudo ./Setup.hs install Building of this release has been tested with: * GHC versions 6.4, 6.6 and 6.8.1 [2] * The Haskell build system "Cabal" versions 1.1.3, 1.1.4, 1.1.6, and the current development trunk. [3] The GHC and Cabal versions listed above span the packages available in most current distributions. I've tested on Debian unstable and Ubuntu Feisty. I'm particularly interested to hear reports of build success or failure on other distributions or operating systems. [2] GHC: http://www.haskell.org/ghc/ [3] Cabal: http://www.haskell.org/cabal/ Usage ----- $ hogg help Usage: hogg <subcommand> [options] filename ... Commands: help Display help for a specific subcommand (eg. "hogg help chop") Reporting: info Display information about the file and its bitstreams dump Hexdump packets of an Ogg file pagedump Display page structure of an Ogg file dumpraw Dump raw (unparsed) page data Extraction: rip Rip selected logical bistreams from an Ogg file (default: all) reconstruct Reconstruct an Ogg file by doing a full packet demux Editing: chop Extract a section (specify start and/or end time) merge Merge, interleaving pages in order of presentation time addskel Write a Skeleton logical bitstream Miscellaneous: known-codecs List codecs known by this version of hogg Please report bugs to <ogg-dev(a)xiph.org> Source ------ Source code is available from the darcs repository at: darcs get http://www.kfish.org/~conrad/software/hogg/ cheers, Conrad.

1 0

Re: About -Wall option
by Yitzchak Gale 06 Dec '07

06 Dec '07

Luis Cabellos wrote: >> I have a question, what's the best way to program? >> - put all the signatures in the Haskell Code? >> - Only put the type signatures needed to compile (like monomorphism errors >> or ambiguous signature)? Wolfgang Jeltsch wrote: > Inserting all type signatures is definitely best practice. (Moving to the cafe from ghc-users...) My personal style is: o Put signatures on everything at the top-level o Inside let and where, only where necessary, BUT: Inside let and where, I try to make sure that every function I define there is such that I would never want to call it separately in ghci/hugs while debugging, or in a unit test. Besides making testing and debugging easier, that rule forces the overall structure of every function to be simple and easy to read. In that case, type signatures just clutter the code and make it less readable. Conversely, if the relationship between the type of the let/where function and the type of the outer function is complex and not obvious, I will likely need to test that function. So it will go into a separate top-level function with a type signature. (I don't think this style creates any problems in Cabal.) -Yitz

1 0

Re: C Preprocessor
by Reinier Lamers 06 Dec '07

06 Dec '07

Bernd Brassel wrote: >Is it already a known problem that the preprocessor cannot cope with the >whole set of possible string declarations? > Yes, it is: http://hackage.haskell.org/trac/hackage/ticket/146 I ran into it lately. I was totally unaware of what caused GHC's parse error on a valid line until someone on the IRC channel pointed it out. According to the ticket, cpphs (a Haskell-oriented CPP replacement) does get it right. Regards, Reinier

2 1

Re: [Haskell-cafe] Looking for largest power of 2 <= Integer
by Dan Piponi 06 Dec '07

06 Dec '07

On Dec 3, 2007 10:05 PM, David Benbennick <dbenbenn(a)gmail.com> wrote: > Could you please post your code here when you're done? I'd be > interested to see the final result. This is just experimental code I'm playing with in order to implement exact real arithmetic, so there'll never be a "final" result :-) But this is what I'm currently playing with. It's hard-coded for a platform with 64 bit Ints and 64 bit "limbs" of Integers. This is my first ever foray into the binary underbelly of Haskell, using information from http://www.haskell.org/ghc/docs/4.06/users_guide/ghc-libs-ghc.html, and I've probably written this code really stupidly. import GHC.Exts import Data.Bits fastTestBit :: Integer -> Int -> Bool fastTestBit n i = case n of S# m -> testBit (I# m) i J# l d -> let I# w = shiftR i 6 b = i .&. 63 in testBit (I# (indexIntArray# d w)) b -- Assumes n/=0 topBit :: Integer -> Int topBit n = case n of S# m -> topBit' n 63 J# l _ -> topBit' n (64*I# l-1) where topBit' n i = if fastTestBit n i then i else topBit' n (i-1) I don't need something super-fast (ie. clever bit twiddling tricks), just something not stupidly slow. Despite what dons says, testBit is stupidly slow :-) fastTestbit takes microseconds instead of seconds on 2^10000000. Maybe a portable tidied up version of fastTestBit ought to go into Data.Bits. These kinds of operations are ubiquitous in numerical algorithms. And note the fixed title :-) -- Dan

6 7

Re: [Haskell] IVar
by Simon Marlow 06 Dec '07

06 Dec '07

Jan-Willem Maessen wrote: >> Consider this: >> >> do >> x <- newIVar >> let y = readIVar x >> writeIVar x 3 >> print y >> >> (I wrote the let to better illustrate the problem, of course you can >> inline y if you want). Now suppose the compiler decided to evaluate y >> before the writeIVar. What's to prevent it doing that? Nothing in >> the Haskell spec, only implementation convention. > > Nope, semantics. If we have a cyclic dependency, we have to respect > it---it's just like thunk evaluation order in that respect. Ah, so I was thinking of the following readIVar: readIVar = unsafePerformIO . readIVarIO But clearly there's a better one. Fair enough. Cheers, Simon

2 2

Re: [Haskell-cafe] ghc overlapping instances -> solved
by Steffen Mazanek 06 Dec '07

06 Dec '07

Hello, Isaac, this works for me. Thx a lot, Steffen 2007/12/5, Isaac Dupree <isaacdupree(a)charter.net>: > > Steffen Mazanek wrote: > > Hi, > > > > Stefan and Isaac, thx for providing quick advice. > > > > @Stefan: Unfortunately I have to use a list. > > @Isaac: I do not get it. Could you please provide a short example of > your > > approach? > > > > The question still remains. Which arguments do I have ghc to start with > to > > get the same behavior than hugs with -98 +o (here it works). > > > > I provide my example for testing purposes: > > > > module Test where > > import Test.QuickCheck > > import Monad(liftM,liftM2) > > > > type Program = [Stmt] > > data Stmt = Text | IfElse Program Program | While Program deriving (Eq, > > Show) > > > > instance Arbitrary [Stmt] where > > arbitrary = sized genProg > > instance Arbitrary Stmt where > > arbitrary = sized genStmt > > > > genStmt::Int->Gen Stmt > > genStmt 0 = return Text > > genStmt 1 = return Text > > genStmt 2 = oneof [return Text, return (While [Text])] > > genStmt n | n>2 = oneof ([return Text, > > liftM While (genProg (n-1))]++ > > [liftM2 IfElse (genProg k) (genProg > > (n-k-1))|k<-[1..n-2]]) > > > > genProg::Int->Gen Program > > genProg 0 = return [] > > genProg 1 = return [Text] > > genProg n | n>1 = oneof ((liftM (\x->[x]) (genStmt n)):[liftM2 (:) > (genStmt > > k) (genProg (n-k))|k<-[1..n-1]]) > > > > prop_ConstructParse progr = True > > where types = progr::Program > > > > main = mapM_ (\(s,a) -> putStrLn s >> a) [("flowchart construct and > parse", > > test prop_ConstructParse)] > > is prop_ConstructParse the only thing that breaks when you remove the > instance Arbitrary [Stmt] where arbitrary = sized genProg, or have I > missed something? If that's all, try this (untested) : > > prop_ConstructParse = forAll (sized genProg) (\progr -> True) > > and similarly for other properties. > > Or, you _can_ use a newtype for quickcheck-only, something like this: > > newtype P = P { unP :: Program } > instance Show P where show = show . unP > instance Arbitrary P where arbitrary = sized genProg . unP > prop_ConstructParse (P progr) = True > > > Isaac > -- Dipl.-Inform. Steffen Mazanek Institut für Softwaretechnologie Fakultät Informatik Universität der Bundeswehr München 85577 Neubiberg Tel: +49 (0)89 6004-2505 Fax: +49 (0)89 6004-4447 E-Mail: steffen.mazanek(a)unibw.de

1 0

matching
by Ryan Bloor 06 Dec '07

06 Dec '07

hi I have a matching problem... I am wanting to identify whether or not a string is an opening substring of another (ignoring leading spaces). I have this: word is a single word and str is a string. match :: String -> String -> (Bool, String)match word str | if removeSpace str `elem` (removeSpace word) ++ rest = (True, rest) | otherwise == (False,str) where rest = str Any help? Ryan _________________________________________________________________ The next generation of MSN Hotmail has arrived - Windows Live Hotmail http://www.newhotmail.co.uk

2 2

New slogan for haskell.org
by Don Stewart 06 Dec '07

06 Dec '07

It was raised at CUFP today that while Python has: Python is a dynamic object-oriented programming language that can be used for many kinds of software development. It offers strong support for integration with other languages and tools, comes with extensive standard libraries, and can be learned in a few days. Many Python programmers report substantial productivity gains and feel the language encourages the development of higher quality, more maintainable code. With the links from the start about using Python for various purposes, along with reassuring text about licenses and so on. Note its all about how it can help you. The Haskell website has the rather strange motivational text: Haskell is a general purpose, purely functional programming language featuring static typing, higher order functions, polymorphism, type classes, and monadic effects. Haskell compilers are freely available for almost any computer. Which doesn't say why these help you. Any suggestions on a 2 or 3 sentence spiel about what's available? Here's some quick points: General purpose: applications from OS kernels to compilers to web dev to ... Strong integration with other languages: FFI, and FFI binding tools Many developer tools: debugger, profiler, code coverage, QuickCheck Extensive libraries: central library repository, central repo hosting Productivity, robustness, maintainability: purity, type system, etc Parallelism! -- Don

54 160

Re: Why is this strict in its arguments? (Jules Bean)
by John Lato 06 Dec '07

06 Dec '07

Wow, thanks. I had a similar function (long if/then/else chain, fromJust) that I haven't been happy with, but couldn't see how to improve it. Now I have a much better idea for how to fix that function. Thanks again, John Lato > the general pattern is : replace isNothing with a case match on Nothing, > replace fromJust with a case match on Just, don't be afraid to case two > expressions at once. > > Hope someone finds that useful, > > Jules

1 0

Re: [Haskell-cafe] Clean Dynamics and serializing code to disk
by Sterling Clover 06 Dec '07

06 Dec '07

In an email to the HAppS listt today, alexj described that HAppS-State "provides a way to serialize function calls for replay either on-restart or on other replicated boxes." (which actually helped me to understand somewhat what's going on behind all its TemplateHaskell magic. This is somewhat more constrained than perhaps you're looking for, given that A) it requires TemplateHaskell and B) it requires that the functions operate only on "other replicated boxes" but it might be a place to start looking? --S On Dec 5, 2007 9:56 AM, John van Groningen <johnvg(a)cs.ru.nl> wrote: > gwern0(a)gmail.com wrote: > > >Hey everyone; recently I've been toying around with various methods of > writing a shell and reading the academic literature on such things. The best > prior art on the subject seems to be the ESTHER shell (see < > http://citeseer.ist.psu.edu/689593.html>, < > http://citeseer.ist.psu.edu/744494.html>, < > ftp://ftp.cs.kun.nl/pub/Clean/papers/2003/vWeA2003-Esther.pdf>). > > > >Now, ESTHER is a really cool looking shell, but it has two main problems > for me: > >1) Source doesn't seem to be available anywhere online > >... > > The source code of ESTHER is include with Clean 2.2 in the directory > Libraries/Hilde of the windows 32 bit binary zip and the sources zip and > tar. > > Kind regards, > > John van Groningen > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

1 0

ghc overlapping instances
by Steffen Mazanek 06 Dec '07

06 Dec '07

Hello, I want to quickcheck a property on a datatype representing programs (=[Stmt]) and need to define a specific instance instance Arbitrary [Stmt] (mainly to restrict the size of the list). In quickcheck an instance Arbitrary of lists is already defined. Which parameters do I have to give ghc such that it accepts such an instance? In hugs -98 +o is enough. I have tried -XOverlappingInstances, -XFlexibleInstances and also -XIncoherentInstances, however I still got an overlapping instances error for this declaration. Regards, Steffen

3 4

Parsing unstructured data
by Olivier Boudry 05 Dec '07

05 Dec '07

Hi all, This e-mail may be a bit off topic. My question is more about methods and algorithms than Haskell. I'm looking for links to methods or tools for parsing unstructured data. I'm currently working on data cleaning of a Customer Addresses database. Addresses are stored as 3 lines of text without any structure and people made used lots of imagination to create the data (20 years of data using no rules at all). Postal code, street, city, state, region, country and other details as suite, building, dock, doors, PO box, etc... are all stored in free form in those 3 lines. I already wrote a haskell program to do the job. It correctly parses about 2/3 addresses and parses much of the rest but with unrecognized parts left. The current program works by trying to recognize words used to tag parts like STE, SUITE, BLDG, street words (STR, AVE, CIRCLE, etc...) and countries from a list (including typos). It uses regular expressions to recognize variation of those words, lookup tables for countries, street words, regular expression rules for postal codes, etc... The most difficult task is splitting the address parts. There is no clearly defined separator for the fields. It can be dot, space, comma, dash, slash, or anything you can imagine using as a separator and this separator can of course also be found inside an address part. In the current application when part of an address is recognized it will not be parsed again by the other rules. A system trying all rules and tagging them with probabilities would probably give better results. Any link to tools or methods that could help me in that task would be greatly appreciated. I already searched for fuzzy, probabilistic or statistical parsing but without much success. Thanks, Olivier. PS: just in case someone's interested I attached the code and partial data to this e-mail.

4 6

a positive challenge for the Haskell effort .....
by Galchin Vasili 05 Dec '07

05 Dec '07

http://code.enthought.com/enthon/ .. how do Haskell libraries/packages stack up against this challenge? Kind regards, Vasya

2 1

An unusual prime number generator...
by Andrew Coppin 05 Dec '07

05 Dec '07

Hi guys. I just wrote this prime number generator. It's... unusual. It seems to go increadibly fast though. Indeed, I asked it to write the first 1,000,000 prime numbers to a text file, and scanning the bit array seemed to take longer than constructing the bit array! Odd... Anyway, for your amusement: module Primes2 (compute_primes) where import Data.Word import Data.Array.IO seive :: IOUArray Word32 Bool -> Word32 -> Word32 -> IO () seive grid size p = mapM_ (\n -> writeArray grid n False) [p, 2*p .. size] next_prime :: IOUArray Word32 Bool -> IO Word32 next_prime grid = work grid 2 where work grid n = do p <- readArray grid n if p then return n else work grid (n+1) copy :: Word32 -> IOUArray Word32 Bool -> Word32 -> IO (IOUArray Word32 Bool) copy p grid size = do let size' = size * p grid' <- newArray (1,size') False mapM_ (\n -> do b <- readArray grid n if b then mapM_ (\x -> writeArray grid' (n + size*x) True) [0..p-1] else return () ) [1..size] return grid' init_grid :: IO (IOUArray Word32 Bool) init_grid = do grid <- newArray (1,6) False writeArray grid 1 True writeArray grid 5 True return grid compute_primes :: Word32 -> IO [Word32] compute_primes n = do g0 <- init_grid ps <- work n g0 6 return (2:3:ps) where work top grid size | size >= top = do p <- next_prime grid putStrLn $ "Found prime: " ++ show p if p > top then return [p] else do seive grid size p ps <- work top grid size return (p:ps) | otherwise = do p <- next_prime grid putStrLn $ "Seiving prime: " ++ show p let size' = p*size grid' <- copy p grid size seive grid' size' p ps <- work top grid' size' return (p:ps) -- Debug... show_grid :: IOUArray Word32 Bool -> IO () show_grid grid = do (b0,b1) <- getBounds grid mapM_ (\n -> do x <- readArray grid n; if x then putChar '-' else putChar '#') [b0..b1] putStrLn ":"

4 8

SingHaskell slides
by Martin Sulzmann 05 Dec '07

05 Dec '07

Slides (in pdf) are now available online: http://taichi.ddns.comp.nus.edu.sg/taichiwiki/SingHaskell2007 http://www.comp.nus.edu.sg/~sulzmann/singhaskell07/index.html - Tom & Martin

1 0

unification would give infinite type
by Rafael 05 Dec '07

05 Dec '07

Hi... I give this error using hugs for the code: --------------------------------------------------- f = foldl (\x y -> add x y) 0 [1,2,3] add x y = return (x + y) --------------------------------------------------- I try: f = foldl (\x y -> counter x y) (return 0) [1,2,3] but it dont solve, and with ghci: " Occurs check: cannot construct the infinite type: b = m b Expected type: b Inferred type: m b In the expression: add x y In a lambda abstraction: \ x y -> add x y " thnks. att Rafael

3 4

building HUnit and other packages on Windows cygwin ...
by Galchin Vasili 05 Dec '07

05 Dec '07

Hello, I believe that HUnit has absolutely not other package dependencies. When I do a "runhaskell Setup.hs build", I get the following error message: gcc: installation problem, cannot exec `cc1': No such file or directory. I am not sure what "cc1" is? A pass/phase of the gnu gcc compiler? Kind regards, Vasya

2 1

foild function for expressions
by Carlo Vivari 05 Dec '07

05 Dec '07

Hi! I'm a begginer in haskell and I have a problem with an exercise, I expect someone could help me: In one hand I have a declaration of an algebra data, like this: data AlgExp a = AlgExp { litI :: Int -> a, litB :: Bool -> a, add :: a -> a -> a, and :: a -> a -> a, ifte :: a -> a -> a -> a} (being ifte an 'ifthenelse' expresion...) What I want to do is to write a fold function for expressions, something like this: foldExp :: AlgExp a -> Exp -> a foldExp alg (LitI i) = litI alg i foldExp alg (LitB i) = litB alg i foldExp alg (add exp1 exp2) = ¿¿¿??? foldExp alg (and exp1 exp2) = ¿¿¿??? foldExp alg (ifte exp1 exp2 exp3) = ¿¿¿??? ..ETC the fact is that I have no idea of what to do with the other expresions (add, and, and ifte)... I really don' t understand how to do this... It's clear that a fold function should colapse in one valour, but how can I espress it in the terms of the exercise? For further information about the problem after this, it's suposed that I have to rewrite some functions for expresions but in terms of foldexp (the one I should write before) Thank you very much!!!! -- View this message in context: http://www.nabble.com/foild-function-for-expressions-tf4932877.html#a141190… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

8 11

Re: [Haskell] Re: Haskell Digest, Vol 52, Issue 1
by Simon Marlow 05 Dec '07

05 Dec '07

Taral wrote: > On 12/4/07, Simon Marlow <simonmarhaskell(a)gmail.com> wrote: >> do >> x <- newIVar >> let y = readIVar x >> writeIVar x 3 >> print y >> >> (I wrote the let to better illustrate the problem, of course you can inline >> y if you want). Now suppose the compiler decided to evaluate y before the >> writeIVar. What's to prevent it doing that? > > Look at the translation: > > newIVar >>= (\x -> let y = readIVar x in writeIVar x 3 >> print y) > > y can't be floated out because it depends on x. y doesn't need to be floated out, just evaluated eagerly. Cheers, Simon

1 0

Expert systems
by Joel Reymont 05 Dec '07

05 Dec '07

Is there an expert system implemented in Haskell, or a library perhaps? A CLIPS/RETE implementation? The main stumbling point, from my perspective, is how to implement a knowledge base and check whether patterns with a certain "shape" have been asserted. It's much easier to do this in a dynamically-typed language. Am I mistaken? Thanks, Joel -- http://wagerlabs.com

1 0

Re: [Haskell] Nested guards?
by Neil Mitchell 05 Dec '07

05 Dec '07

Hi > server text > | Just xs <- parse text = let > x | "field1" `elem` xs = error "... do one thing ..." > | "field2" `elem` xs = error "... do something else ..." > in x > server _ = error "... invalid request ..." This now has the wrong semantics - before if parse text returned Just [] the error invalid request branch was invoked, now its a pattern match failure. I haven't used pattern guards that much (but will once Haskell' standardises them, or they get implemented in Hugs!), but their syntax seems quite natural. This extension seems to make it harder to understand them, and gives some nasty , | parsing issues for a human at least - quite possibly for a compiler too. Perhaps if you gave a little grammar for extended pattern guards (compared to the original) it would be easier to see how naturally they fit in. Thanks Neil

4 3

Looking for smallest power of 2 >= Integer
by Dan Piponi 05 Dec '07

05 Dec '07

Is there anything in any of the interfaces to Integer that will allow me to quickly find the highest bit set in an Integer? If not, does anyone have any recommendations for how to do it efficiently. There are some obvious things that come to mind but which might involve quite a bit of useless copying of data internally by the implementation of Integer. -- Dan

9 12

when I am rebuilding a package that has package dependencies
by Galchin Vasili 05 Dec '07

05 Dec '07

Hello, Which document discusses how to first build all dependencies and then finally the target package? I prefer to read relevant documentation so I get fully up to speed rather than take up bandwidth on this newsgroup asking one question at a time. Regards, Vasya

1 0

isSpace
by Ryan Bloor 05 Dec '07

05 Dec '07

hi I am having trouble with a function that is supposed to eliminate spaces from the start of a String and return the resulting string. I reckon a dropWhile could be used but the isSpace bit is causing me problems... words :: String -> String words a = case dropWhile isSpace a of "" -> s:ss -> (s:word) : words rest where (word,rest) = break isSpace ss Thanks Ryan _________________________________________________________________ The next generation of MSN Hotmail has arrived - Windows Live Hotmail http://www.newhotmail.co.uk

3 2

Re: [Haskell] IVar
by Isaac Dupree 05 Dec '07

05 Dec '07

>> A pure readIVar would be just like lazy I/O, with similar drawbacks. >> With readIVar, the effect that lets you observe the evaluation order >> is writeIVar; with hGetContents it is hClose. Conclusion: it's >> probably no worse than lazy I/O. > > Actually, it's considerably better. +: implementation may not evaluate something that may terminate/block, anyway IVar may change from blocking to non-blocking, unlike most pure expressions. This is only meaningful if trying to evaluate it would prevent it from gaining a value. It can only have such an effect (helping the IVar gain a value) if the same thread would do any IO (if it wasn't for the unnecessary evaluation). IO is generally observable, so getting stuck on a normal non-terminating expression wouldn't be any more acceptable than getting stuck on an IVar in that case. ... all assuming unsafeInterleaveIO doesn't exist, because it's unsafe, so the semantics are undefined of when it gets evaluated relative to later normally-sequenced IO actions, if it will be eventually evaluated for sure -- right? Nevertheless its intended use generally assumes that it will be evaluated as if its evaluation might not terminate, i.e. as late as possible. If it is in fact (a finite amount of) non-blocking IO, then evaluating it early will only have consequences on when the IO happens (and therefore its effect/result), not directly on the program's non-termination or actions. It gets more confusing the more I think about it! to modify Simon's example, it looks to me like treating readIVar as potentially non-terminating, and writeIVar as potentially having side-effects, is enough: main = do --irrelevant x <- newIVar let y = last [1..] print "test" --was irrelevant writeIVar x 3 print y Isaac

2 1