- Haskell-Cafe - Haskell.org

RE: [Haskell-cafe] arr f
by Sven Biedermann 31 Jan '06

31 Jan '06

Hello Chris, Many thanks for your input. arr _ = error ... Doesn't work, because it will not be possible to use arrow notation. Today I learned that the function type is abstract and so has no constructor I can pattern match against. I don't know, why. Does something break, if Haskell would offer such a constructor? Since I want to use the arrow notation, I had a close look at the following description, taken from http://www.haskell.org/ghc/docs/latest/html/users_guide/arrow-notation.h tml And revised my problem again (sorry): ------------------------------------------------------------------------ ---- 7.7.1. do-notation for commands Another form of command is a form of do-notation. For example, you can write proc x -> do y <- f -< x+1 g -< 2*y let z = x+y t <- h -< x*z returnA -< t+z You can read this much like ordinary do-notation, but with commands in place of monadic expressions. The first line sends the value of x+1 as an input to the arrow f, and matches its output against y. In the next line, the output is discarded. The arrow returnA is defined in the Control.Arrow module as arr id. The above example is treated as an abbreviation for arr (\ x -> (x, x)) >>> first (arr (\ x -> x+1) >>> f) >>> arr (\ (y, x) -> (y, (x, y))) >>> first (arr (\ y -> 2*y) >>> g) >>> arr snd >>> arr (\ (x, y) -> let z = x+y in ((x, z), z)) >>> first (arr (\ (x, z) -> x*z) >>> h) >>> arr (\ (t, z) -> t+z) >>> returnA Note that variables not used later in the composition are projected out. After simplification using rewrite rules (see Section 7.10, "Rewrite rules ") defined in the Control.Arrow module, this reduces to arr (\ x -> (x+1, x)) >>> first f >>> arr (\ (y, x) -> (2*y, (x, y))) >>> first g >>> arr (\ (_, (x, y)) -> let z = x+y in (x*z, z)) >>> first h >>> arr (\ (t, z) -> t+z) ------------------------------------------------------------------------ --- The arrow I want to create is one to track down dependencies. This doesn't seem to work with arrow notation, because in the example above g -< 2*y isn't used in the following statements but is bound to the next arrow: first g >>> arr (\ (****here==> _ ***, (x, y)) -> let z = x+y in (x*z, z)) >>> So, when tracking down dependencies, the result will depend on g. But it does not! In my eyes, it would be better that the whole proc x delivers an arrow of type a b (c,d) instead of a b c with d being piggy backed from g. So I can see on the wrong type of proc x that I missed out connecting something to some other bits. Another solution would be just to skip g. Can somebody tell me, why the arrow notation is as it is? Greetings Sven -----Original Message----- From: Chris Kuklewicz [mailto:haskell@list.mightyreason.com] Sent: Samstag, 28. Januar 2006 18:01 To: Sven Biedermann Cc: haskell-cafe(a)haskell.org Subject: Re: [Haskell-cafe] arr f Sven Biedermann wrote: > Hello Henrik & Ross, > > Man thanks for your input. I have realised that I should have > explained my problem better. > > So, I try... > > I want to create a datatype like this: > > data D a b = DepVoid (a->b) | -- a = () > DepSingle (a->b) | -- a = a simple ones > DepPair (a->b) | -- a = (c,d) > DepTriple (a->b) | -- a = (c,d,e) > ... > DepFun (a->b) -- a = (c->d) > ... You have a serious typing problem in Haskell with that. Every constructor could be replaced with DepSingle. > Its easy to construct them: > > mkArrVoid :: (() -> c) -> D () c > mkArrVoid f = DepVoid f > > mkArrPair :: ((a,b) -> c) -> D (a,b) c > mkArrPair f = DepPair f > > ... > > Now I want to make D an instance of Arrow: > > instance Arrow (D) where -- my problems stems from > arr f = ??? > > I have no clue to glue the mkArr* functions together to reach what I > want: a different Dep* for different functions f. > What can I pattern match, here? What can I do else? This is not easily fixable, since (arr = DepSingle ) is always a valid choice for the compiler to make. Thus typeclass solutions badly overlap. > > Greetings > > Sven > I can come closer with a GADT. The serious typing problem is still there. So I made arr and pure into error messages. {-# OPTIONS -farrows -fglasgow-exts #-} import Control.Arrow -- GADT style data D x y where DepVoid :: (()->b) -> D () b DepSingle :: (a->b) -> D a b DepPair :: ((a1,a2)->b) -> D (a1,a2) b DepFun :: ( (a1->a2) -> b ) -> D (a1->a2) b -- And these are the constructors, so we could skip them mkArrVoid = DepVoid mkArrSingle = DepSingle mkArrPair = DepPair mkArrFun = DepFun -- The destructor is more annoying (template haskell would help) -- http://haskell.org/hawiki/GADT_20with_20record_20syntax might make this easier getF :: D x y -> (x -> y) getF (DepVoid f) = f getF (DepSingle f) = f getF (DepPair f) = f getF (DepFun f) = f -- This is useful for diagnosing which constructor you have, for testing getF' :: D x y -> Int getF' (DepVoid f) = 1 getF' (DepSingle f) = 2 getF' (DepPair f) = 3 getF' (DepFun f) = 4 instance Arrow D where arr _ = error "Use Dep* instead" -- or arr = DepSingle pure _ = error "Use Dep* instead" -- or pure = DepSingle first arrD = let toPair :: (x->y) -> D (x,d) (y,d) toPair f = DepPair (\(b,d) -> (f b,d) ) in toPair (getF arrD) -- (template haskell would help with defining >>>) (>>>) arr1 arr2 = let comp f = (getF arr2) . f in case arr1 of DepVoid f -> DepVoid (comp f) DepSingle f -> DepSingle (comp f) DepPair f -> DepPair (comp f) DepFun f -> DepFun (comp f) -- This >>> loses the constructor info of arr1 but is simpler (>>>>) arr1 arr2 = DepSingle ( (getF arr2) . (getF arr1) )

