January 2006 - Haskell-Cafe

Creating static libraries using GHC
by Tom Hawkins 16 Mar '07

16 Mar '07

I have a chunk of Haskell code I would like wrap up and distribute as a library. Is there a way to build a static library (*.a) that includes my code plus the Haskell runtime, which C programs can easily link against? Here is what I have tried so far... ghc --make -fffi MyLib # Builds MyLib.o and MyLib_stub.o. gcc -c -I/usr/local/lib/ghc-6.4.1/include MyLibWrapper.c ar -r libMyLib.a MyLib.o MyLib_stub.o MyLibWrapper.o This works fine when I use ghc to compile and link a C program... ghc main.c libMyLib.a But if I use gcc, it throws a lot of unresolved references. I have no problem compiling with ghc, but the folks using my library probably won't have it installed. I added -v to ghc to see how it calls gcc; it seems to link in different libraries based on what Haskell libraries are being used, and it undefines a bunch is symbol references. Are there any switches to have ghc return a single archive with everything included? Please excuse my ignorance of the linking process. Thanks for any help! -Tom

3 2

matrix computations based on the GSL
by Alberto Ruiz 21 Apr '06

21 Apr '06

Hello all! This is my first message to the list. In my work I often need linear algebra algorithms and other numeric computations. An option is using scientific computing systems like Matlab, Mathematica, Maple, etc. In Haskell there are several modules and bindings to matrix libraries; many of them are excellent. But I think that Haskell would be even more attractive if the basic matrix computations (what we find, for example, in the GNU Octave Quick Reference) were easily available in a standard library. We have all we need: an interactive environment, excellent graphics (HOpenGL), FFI and ForeignPtr with automatic garbage collection, QuickCheck, etc. Computations can be implemented by the GSL (GNU Scientific Library), a well designed numerical library written in C. Well... I know that I am trying to reinvent the wheel: I am working on a user friendly functional interface to matrix computations based on the GSL. I think that many numeric problems that can be solved using Octave or a similar system can be also solved more elegantly using Haskell. The library is very preliminary and incomplete but some simple problems can already be solved. The sources, haddock documentation and the draft of a tutorial can be found at: http://dis.um.es/~alberto/hmatrix/matrix.html I am not a Haskell expert, I only use the most basic programming techniques, so any suggestion will be greatly appreciated... Alberto

22 97

RE: [Haskell-cafe] generics question, logical variables
by Ralf Lammel 03 Apr '06

03 Apr '06

