February 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

haskell programming guidelines
by Christian Maeder 28 Mar '06

28 Mar '06

Hi, haskell admits many programming styles and I find it important that several developers of a prject agree on a certain style to ease code review. I've set up guidelines (still as plain text) for our (hets) project in http://www.informatik.uni-bremen.de/agbkb/forschung/formal_methods/CoFI/het… These were inspired by C programming guidelines, http://haskell.org/hawiki/ThingsToAvoid and the problems I came across myself. It like to get comments or proposals for our or other haskell grogramming guidelines. Thanks Christian

10 31

RE: [Haskell-cafe] library sort
by Simon Peyton-Jones 08 Mar '06

08 Mar '06

Strangely, Hoogle isn't easy to find at haskell.org. I'm not sure where the best place to add a link would be: perhaps near the top of the libraries-and-tools page? It's all wikified now, so would someone like to add it somewhere appropriate? Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of | Radu Grigore | Sent: 17 February 2006 14:11 | To: Haskell Cafe | Subject: Re: [Haskell-cafe] library sort | | On 2/16/06, Jared Updike <jupdike(a)gmail.com> wrote: | > If you need an easier way to search the Haskell APIs, use Hoogle: | | Hoogle is very nice. Thanks to everyone who answered my question about | finding a sort library function. | | -- | regards, | radu | http://rgrig.blogspot.com/

4 8

PrefixMap: code review request
by David F.Place 07 Mar '06

07 Mar '06

