December 2007 - Haskell-Cafe

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

07 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 07 Dec '07

07 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 07 Dec '07

07 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 07 Dec '07

07 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 07 Dec '07

07 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 07 Dec '07

07 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 07 Dec '07

07 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 06 Dec '07

06 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