Frederik, > As for your code example, it looks very interesting, but are you > saying that this could turn into an extension of the Data.Generics > library, or that this is something I could be implementing in terms of > what's already there? The posted code works with GHC 6.4 (SYB2) intentionally and actually. I have attached another attempt (again GHC 6.4, based on SYB2) which might be more useful for your purposes, and it may be useful in general, in fact. What I defined this time is a "certainty-improving" function: idify :: (Typeable1 f, Monad m, Data (a f), Data (a Id)) => (forall a. f a -> m a) -> a f -> m (a Id) That is, the function "idify get" takes a value whose type is parameterized in a type constructor f (such as Maybe or IORef), and the function attempts to establish Id instead of f on the basis of the function argument "get". > What is the 'a' parameter for in "force"? > > force :: ( Data (t Maybe a) > , Data (t Id a) > , Term t Maybe a > , Term t Id a > ) => t Maybe a -> t Id a The previous attempt was a more parameterized blow than required in your case. (I was guessing about what "typed logical variables" could mean. I was assuming that you would need some extra layer of embedding types on top of the Haskell term types. Looking at your code, this was not the case.) > For the part which I asked for help with, to get around my trouble > with generics, I defined a class GenFunctor and an example instance. > The intent is that generics should be able to provide this > functionality automatically later on, but you can see what the > functionality is. Let's look at the type of your GenFunctor: class GenFunctor f where gfmapM :: (Monad m, FunctorM b) => (forall x . a x -> m (b x)) -> f a -> m (f b) This type can be seen as a more relaxed version of the idify operation above. That is, idify fixes GenFunctor's b to Id. The particular encoding of idify (attached) takes advantage of this restriction. I wonder whether I should bother. (Exercise for reader :-)) > However, I am stuck on something else, the program doesn't typecheck > because of use of another function I defined, 'cast1'. Maybe you can > take a look. I had thought that I would be able to write a generic > 'unify' but I get the error: > > GenLogVar.hs:82:19: > Ambiguous type variable `a' in the constraint: > `Data a' arising from use of `cast1' at GenLogVar.hs:82:19-23 > Probable fix: add a type signature that fixes these type variable(s) > > This is because I need to do something special when I encounter a > "Var" variable in unification, but the compiler seems to not like the > fact that the type argument of the Var data type is not known. Please try to avoid new cast operations at all costs. :-) Your code can be arranged as follows: (i) Use extQ1 to dispatch to a special case for "Var x" for the first argument. (ii) In this special case, use again ext1Q to dispatch to a special case for "Var y" for the second argument. (iii) At this point, *cast* the variable value of *one* variable to the type of the other. So the problem with your code, as it stands, is that the target type of cast is ambiguous because you cast *both* arguments. The insight is to make the cast asymmetric. Then, not even polymorphism is in our way. Interesting stuff! Ralf

2 2

EclipseFP (Haskell IDE) 0.9.1 released
by Thiago Arrais 07 Feb '06

07 Feb '06

EclipseFP 0.9.1 has been released since last Friday. It is an open-source development environment for Haskell code. EclipseFP integrates GHC with an Haskell-aware code editor and also supports quick file browsing through an outline view, automatic building/compiling and quick one-button code execution. Downloads and more information are available on the project home page http://eclipsefp.sourceforge.net/ We are open for comments and general discussion. Actually we would really appreciate comments from both newbie and veteran Haskell programmers. This is open-source development and everyone on the Haskell community is welcome to participate. Cheers, Thiago Arrais

9 12

Haskell to call Microsoft COM (Dispatch)
by Gracjan Polak 05 Feb '06

05 Feb '06

Hi all, Is there any library to make Haskell call Microsoft COM functions using Dispatch? E.g I don't need the full COM binary functionality, scripting is enough. Google didn't seem to find anything interesting... beside rolling my own using FFI :) Thanks in advance! -- Gracjan

5 6

Known Unknowns
by Chris Kuklewicz 03 Feb '06

03 Feb '06

There is a new combined benchmark, "partial sums" that subsumes several earlier benchmarks and runs 9 different numerical calculations: http://haskell.org/hawiki/PartialSumsEntry I took the Clean entry and, since there were so many recursive computations, I made compute and altCompute higher order functions. No speed optimization work has been done yet, but it seems really fast. A new http://haskell.org/hawiki/KnucleotideEntry has been accepted, replacing the one with the memory leak. The speed is also better, but still poor, due to Data.Hashtable. GHC 6.6.x should eventually help. Also on the topic of poor speed: http://haskell.org/hawiki/NbodyEntry At the bottom of the page is Einar's really cool existing entry (open mutable records). At the top of the page is best effort to replace it, but it runs at almost the same speed. Which is very much slower (10x) than other entries, such as OCaml. It is odd that small scale numerics, such as the partial-sums functions, can be made fast but not medium scale numerics like the n-body integration. There are 5 fixed mass parameters and 30 variables (5*3 positions + 5*3 velocities). Addition, Subtraction, Multiplication, Division. And we can't get it going nearly as fast as it ought to run. Note: The garbage collector is not a factor (%GC time 0.9%). Like the Hashtable glitch, if this were part of real program then a small bit of c-code could be attached via FFI. Are there little known Haskell idioms for doing math? Do we have to write a recursive function with 30 separate parameters? Do we have to peek and poke unboxed doubles? Is there an undocumented -funleash-fortran parameter? Will this be fixable in Haskell' ("Haskell-Prime")?