Hi, I'm a newish Haskell hacker with way too much experience hacking Lisp. At first, I found my Haskell code looking very lisp-y. I think my code is becoming more idiomatic haskell. I would be very grateful to anyone who would take a glance at the code below and point out any un-idiomatic usages that jump out. It's a small module from a program which looks for palindromes in a list of words. Thanks very much. Cheers, David \begin{code} {-# OPTIONS -O2 -optc-O3 #-} module PrefixMap (PrefixMap,fromDistinctAscPairList,searchMap) where import Data.List import qualified Data.Map as Map import Test.HUnit \end{code} The PrefixMap datastructure implements a Prefix Tree which allows a key/value relationship. \begin{code} data PrefixMap k v = Node (Maybe v) (Map.Map k (PrefixMap k v)) deriving (Show) \end{code} A PrefixMap is built from an alphabet enumerating the possible constituents of keys and a list of pairs of keys and objects. A key is a string of elements of the alphabet. The list must be distinct and in ascending order. The constraint is not checked. \begin{code} fromDistinctAscPairList :: Ord k => [k]->[([k],v)]->PrefixMap k v fromDistinctAscPairList alphabet pairList = build alphabet Nothing (partList pairList alphabet) partList :: Ord k => [([k],v)]->[k]->[(k,[([k],v)])] partList pairs alphabet = reverse . fst $ foldl' f ([],pairs) alphabet where f (result,pairs) l = (result',rest) where (part,rest) = span ((==l) . head . fst) pairs result' = if null part then result else (l,part):result build :: Ord k => [k]->(Maybe v)->[(k,[([k],v)])]->(PrefixMap k v) build alphabet val pairs = Node val $ Map.fromDistinctAscList treePairs where treePairs = [(c,mkITree l)|(c,l)<-pairs] mkITree l = build alphabet x (partList l' alphabet) where (x,l') = findNode $ snipKeys l snipKeys :: Ord k => [([k],v)]->[([k],v)] snipKeys l = [(k,v) | (_:k,v) <- l] findNode :: Ord k => [([k], v)] -> (Maybe v, [([k], v)]) findNode l = if null suffix then (Nothing,l) else ((Just $ snd.head $ suffix),prefix++(tail suffix)) where (prefix,suffix) = span (not.null.fst) l \end{code} searchMap applies a function to each object in the PrefixTree that is on the path specified by the key and the subtree below it and returns a list of the results. \begin{code} searchMap :: Ord k => (v -> vv) -> [k] -> PrefixMap k v -> [vv] searchMap f [] t = walk f t [] searchMap f (k:ks) (Node v al) = maybe rest ((:rest) . f) v where rest = maybe [] (searchMap f ks) (Map.lookup k al) walk :: (a -> b) -> PrefixMap k a -> [b] -> [b] walk f (Node Nothing al) z = Map.fold (walk f) z al walk f (Node (Just x) al) z = Map.fold (walk f) (f x:z) al test1 = TestCase (do input <- readFile "words.txt" let dict = words input pairs = zip dict dict alpha = ['a'..'z'] ftree = fromDistinctAscPairList alpha pairs fAnswer = searchMap id "assert" ftree rtree = fromDistinctAscPairList alpha $ sort $ zip (map reverse dict) dict rAnswer = searchMap id "tressa" rtree assertEqual "forward search" ["as","ass","assertedly","asserted", "asserters","asserter","asserting", "assertions","assertion","assertively", "assertivenesses","assertiveness", "assertive","assertors","assertor", "asserts","assert"] fAnswer assertEqual "reverse search" ["reassert","overassert","assert"] rAnswer ) tests = TestList [TestLabel "Tree Test" test1] \end{code} \end{document} -------------------------------- David F. Place mailto:d@vidplace.com

16 38

rounding errors with real numbers.
by Matthias Fischmann 03 Mar '06

03 Mar '06

hi, I think this is the well-known issue of using real numbers in decimal representation on a machine that thinks binary, but I don't know what to do with it, and some of you maybe do. I want to shift+stretch a list of doubles into a given interval. example: | x1 = [2, 3, 4, 5, 10] | y1 = normInterval x1 0 1 | => y1 = [0.0,0.125,0.25,0.375,1.0] The function that does this looks something like this: | normInterval :: [Double] -> Double -> Double -> [Double] | normInterval ps lower upper = map (\ x -> (x - oldLower) * stretch + lower) ps | where | oldLower = head ps | oldUpper = last ps | stretch = (upper - lower) / (oldUpper - oldLower) However, with bigger numbers I get rounding errors: | x2 = [0.0,1.9569471624266144e-3,5.870841487279843e-3,1.5655577299412915e-2,3.913894324853229e-2,9.393346379647749e-2,0.2191780821917808,0.5009784735812133,1.1272015655577299,2.504892367906066] | y2 = normInterval x2 0 1 | => y2 = [0.0,7.8125e-4,2.3437500000000003e-3,6.25e-3,1.5625000000000003e-2,3.7500000000000006e-2,8.750000000000001e-2,0.2,0.45000000000000007,0.9999999999999999] The solution that pops to my mind is very simple: | normInterval :: [Double] -> Double -> Double -> [Double] | normInterval ps lower upper = repair (map (\ x -> (x - oldLower) * stretch + lower) ps) | where | oldLower = head ps | oldUpper = last ps | stretch = (upper - lower) / (oldUpper - oldLower) | | -- fix rounding error: | repair [i] = [upper] | repair (h:t) = h : repair t It works, but it's ugly. Is there a better way to do this? Thanks, Matthias

7 14

module for probability distributions
by Matthias Fischmann 01 Mar '06

01 Mar '06

hei again, (-: I wrote a module for sampling arbitrary probability distribution, so far including normal (gaussian) and uniform. http://www.wiwi.hu-berlin.de/~fis/code/ For those who need something like this: feel free to take it, it's BSD. For those who feel like growing their karma: - There are a few questions in the code (marked with 'XXX'). - There are probably far better way to do this. I am eager to learn. - There is probably a better implementation out there already. Please point me to it. cheers, Matthias

3 2

enforcing strictness on arbitrary subexpressions
by Matthias Fischmann 01 Mar '06

01 Mar '06

hei, I want to force evaluation on an arbitrary expression. What I have found is only strict datatypes (the '!' thing), but not a strictness idiom for arbitrary subexpressions. (I want this for debugging mostly, so if there is a better way to unsafePerformIO something in one piece I would be happy with that, too.) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ veryLongString = "..." data StrictThingy = StrictThingy ! String main :: IO () main = do hPutStr stdout veryLongString -- lazy veryLongString `seq` hPutStr stdout veryLongString -- still lazy? (StrictThingy veryLongString) `seq` hPutStr stdout veryLongString -- strict (or at least i hope it is) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Problem with the last line is that it doesn't work for arbitrary types, and it's kind of ugly. What I would like to have is something like: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ hPutStr stdout ! veryLongString ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ but I guess it's not that easy? Sorry for asking without consulting the list archives, but I promise I'll add it to the faq in the wiki once i understood. (-: I am using ghci and ghc, latest ubuntu package, but I am happy to switch to new versions. thanks, matthias

3 3

Picking a shell for runCommand
by Tom Hawkins 28 Feb '06

28 Feb '06

It appears runCommand uses /bin/sh by default, but our environment needs tcsh. Is there any way to set an alternative shell? -Tom

2 1