- Haskell-Cafe - Haskell.org

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 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