2 1

library(s) for numeric constant folding?
by Robert Dockins 30 Jan '06

30 Jan '06

Does anyone know of a good library or libraries which will allow me to perform arithmetic operations on 1) binary integers (signed and unsigned) of various fixed sizes? 2) IEEE 754 floating point numbers (single and double precision). Pure Haskell is preferable, but I'll make do with C bindings. I need to do constant folding for integral and floating point types for a compiler front-end, and I'm hoping that I don't have to write this stuff myself.... Why not just use Float and Double for 2) you ask? Because I need to to EXACTLY IEEE 754 computation, and the Haskell report is pretty dodgy about what implementations are required to provide. Thanks Rob Dockins Speak softly and drive a Sherman tank. Laugh hard; it's a long way to the bank. -- TMBG

1 0

Evaluating arithmetic expressions at run time
by Andrew Savige 30 Jan '06

30 Jan '06

Haskell beginner using GHC. I have a function to do some simple arithmetic at run time: myeval :: Int -> Int -> String -> Int myeval x y "+" = (+) x y myeval x y "-" = (-) x y myeval x y "*" = (*) x y -- ... While that works, I'm curious to know if it can be done more elegantly. I'm thinking of something like: myeval :: Int -> Int -> String -> Int myeval x y op = (read op) x y Thanks, /-\ ____________________________________________________ Do you Yahoo!? Listen to over 20 online radio stations and watch the latest music videos on Yahoo! Music. http://au.launch.yahoo.com

7 10

RE: [Haskell-cafe] arr f
by Sven Biedermann 29 Jan '06

29 Jan '06