7 18

unary pattern matching
by John Meacham 01 Feb '06

01 Feb '06

I have often wanted a shorthand syntax for testing if a value matches a given pattern. I want to implement such an extension for jhc but can't decide an appropriate syntax so I thought I'd ask the group. basically I want something like /Left (Just _)/ expands to \x -> case x of Left (Just _) -> True _ -> False so you can do things like when (/Just _/ x) $ putStrLn "x is something" or map /Left (Foo _ 'x')/ xs to get a list of booleans saying whether the xs match or not. however, the '/' syntax clearly doesn't work, nor would anything that conflicts with normal haskell syntax. does anyone have any better ideas? John -- John Meacham - ⑆repetae.net⑆john⑈

7 8

point-free simplification algoritm.
by Nuno Pinto 31 Jan '06

31 Jan '06

Since it's my first post, hi all! I have been reading this for some days but only now i decided to write something. I am researching a to build a computer assisted simplification algorithm used to simplify pointfree expression.. Example. If i give the program: fst . snd . id . id it will return: fst . snd. it wil also show all steps it made to reach that goal. to do this we must have the laws (such as f. id = f) that help us doing this defined. the program uses a datatype such as: data ExpTree v c = Var v | Term c [ExpTree] exp :: Exp Char PF exp = Term Comp [Term Comp [Term Fst [], Term Comp [Term Snd [], Term Id []]], Term Id []] I have previously defined the catamorphism, hylo and anamorphism for this data type, so recursion is insured. I have also implemented a generic calculador that, given a list of functions will try to aply them and returns the best simplification aswell as the steps made to reach it. I am now trying to implement such functions in a "decent" way, but i am however interested in the theory behind all this. I am looking for algorithms that will help me efficiently simplify the expression to the fullest. I am also interested in knowing what zygomorphisms and paramorphisms are? and how can u build a gcata?? (a cata for all datatypes). I head about "proof-by-exhaustion" and "four color theorem" beeing used to make mathematical proves such as this ones, but i have never seen any example of such and would like to see it, if possible, in haskell.. If anyone can help me find what im looking for, a decent mathematical proofing algoritm.. or just tell me what it is that im looking for :P. or even contribute with any ideas, it would be very much aprecciated. :) TY, and Hi all :D :) and have fun coding haskell :) _________________________________________________________________ Don't just search. Find. Check out the new MSN Search! http://search.msn.click-url.com/go/onm00200636ave/direct/01/

2 1

Correct usage of MonadError, ErrorT?
by Daniel 31 Jan '06

31 Jan '06

Hi, I've got some functions in MonadError with different Error types. I would like to map errors of one Error type onto the other Error type. It seems that the only facility for doing this is mapErrorT, but that seems to force me to work in ErrorT rather than any old instance of MonadError. Am I barking up the wrong tree trying to keep the functions generalised over MonadError? Is there some other paradigm I should use for passing errors across system layers in haskell? I would like to do something like the following, but I don't know how to achieve the 'mapError errMap' part of g. instance Error Int where strMsg s = 0 f :: (MonadError Int m, MonadIO m) => Int -> m String f 0 = do liftIO $ putStrLn "The int is 0, that'll be an error." throwError (-27) f i = do liftIO $ putStrLn ("The int is " ++ show i ++ ", we'll do the division.") return $ show (100 `div` i) g :: (MonadError String m, MonadIO m) => Int -> m String g i = do liftIO $ putStrLn ("Will try to divide by " ++ show i) mapError errMap (f i) h :: (MonadIO m) => Int -> m String h i = (runErrorT (g i)) >>= either (\e -> return ("had an error: " ++ e)) return Thanks Daniel

4 4

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

30 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