Hello Henrik & Ross, Man thanks for your input. I have realised that I should have explained my problem better. So, I try... I want to create a datatype like this: data D a b = DepVoid (a->b) | -- a = () DepSingle (a->b) | -- a = a simple ones DepPair (a->b) | -- a = (c,d) DepTriple (a->b) | -- a = (c,d,e) ... DepFun (a->b) -- a = (c->d) ... Its easy to construct them: mkArrVoid :: (() -> c) -> D () c mkArrVoid f = DepVoid f mkArrPair :: ((a,b) -> c) -> D (a,b) c mkArrPair f = DepPair f ... Now I want to make D an instance of Arrow: instance Arrow (D) where -- my problems stems from arr f = ??? I have no clue to glue the mkArr* functions together to reach what I want: a different Dep* for different functions f. What can I pattern match, here? What can I do else? Greetings Sven -----Original Message----- From: Henrik Nilsson [mailto:nhn@Cs.Nott.AC.UK] Sent: Freitag, 27. Januar 2006 21:46 To: Sven Biedermann Cc: haskell-cafe(a)haskell.org Subject: Re: [Haskell-cafe] arr f Hi Sven, > since this is my first post, > > "Hello all" Welcome! > I have a problem with a function taken from class Arrow. > > arr :: (b -> c) -> a b c > > To build my own arrow, i need to distinguish between different kinds > of b or c. For instance, if b has the form (d,e), i want to construct > something different as when having form (d,e,f). I'm not quite sure I understand what you mean. Are you saying that you you want the input to be either a pair or a triple? Then one possibility would be to wrap up the input in the standard Haskell type "Either". For reference, "Either" is defined like this: data Either a b = Left a | Right b Assume g :: T1 -> T2 -> T h :: T1 -> T2 -> T3 -> T for some specific types T1, T2, T3 and T. Now you can define a function "f": f :: Either (T1,t2) (T1,T2,T3) -> T f (Left (x,y)) = g x y f (Right (x,y,z)) = h x y z Thus "f" "distinguish[es] between different kinds" of input. If it is applied to what essentially is a pair, it will compute a result of type "T" using the function "g", whereas if it is applied to what essentially is a triple it will compute a result using the function "h", again of type "T". Lifting "f" into an arrow yields: arr f :: Arrow a => a (Either (T1,T2) (T1,T2,T3)) T I don't know if that was what you really ment by "construct[ing] something different" depending on the input type? Hope that helps, /Henrik -- Henrik Nilsson School of Computer Science and Information Technology The University of Nottingham nhn(a)cs.nott.ac.uk This message has been checked for viruses but the contents of an attachment may still contain software viruses, which could damage your computer system: you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

2 1

arr f
by Sven Biedermann 28 Jan '06

28 Jan '06

Dear Haskellers, since this is my first post, "Hello all" I have a problem with a function taken from class Arrow. arr :: (b -> c) -> a b c To build my own arrow, i need to distinguish between different kinds of b or c. For instance, if b has the form (d,e), i want to construct something different as when having form (d,e,f). Could I get a hint how to express my needs, please! Many thanks in advance Sven Biedermann

3 2

Another idea for record field selection and better namespace management
by Brian Hulley 27 Jan '06

27 Jan '06

Hi - To avoid the problems with so many names being put into a module's namespace, data declarations could implicitly define sub-modules and class/instance declarations as follows: module M where data Foo = FooCon {x : Int} would declare (as seen from inside M) Foo, Foo.FooCon, Foo.x and would further declare x and FooCon as instances of a global value type-class and constructor type class as follows (where //varid denotes the global typeclass corresponding to (a record field called) varid, and //conid denotes the global typeclass corresponding to the constructor conid) class //x a b where x : a -> b instance //x Foo Int where x Foo.FooCon{x=p} = p class //FooCon a b where FooCon : a -> b instance //FooCon Int Foo where FooCon = Foo.FooCon The class declarations (generated by the compiler) are global, and there is no danger of conflicts with user class declarations because of the // prefix. The instance declarations (also generated by the compiler) would be inserted into the module itself. This would give at least three advantages: 1) The same names could be used for fields in more than one data declaration and these would be resolved using the well known type class mechanism 2) Some exciting new programming paradigms become instantly available due to the extension of allowing constructor type classes, namely we could then get the effect of extensible data types eg data Col1 a = One a data Col2 a = One a | Two a useOne :: ( //One col a) => col -> a useOne (One x) = x This is a lot more powerful than just OOP, because we could have different views of a data type, selecting out those components which are relevant to particular operations: data Element = TerminalPunct | TerminalValue | NonTerminal | Push | Pop data Action = Push | Pop data Insertion = TerminalValue | NonTerminal | Push without having to artificially construct various injections... 3) If x is a record field, then because a typeclass and instance has been automatically generated, (x p) already uses the type of p to determine which overloaded x to use, so all that remains is to introduce a sugar to get a form of function application syntax that binds stronger than prefix application. I suggest p^x === (x p) It is still possible to be completely explicit, by writing P.x p or p^P.x I think this solves all the problems that I had with the value space idea, and is also a fairly conservative extension to Haskell as it stands at the moment, except I wonder if it is possible to implement type classes for constructors? Regards, Brian.

1 2

graphics Windows Programming
by Andrew U. Frank 26 Jan '06

26 Jan '06

There are several graphics packages to select from... But which one is the easiest to work with for students for a ghci - windows environment. I sense that cairo / gtk2hs does not support ghci. >From the HOpenGL home page I cannot find out what I would need to download for a windows environment (can somebody point me to the right direction?). We have used SOE under hugs but I sense it is not working with ghci? We found it also somewhat deficient for graphics beyond the content of the book - has it been extended and improved? Any advice greatly appreciated! Andrew Frank

2 1

HitchhickersGuideToTheHaskell - Chapter 3 ...
by Dmitry Astapov 26 Jan '06

26 Jan '06

... which deals with QuickCheck and type classes, have been uploaded to http://www.haskell.org/hawiki/HitchhickersGuideToTheHaskell. Any feedback and criticism is gratly appreciated! -- Dmitry Astapov //ADEpt GPG KeyID/fprint: F5D7639D/CA36 E6C4 815D 434D 0498 2B08 7867 4860 F5D7 639D

1 0

Printing functions
by Creighton Hogg 26 Jan '06

26 Jan '06

Hi, I'm working on writing a genetic programming system in Haskell, and I wanted to know what might be a good way to print out the programs that are being generated. There's no instance of Show for functions, but I'd really like to see what's happening so that I know if it's working right. What should I try?

2 1

Hashtable woes
by Chris Kuklewicz 26 Jan '06

26 Jan '06

Hello, This post is a about a tangential issue to the shootout, not the shootout itself. It concerns the lack of a fast mutable hashtable. If you have a good replacement for Data.Hashtable, I would be interested to know about it (and so would the wiki!). The shootout entry "k-nucleotide" is a good test of the hashtable provided by each of the languages: http://shootout.alioth.debian.org/gp4/benchmark.php?test=knucleotide&lang=a… Several of us are building a proposed entry on the wiki at http://haskell.org/hawiki/KnucleotideEntry where I have just posted a plea which I will paste below: On mutable data structures in Haskell This benchmark is completely bottlenecked by Data.Hashtable (in GHC 6.4.1) and this discussion is based on the assumption that I am using Hashtable optimally. I downloaded the GHD 0.17 compiler and the DMD entry to benchmark on my machine. The DMD entry uses the "associative arrays" built into the language: "int[char[]] frequencies" and places [WWW]second (runs in 3.0s). The winning entry is interesting, since the c-code does not have a hash table, and so it uses #include "../../Include/simple_hash.h" which pulls in a dead simple, inline, string to int hashtable and runs in 2s. The entry below runs 16 slower than the DMD entry on my powerbook G4. Profiling shows the bottleneck. I downloaded simple_hash.h and shamelessly optimized it to replace Data.Hashtable for exactly this benchmark code. This sped up the proposed entry by a factor of 4.1 so that it is now about a factor of 4 slower than the DMD entry. This shows that Data.Hashtable is doing *at least* four times more work that is needed for this usage pattern. And even with my over specialized hash table, Haskell is almost 50% slower than OCaml's "module H = Hashtbl.Make(S)" (note that I my code uses the same hash function as OCaml). Unfortunately I cannot submit this optimized hash table entry to the shootout. The only mutable data structure that come with GHC besides arrays is Data.Hashtable, which is not comptetitive with OCaml Hashtbl or DMD's associative arrays (unless there is something great hidden under Data.Graph). Is there any hope for GHC 6.6? Does anyone have pointers to an existing library at all? Perl and Python and Lua also have excellent built in hashtable capabilities. Where is a good library for Haskell? -- Chris Kuklewicz

5 6