- Haskell-Cafe - Haskell.org

Haddock Parse Errors
by Matthew Bromberg 07 Oct '06

07 Oct '06

I am trying to use Haddock for the first time on windows for a reasonably large project. I must be completely clueless because I seem to generate a lot of parse errors that have no reasonable explanation. In some cases it seems like Haddock is white space sensitive requiring the same indentation as my source code. If so, this is not clearly documented. However consider this example: in my matrix library I have this code snippet: ... -- | class instance Rmatrix, real only matrices instance Matrix Rmatrix where -- | tells us if its a submatrix (better to use pattern matching) issub x = case x of Rindx n -> False Rsubindx n -> True ... This generates a parse error on the line -- | class instance Rmatrix, real only matrices at the first s in class. Removing the | from the comment generates a parse error on the instance declaration even though there are no haddock comments that apply to it! The code prior to this looks something like... -- | copy one matrix into another copy :: m -> m -> m copy a b = mio $ do ka <- pushsub a ... and is part of the class declaration itself. I'm not sure why an auto-documentation tool shouldn't be a bit more forgiving vis a vis it's syntax. Maybe flag errors as warnings but keep on going. I run haddock from the command prompt via the command haddock.exe -o docs -v -h matrix.hs

4 6

Having our cake and eating it too
by Michael Shulman 06 Oct '06

06 Oct '06

This proposal is somewhat tongue in cheek, but at least it's amusing, and who knows, it might be good for something. The idea is that one could, in theory, allow both prefix unary minus and right sections of subtraction, with the type-checker deciding which is meant based on the context. Has this been noticed before? Consider the following code snippet, which runs in GHC 6.6 (with the new ability to define postfix operators). > {-# OPTIONS -fglasgow-exts -fallow-undecidable-instances -fallow-overlapping-instances #-} > module Minus where > import TypeCast > class Minus a b where > (<->) :: a -> b > instance (Num a, TypeCast a b) => Minus a b where > (<->) = typeCast . negate > instance (TypeCast a b, Num b, TypeCast b c) => Minus a (b -> c) where > (<->) x y = typeCast ((typeCast x) - y) (TypeCast is the usual one from HList etc.) Loading this in the interpreter, we now have: *Minus> (1 <->) :: Int -1 *Minus> 3 <-> 1 :: Int 2 *Minus> map (<-> 1) [2..5] [1,2,3,4] *Minus> map (1 <->) [2..5] [-1,-2,-3,-4] *Minus> map (<->) [2..5] :: [Int] [-2,-3,-4,-5] *Minus> zipWith (<->) [1,3,5] [1,2,3] [0,1,2] In short, the operator <-> can be used as *either* an infix subtraction operator (which can be sectioned on both sides) or a postfix unary negation operator (which can also be sectioned once). The trick is the same one used for variadic arguments: the type-checker can infer from context whether (1 <->) should return a number or a function, and resolves it accordingly. Thus, if we could figure out a way to define prefix operators, analogous to the way we can now define postfix operators, we could in theory allow prefix unary minus and right sections of subtraction to coexist peacefully. But I haven't had much luck coming up with a non-ugly suggestion for how to do this. I'd be interested to hear if anyone else has ideas, although I doubt any such solution would ever make it into any Haskell standard. (-: It's also unfortunate that we need the explicit type signatures in the interpreter above, but otherwise there would be no context for type-inference based on the return value. As usual, though, this problem would probably hardly ever arise in an actual program, where most values have a known type. (Actually, I still don't understand why a type signature is necessary on 3 <-> 1; anyone care to enlighten me?) Comments? Mike

1 0

collection monads
by tpledger＠ihug.co.nz 05 Oct '06

05 Oct '06

Matthias Fischmann wrote: > another beginners question about monads: given the type > > | data (Ix x) => Permutation x = Permutation [x] > > i wanted to define > > | instance Monad Permutation where > | return xs = Permutation xs > > but of course nothing about the monad class guarantees xs to be of > type list. the monad class seems unsuitable for holding collections, > and i am inclined to not instantiate permutations. > > just to be sure: is there any easy way to do it that i missed? Do you expect the contained type x to change during a sequence of monadic actions? e.g. would you ever use (>>=) at the type 'Permutation Int -> (Int -> Permutation Bool) -> Permutation Bool'? If not, you could separate each permutation into keys and values: data Permutation k v = Permutation [(k, v)] instance (Ix k) => Monad (Permutation k) Regards, Tom

2 1

Searching all the source code of the world
by Stephane Bortzmeyer 05 Oct '06

05 Oct '06

http://www.google.com/codesearch A great tool (which fulfills a different need than Hoogle) if you are looking for a concrete example of use of such or such function. Unfortunately, "lang:haskell" is not recognized (as a workaround, "file:\.hs" is OK). This has already been reported: http://groups.google.com/group/Google-Code-Search/browse_thread/thread/8c9e…

1 0

haskell vim / my coding aids
by Marc Weber 05 Oct '06

05 Oct '06

I've been busy for some days writing this humbled helper scripts for vim: Goto vim -> by Marc Weber http://www.haskell.org/haskellwiki/Libraries_and_tools/Program_development#… If you find it useful and drop me a line I'll be glad to read your feedback. Marc

1 0

how to create new repository on darcs.haskell.org?
by Bulat Ziganshin 05 Oct '06

05 Oct '06

Hello haskell-cafe, i want to make my library available via darcs repository on darcs.haskell.org. how i can arrange it? if it is required, i already have user account on haskell.org server -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

5 5

Mission: To take args from a list... generally
by tpledger＠ihug.co.nz 05 Oct '06

05 Oct '06

Joel Koerwer wrote: > Let's say I want to evaluate a function of type > (a->a->...->a->a), taking the arguments from a > list. If know the function ahead of time, I can > simply wrap it: > > foo a b c d = ... > wrapFoo (a:b:c:d:_) = foo a b c d > > But, as an exercise, I challenged myself to write > a function, multApply :: (a->a->...->a->a) -> [a] > -> a, that automatically does the wrapping for any > such function. This came up a while ago (but with a list of functions of different arities, all being fed one argument). I found Scott Turner's pure Haskell 98 solution very illuminating: http://www.haskell.org/pipermail/haskell-cafe/2000-November/001332.html Regards, Tom

2 1

seeking paper: Computing with lattices: An application of type classes
by Mathew Mills 05 Oct '06

05 Oct '06

I am not sure how to go about getting a copy of this paper. http://citeseer.ist.psu.edu/context/320255/0 I was hoping someone here could give me a pointer.

1 0

throwDynIO ?
by Carlos Pita 05 Oct '06

05 Oct '06

Hi all! I'm a newcomer to haskell programming with a lisp/scheme background. Last week I've been reading a lot about the monadic approach to IO and I should said I'm pretty fascinated about the flexibility it allows. Currently I'm trying to grasp haskell exception handling and although I find it mostly clear I'm a bit confused regarding the lack of a throwDynIO action "paralelling" throwIO, as there are dynamic variants for the other throw functions: throwDyn - throw throwDynTo - throwTo I understand that the same effect could be conjured up by throwIO (DynException (...))) magic. But the lack of symmetry still disturbes me. Am I missing something? Thank you in advance. Regards, Carlos

1 0

[Haskell] open assistant professorship at Utrecht University, Software Technology
by Doaitse Swierstra 04 Oct '06

04 Oct '06

We have an open 5 year position for an assistant professor. Current areas of interest are: - domain specific embedded languages (especially in the form of combinator languages) - programming language design and implementation - generic programming techniques - tools and methods for building complex systems out of a large number of artefacts in a controlled way - program verification - systems for generating informative feedback to users in the case of inconsistencies in specifications - advanced type systems and their implementation - software generation We strongly believe that the functional programming paradigm is an excellent starting point for many new developments in the above mentioned areas. In our research we try to identify real problems, to find solutions for them, to formalise these, and to build tools in order to convey the solutions to the problem holders. Thus we try to combine sound principles for solving real-life problems. Given the increased pressure on our finances cooperation with industry is of growing importance, which will also hold for this position. Further details can be found at: http://www.cs.uu.nl/vacatures/en/62612.html Doaitse Swierstra _______________________________________________ Haskell mailing list Haskell(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell

1 0

question - which monad to use?
by Tamas K Papp 04 Oct '06

04 Oct '06

Hi, I have a computation where a function is always applied to the previous result. However, this function may not return a value (it involves finding a root numerically, and there may be no zero on the interval). The whole problem has a parameter c0, and the function is also parametrized by the number of steps that have been taken previously. To make things concrete, type Failmessage = Int -- this might be something more complex data Result a = Root a | Failure Failmessage -- guess I could use Either too f :: Double -> Int -> Double 0 -> Result Double f c0 0 _ = c0 f c0 j x = {- computation using x, parameters calculated from c0 and j -} Then c1 = f c0 0 c0 c2 = f c0 1 c1 c3 = f c0 2 c2 ... up to cn. I would like to 1) stop the computation when a Failure occurs, and store that failure 2) keep track of intermediate results up to the point of failure, ie have a list [c1,c2,c3,...] at the end, which would go to cn in the ideal case of no failure. I think that a monad would be the cleanest way to do this. I think I could try writing one (it would be a good exercise, I haven't written a monad before). I would like to know if there is a predefined one which would work. Thank you, Tamas

4 6

throwDynIO ?
by Carlos Pita 04 Oct '06

04 Oct '06

Hi all! I'm a newcomer to haskell programming with a lisp/scheme background. Last week I've been reading a lot about the monadic approach to IO and I should said I'm pretty fascinated about the flexibility it allows. Currently I'm trying to grasp haskell exception handling and although I find it mostly clear I'm a bit confused regarding the lack of a throwDynIO action "paralelling" throwIO, as there are dynamic variants for the other throw functions: throwDyn - throw throwDynTo - throwTo I understand that the same effect could be conjured up by throwIO (DynException (...))) magic. But the lack of symmetry still disturbes me. Am I missing something? Thank you in advance. Regards, Carlos

1 0

irrefutable patterns for existential types / GADTs
by oleg＠pobox.com 04 Oct '06

04 Oct '06

It seems that irrefutable pattern match with existentials is safe. The fact that irrefutable pattern match with GADT is unsafe has been demonstrated back in September 2004. Let us consider the following regular existential data type > data TFoo where > Foo :: Show a => a -> TFoo > Bar :: Int -> TFoo Despite the 'where' syntax, it is NOT GADT; it is just a regular data type. We can write > test_foo vf = case vf of ~(Foo x) -> body Now, if 'x' does not occur in `body', we could have just as well written test_foo vf = body If `x' does occur in body and the scrutinee is not of the form `Foo', then 'x' is undefined, and so 'body' bottoms out when it demands the value of 'x'. No surprise, and no concern here. Let is now consider a GADT > data GTFoo a where > GFoo :: GTFoo Int > GBar :: GTFoo Bool > > test_gfoo :: GTFoo a -> a > test_gfoo vf = case vf of GFoo -> (1::Int) It can be faithfully emulated as follows > -- the data constructors Em_GFoo and Em_GBar must be hidden! > data EmulateGTFoo a = Em_GFoo | Em_GBar > > em_gfoo :: EmulateGTFoo Int > em_gfoo = Em_GFoo > em_gbar :: EmulateGTFoo Bool > em_gbar = Em_GBar The constructors Em_GFoo and Em_GBar should be hidden. The user should use `smart' constructors em_gfoo and em_gbar, which not only set the correct type (Int vs Bool) but also produce the witness, viz. Em_GFoo or Em_GBar. Now, the test_gfoo function should be written as > tesd_emulate_gfoo :: EmulateGTFoo a -> a > tesd_emulate_gfoo vf = case vf of Em_GFoo -> unsafeCoerce (1::Int) So, we test for evidence, Em_GFoo, and if it is presented, we proceed with unsafeCoerce, which generalizes Int to the desired type 'a'. We know this generalization is safe because the evidence Em_GFoo told us that 'a' was really Int. The similarity with Dynamics is uncanny. Now, had we used an irrefutable match instead, we would have proceeded with unsafeCoerce without checking for the evidence. The following code, written back in Sep 13, 2004, shows that the above is not an empty concern. The code did indeed typecheck, with the version of GHC (tidt-branch CVS branch) that existed at that time. Running the code produced the result one'd expect when reading an Int as a Bool. I think the code below was the reason GHC prohibited irrefutable GADT pattern matching since. > {-# OPTIONS -fglasgow-exts #-} > > module Main where > > import Data.IORef > > data T a where > Li:: Int -> T Int > Lb:: Bool -> T Bool > La:: a -> T a > > writeInt:: T a -> IORef a -> IO () > writeInt v ref = case v of > ~(Li x) -> writeIORef ref (1::Int) > > readBool:: T a -> IORef a -> IO () > readBool v ref = case v of > ~(Lb x) -> > readIORef ref >>= (print . not) > > tt::T a -> IO () > tt v = case v of > ~(Li x) -> print "OK" > > main = do > tt (La undefined) > ref <- newIORef undefined > writeInt (La undefined) ref > readBool (La undefined) ref

4 6

Mission: To take args from a list... generally
by Joel Koerwer 04 Oct '06

04 Oct '06

Thanks! Don pointed me to Oleg's page too. I *was* (90%) convinced that this is fundamentally different, but it sure looks similar. Kind of an inside-out polyvariadic function. Any given f only takes n args, but myApply doesn't know the value of n. In fact, a polyvariadic f would cause an infinite loop. At least a stack overflow. Always nice to know you're in good company though. Cheers, Joel On 10/4/06, David House <dmhouse(a)gmail.com> wrote: > Nice work! I haven't tried it out, but you seem to have on the right > trick here: typeclass hackery. An interesting related exercise to > develop a similar function using Template Haskell [1]. Also of note > might be Oleg's writings on true polyvariadic functions [2]. > > [1]: http://haskell.org/th > [2]: http://okmij.org/ftp/Haskell/types.html#polyvar-fn

1 0

Mission: To take args from a list... generally
by Joel Koerwer 04 Oct '06

04 Oct '06

Haskellers, Let's say I want to evaluate a function of type (a->a->...->a->a), taking the arguments from a list. If know the function ahead of time, I can simply wrap it: foo a b c d = ... wrapFoo (a:b:c:d:_) = foo a b c d But, as an exercise, I challenged myself to write a function, multApply :: (a->a->...->a->a) -> [a] -> a, that automatically does the wrapping for any such function. On #haskell Don Stewart suggested I look at printf, but I've yet to put much thought into whether that method will work here. I'm posting my solution in hopes to learn from your comments. This solution uses fundeps, multi-parameter classes, and overlapping instances. Note that I don't actually understand these things! :) ------------------------ MultApply.hs ------------------------------ {-# OPTIONS -fglasgow-exts -fallow-overlapping-instances #-} module MultApply where class MultApply func arg | func -> arg where multApply :: func -> [arg] -> arg instance MultApply (a->a) a where multApply f (x:xs) = f x multApply f _ = error "MultApply: one too few args" instance MultApply cascade a => MultApply (a -> cascade) a where multApply f (x:xs) = multApply (f x) xs multApply f _ = error "MultApply: n too few args" -- some random examples oneArg = multApply sqrt [25..] twoArg = multApply (+) [1..] fiveArg = multApply (\a b c d e -> sqrt ((a+b)^2+(d-e)^2)-5*c) [13..] -------------------End File ------------------------ Results in ghci: *MultApply> oneArg 5.0 *MultApply> fiveArg -47.981487827787404 To compose your own examples in ghci, you'll need -fallow-overlapping-instances on the command line. Cheers, Joel

2 1

layout monads
by Thomas Conway 04 Oct '06

04 Oct '06

Hi All, Next monad query.... [*] In the 1995 paper "Composing Haggis", layout is done using a monad to compose individual elements. To modernize the syntax consider (forgive the operator, but it avoids parentheses): infixl 1 <| f <| x = f x mylayout = do hbox <| do button "ok" button "cancel" It was nice, because you didn't need to worry about temporary structures, variable names, and suchlike. In the 1996 version of the paper, this silently changed to mylayout = do o <- button "ok" c <- button "cancel" hbox [o, c] Does anyone know why the change occurred? IMO, the former was much more elegant. Also, assuming you want to use a different underlying monad (e.g. IO), how would you implement a layout monad. FWIW, I'm not actually interested in widgets per se, but in building html pages in such a way that you can specify the style elements/scripts with the code that creates the nodes of the document tree, but serialize them separately. Tom * Maybe we need a haskell-monads(a)haskell.org list. On second thoughts, no, because it would kill off the other mailingl lists. ;-)

1 0

Either as a Monad instance
by Thomas Conway 04 Oct '06

04 Oct '06

Hi All, I've been [trying to] grapple with the various monads and transformers, and it occurs to me that the standard instance for Either as a monadic type is unnecessarily restrictive. Is there a compelling reason that it is not just instance Monad (Either e) where return = Right (Left e) >>= f = Left e (Right x) >>= f = f x abort = Left Tom

4 5

Mis-understanding something in Haskell interpretation
by Edward Ing 04 Oct '06

04 Oct '06

Hi, I am new to Haskell and am learning Haskell on my own with "The Haskell School of Expression". Unfortunately there is no teacher that comes along with the book. I am having a problem with loading an excerise. I get this message from ghci on a :l Shapes.hs Shapes.hs:40:40: Couldn't match `Side' against `Int' Expected type: Side Inferred type: Int In the first argument of `sin', namely `angle' In the second argument of `(*)', namely `(sin angle)' Failed, modules loaded: none. The source is below. Side is types as Float. My assumption was that Haskell would know how to convert the Int to a float and all would be well. I am I mistaken somewhere? The problem is with the last line. Tips would be appreciated. Source Shapes.hs: module Shapes where data Shape = Rectangle Side Side | Ellipse Radius Radius | RtTriangle Side Side | Polygon [Vertex] deriving Show type Radius = Float type Side = Float type Vertex = (Float, Float) type Angle = Float rectangle :: Shape -> Shape rectangle (Rectangle width height )= Polygon [(0, 0),(0, height), (width, height), (width, 0)] rtTriangle :: Shape -> Shape rtTriangle (RtTriangle width height) = Polygon [(0,0),(0,height), (width, height)] regularPolygon :: Int -> Side -> Shape regularPolygon totalSides sideLength = let initial = (0.0,0.0) in Polygon (initial : vertices initial 1 totalSides sideLength ) vertices :: Vertex -> Int -> Int -> Side -> [Vertex] vertices _ 0 _ _ = [] vertices lastVertex currentSide totalSides length = let currentVertex = vertex lastVertex currentSide totalSides length in currentVertex: vertices currentVertex (totalSides - (currentSide + 1)) totalSides length vertex :: Vertex -> Int -> Int -> Side -> Vertex vertex (a ,b) currentSide totalSides length = let angle = 1.0 * (360 / totalSides) * currentSide in ( a + ( length * (sin angle)), b + ( (*) (cos angle) length ) )

3 2

Haskell compiler from a USB Stick?
by David House 04 Oct '06

04 Oct '06

Hi all. Does anyone know of a Haskell compiler that will run from a USB stick? I think something like Hugs + minimal libraries + WinHugs should be small enough to install onto the stick, but I haven't tested this. That'd be the ideal scenario as I'm teaching Haskell (so won't need complicated libraries) on Windows (so user-friendliness is appreciated; terminals are something to avoid if at all possible). Has this/could this be done? Thanks in advance. -- -David House, dmhouse(a)gmail.com

5 4

collection monads
by Matthias Fischmann 03 Oct '06

03 Oct '06

another beginners question about monads: given the type | data (Ix x) => Permutation x = Permutation [x] i wanted to define | instance Monad Permutation where | return xs = Permutation xs but of course nothing about the monad class guarantees xs to be of type list. the monad class seems unsuitable for holding collections, and i am inclined to not instantiate permutations. just to be sure: is there any easy way to do it that i missed? thanks, matthias

1 0

DiffTime in Data.Time
by Chad Scherrer 03 Oct '06

03 Oct '06

I'm trying to use Data.Time, and I'm totally confused. DiffTime is abstract, and I don't see anything that maps into it. How do I construct one? I would like to then use the result to create a value of type UTCTime, but it seems (currently) like this might be easier. Thanks, -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

2 2

oddity with profiling
by Matthias Fischmann 03 Oct '06

03 Oct '06

hi, i have been staring at a strange profile for a while now, and was wondering whether anybody could give me a hint. (using ghc.6.4. i know i should upgrade, but has the profiler changed after that in particular?) almost all time / memory costs occurs in a CAF cost center. as far as i understand, this means that the evaluation only takes place once each time i run the program, and doesn't depend on the input. Q1. why should one distinguish time spent in top-level constants from time spent in functions? (my program is basically a top-level constant that calls a function i am trying to understand with constant toy arguments.) curiously, the costs inherited by the CAF cost center and caused elsewhere do not show anywhere else, although i am pretty sure the call stack doesn't leave my code for another few levels. Q2. how can i learn which parts of my code causes the CAF cost centers to bloat? and what does it mean if the 100% inherited costs do not show in any other item in the cost center stack in my profile? user manual yields further confusion: | The cost of evaluating any expression in your program is attributed to | a cost-centre stack using the following rules: | | * If the expression is part of the one-off costs of evaluating the | enclosing top-level definition, then costs are attributed to the stack | of lexically enclosing SCC annotations on top of the special CAF | cost-centre. how can an expression be part of the one-off cost of anything? does the second part mean that the SCC annotations are on top of the special CAF cost-center? which is the special CAF cost-center? what does being on top of that mean? sorry, maybe i am just tired... :-/ | * Otherwise, costs are attributed to the stack of | lexically-enclosing SCC annotations, appended to the cost-centre stack | in effect at the call site of the current top-level | definition[7]. Notice that this is a recursive definition. | | * Time spent in foreign code (see Chapter 8, Foreign function | interface (FFI) ) is always attributed to the cost centre in force at | the Haskell call-site of the foreign function. thanks, matthias

1 0

How can I redirect stdout?
by Matthew Bromberg 03 Oct '06

03 Oct '06

I'm reposting this in it's own new thread since I think it involves a general issue beyond exporting Haskell DLLs. I am having some problems with GHCs stdout when a Haskell program is called from a windows program. As I noted earlier I am calling some Haskell code from C as a bridge to being able to ultimately call Haskell from Matlab 6.5. The Haskell code is compiled into a .DLL file on a windows machine. Matlab calls some C code which then calls the Haskell code. As soon as it gets into the Haskell code I get this run time error in ghcDLL.dll <stdout>: hPutChars: invalid argument (Bad File Descriptor) The Haskell code seems to work correctly if called from a stand-alone C program. Moreover, if I scrub all print statements from the Haskell code, it appears to run correctly from Matlab. Matlab does not properly redirect stdout so any printf calls from the C code simply fail to print. However Haskell's behavior is to halt after generating a runtime error. The C code used to generate the Haskell .dll is of course mingw gcc, but the C code used to create my Matlab mex file is Microsoft VC++ 6.0. I tried to redirect stdout using freopen() in C, but that never seems to work with Microsoft. At any rate it certainly doesn't effect Haskells use of stdout. I think in general for windows programs there is no stdout defined, whereas it's always defined for console programs. My question is, is there some way I can redirect stdout from inside Haskell so that all output is sent to a file? Is there an equivalent of freopen() in Haskell that works?

3 2

Problematic irrefutable pattern matching of existentials
by oleg＠pobox.com 03 Oct '06

03 Oct '06

I have come to realize that irrefutable pattern matching of existentials may indeed be problematic. Let us consider the following existential data type > data FE = forall a. Typeable a => Foo a > | forall a. Typeable a => Bar a The following tests type and run (the latter raising the expected exception). > test1 = case (Foo ()) of Foo x -> show $ typeOf x > test2 = case (Bar True) of Foo x -> show $ typeOf x Let us suppose that irrefutable pattern matching of existentials is allowed. What would be the value of the expression case (Bar True) of ~(Foo x) -> show $ typeOf x then? Hopefully not "Bool". One might say that the expression ought to bottom out. However, what reason one may give for that outcome? The only binding in the above expression is of 'x', whose value is never demanded. Indeed, "show $ typeOf (undefined :: ())" yields the non-bottom value "()". One may claim that the existential pattern match also binds an implicit dictionary argument, which is demanded above. That explanation is quite unsatisfactory, because it breaks the abstraction of type classes. The dictionary passing is merely an _implementation technique_ for type classes. Furthermore, it is not the only implementation technique: JHC and Chameleon, for example, use intensional type analysis to implement typeclasses. On a different note, Conor McBride wrote: > It isn't necessary to perform > constructor discrimination when it's statically known that exactly one > constructor is possible, so those patterns can always be made > irrefutable, with matching replaced by projection. that is, in essence, the idea behind `Tagless Staged Interpreters for Typed Languages' Pasalic, Taha, Sheard: ICFP02 It is well-written paper, with an excellent introduction and motivation. Incidentally, one can write their tagless staged interpreter in Haskell as it is. No dependent types are necessary.

3 2

Re: [Haskell-cafe] cumulative sum
by Chad Scherrer 03 Oct '06

03 Oct '06

Tamas, try scanl (+) 0 for the cumulative sum >From there the zipWith idea you mentioned seems like the way to go. -Chad > Hi, > > I have two lists, p and lambda (both are finite). I would like to > calculate > > 1) the cumulative sum of lambda, ie if > > lambda = [lambda1,lambda2,lambda3,...] > > then > > csum lambda = [lambda1,lambda1+lambda2,lambda1+lambda2+lambda3,...] > > 2) the cumulative sum of p*lambda (multiplication elementwise) > > Once I know how to do the first, I know how to do the second I guess > (doing the multiplication using zipWith to get the p*lambda list, but > I would be interested in any other suggestions). Currently I take and > sum, but then I am calculating the same sums many times. > > Thanks, > > Tamas

2 1

cumulative sum
by Tamas K Papp 03 Oct '06

03 Oct '06

Hi, I have two lists, p and lambda (both are finite). I would like to calculate 1) the cumulative sum of lambda, ie if lambda = [lambda1,lambda2,lambda3,...] then csum lambda = [lambda1,lambda1+lambda2,lambda1+lambda2+lambda3,...] 2) the cumulative sum of p*lambda (multiplication elementwise) Once I know how to do the first, I know how to do the second I guess (doing the multiplication using zipWith to get the p*lambda list, but I would be interested in any other suggestions). Currently I take and sum, but then I am calculating the same sums many times. Thanks, Tamas

2 1

non lazy io
by Matt Roberts 02 Oct '06

02 Oct '06

I would like a non-lazy alternative to readFile is there such a thing in the libraries? matt r

3 3

variadic functions and typeCast
by Michael Shulman 02 Oct '06

02 Oct '06

Hi all, I am writing, for my own amusement, a more general version of the trick to implement variadic functions in Haskell outlined at http://okmij.org/ftp/Haskell/vararg-fn.lhs. (If someone else has done this already, please point me to it!) Code is attached at the end of the message. My question concerns the use of `typeCast', which is defined as follows: class TypeCast x y | x -> y, y -> x where typeCast :: x -> y instance TypeCast x x where typeCast = id This is taken from the paper "Strongly typed heterogeneous collections" by Oleg Kiselyov, Ralf Lammel, and Keean Schupke. As observed there, the TypeCast instance declaration must occur in a separate module; otherwise the compiler is too eager about type simplification. (I also get the same errors if VarArg is interpreted by GHCi, even if TypeCast is in a separate module.) I think I understand the reason for this, but I find it a little surprising; it wasn't clear to me from the documentation that fundeps introduce a new dependence on module boundaries. Anyway, my main question about typeCast is this: why is it needed here at all? If I omit it entirely, the code compiles fine, but then using it gives error messages like the following: Prelude VarArg> build 'h' 'i' :: String <interactive>:1:0: No instances for (VarFold [a] [a] [Char], VarAccum Char [a]) arising from use of `build' at <interactive>:1:0-4 ... I don't understand why the type-checker is unable to infer that the type variable `a' should be specialized to `Char' here, since the only available instance of VarFold whose third type is [Char] has the first type also being [Char]. I've given the compiler all the type hints I can think of. Can someone explain this to me? I should say that if I add a functional dependency "l -> a" to the class VarAccum, then this particular example works. However, I have other examples in mind for which l doesn't functionally determine a, so I don't want to do that. And I don't see why it's necessary. Here's the code: class VarAccum a l where accum :: a -> l -> l class VarFold b l r where varFold :: (l -> b) -> l -> r instance (TypeCast b c) => VarFold b l c where varFold f xs = typeCast (f xs) instance (VarFold b l r, VarAccum a l) => VarFold b l (a -> r) where varFold f xs x = varFold f (accum x xs) -- This is the type of variadic functions from lots of As to a B. type a :--> b = forall r. (VarFold b [a] r) => r infixr 0 :--> instance VarAccum a [a] where accum x xs = (x:xs) varArg :: forall a b. ([a] -> b) -> (a :--> b) varArg f = varFold (f . reverse) ([] :: [a]) build :: forall a. a :--> [a] build = varArg (id :: [a] -> [a]) Thanks! Mike

4 8

Re: [Haskell] Replacing and improving pattern guards with PMC syntax
by Brandon Moore 02 Oct '06

02 Oct '06

kahl(a)cas.mcmaster.ca wrote: ... > So far I never considered it important to devise a concrete syntax for PMC, > but triggered by the current pattern guards thread on haskell-prime, > I now try to give a PMC syntax that blends well with Haskell. I think with some alterations your syntax would blend even better. In particular, it would be really nice to have a backwards-compatible syntax. I have designed a slightly different syntax with that goal in mind, which is described in the rest of this message. > One of my gripes with Haskell pattern matching is > that the anonymous variant, namely case expressions, > has an application to an argument built in, > and therefore does not by itself produce a function. > > However, lambda-abstraction already allows single-alternativepattern matching, so I propose to relax this to multi-alternative > pattern matching: >> length = \ >> [] -> 0 >> x : xs -> 1 + length xs I'm with you here. Extending lambda to introduce a layout group of alternatives makes sense even without the rest of the changes to matching. This isn't completely backwards-compatible, but it's pretty close. While we're at it, why not have the identifier of a top level definition introduce a layout group of alternatives, rather than requiring the name to be repeated all the time. How about take 0 _ = [] _ [] = [] n (x:xs) = x : take (pred n) ns > (Lists of alternatives correspond to the ``matchings'' of PMC, > and concatenation of those lists (using ``;'' or layout) corresponds > to matching alternative in PMC. > ``\ m'' then corresponds to ``{| m |}'' in PMC. > ) > > For multi-argument pattern matching, > I propose to allow nested matchings: >> zip = \ >> x : xs -> y : ys -> (x,y) : zip xs ys >> _ -> _ -> [] This deviates from the current syntax of multi-argument lambda, and introduces overloading on ->. Perhaps -> could be reserved for "match and lift", and whitespace could separate several alternatives: zip = \ (x:xs) (y:ys) -> (x,y) : zip xs ys _ _ -> [] There is some tension in the current between argument lists which allow several arguments and require parentheses around constructor applications to delimit patterns, and case expression which match only one item, but without grouping. If we are trying to unify things, perhaps case could be extended to support matching several values together, perhaps separating expressions with commas in the head and using the syntax of a lambda for the cases. Perhaps '=' in function declarations vs. "->" for other matching could also be simplified somehow. I don't have any ideas here. >> take' = \ >> 0 -> _ -> [] >> n -> { [] -> [] >> ; x : xs -> x : take (pred n) xs >> } I'm not sure how to handle a case like this. Introducing layout at whitespace seems a bit excessive, but requiring explicit separators looks a bit heavy on punctuation next to the current grammar, where only records (and perhaps Maybe the '\' could be reiterated to introduce the layout group: take' = \ 0 _ -> [] n \[] -> [] (x:x) -> x : take (pred n) xs > > Pattern guards now can be seen as a special case of > alternatives-level argument application > (``argument supply'' $\righttriangle$ in PMC). > I find it useful to write the argument first, as in PMC. > > I see two options of writing argument supply in Haskell: > either using new keywords, giving rise to the syntax production > > alt -> match exp with alts Maybe reuse "case", unless a new keyword is needed to avoid confusion. > or using a keyword infix operator: > > alt -> exp |> alts > > (Using this kind of argument supply instead of pattern guards > also has the advantage that multiple alternatives become possible.) I'm not using -> to separate patterns, but some leading symbol is required to separate the last pattern from the expression. I like '|' from the current syntax, selected with hopes of incorporating and extending the current guard syntax. I'm pretty sure incorporating the existing guard syntax will require that the grammar keep track whether the last "bit" of the matching was a pattern or a guard (just like currently | switches from patterns separated by whitespace to a list of guards separated by commas). Pattern guards can be translated to matching plus argument supply, so argument supply needs to be part of the primitive matching syntax. I like the suggestion alt | exp |> alts It would be unambiguous but require unbounded lookahead to allow a case to begin with argument supply: foo :: [Int] -> [Int] foo = \lookup env v |> (Just r) [] -> [r] Given argument supply, we can sugar in the existing guard syntax by allowing alt | guard, guards, exp |> alts and alt | guards -> expr The sequence "->\" will transition from guards back to matching more arguments. It might be nice to abbreviate that to '\'. Guards can be eliminated with the translations alt | exp, guards ... ==> alt | exp |> True |guards alt | exp -> expr ==> alt | exp |> True -> expr alt | pat <- exp, guards ==> alt | exp |> {pat | guards ... } alt | pat <- exp -> expr ==> alt | exp |> pat -> expr > > I start with Simon Peyton Jones' standard example: > >> clunky env v1 v2 | Just r1 <- lookup env v1 >> , Just r2 <- lookup env v2 = r1 + r2 >> | otherwise = v1 + v2 I'd like to accepts this unchanged. I think the treatment of guards above will work. > This could now be written using either ``match _ with _'': > >> clunky env v1 v2 = \ >> match lookup env v1 with >> Just r1 -> match lookup env v2 with >> Just r2 -> r1 + r2 >> v1 + v2 > > or infix ``_ |> _'': > >> clunky env v1 v2 = \ >> lookup env v1 |> Just r1 -> >> lookup env v2 |> Just r2 -> r1 + r2 >> v1 + v2 Because I'm using space to separate patterns, I would require parentheses (or the pat <- exp sugar) clunky env v1 v2 | lookup env v1 |> (Just r1) , lookup env v2 |> (Just r2) -> r1 + r2 > Boolean guards are matches against True: >> take = \ >> 0 -> _ -> [] >> n -> match n > 0 with >> True -> >> { [] -> [] >> ; x : xs -> x : take (pred n) xs >> } >> _ -> error "take: negative argument" take = \ 0 _ -> [] n | n > 0 \[] -> [] (x:xs) -> x : take (pred n) ns This syntax has a pretty nice pronunciation, reading | as "such that", a comma as an "and" (between guards), and both space between patterns or '\' after a guard as "and" or "and then" (either way, introducing a pattern for another argument). This PMC stuff seems like a description/semantics for pattern matching. Hopefully my attempts at backwards-compatible syntax help people give the semantics a deeper look. Brandon

1 0

How would you replace a field in a CSV file?
by tpledger＠ihug.co.nz 02 Oct '06

02 Oct '06

Hi Pete. For such a small self-contained task, I don't think Haskell is any better than Python. Haskell would come into its own if you wanted some assurance about type safety, and/or were taking on a task large enough to warrant the use of records (and hence record update notation). Regards, Tom

3 2

[Offtopic] Re: Re: A better syntax for qualified operators?
by Cale Gibbard 01 Oct '06

01 Oct '06

> "What a beautiful world this could be..." ;-)) (*) > > Cheers, > Ben > (*) Donald Fagen (forgot the name of the song) I think I.G.Y. (International Geophysical Year) is it: On that train all graphite and glitter Undersea by rail Ninety minutes from New York to Paris (More leisure time for artists everywhere) A just machine to make big decisions Programmed by fellows with compassion and vision We'll be clean when their work is done We'll be eternally free yes and eternally young What a beautiful world this will be What a glorious time to be free

2 1

irrefutable patterns for existential types / GADTs
by apfelmus＠quantentunnel.de 01 Oct '06

01 Oct '06

Ross Paterson wrote: > The story so far: > apfelmus: why are there no irrefutable patterns for GADTs? > Conor: because you could use them to write unsafeCoerce > Ross: how about irrefutable patterns (or newtypes) for existential types? > Simon: Try giving the translation into System F + (existential) data types I'd like to add that I see no problem with coerce :: Eq a b -> a -> b coerce ~Refl x = x as long as we have coerce _|_ x === _|_ The wish is that f = \refl -> Just . coerce refl = \~Refl x -> Just x should satisfy f _|_ x === Just _|_ f _|_ x =/= _|_ and likewise for any other constructor than Just. Regards, apfelmus

3 5

Re: Why is type 'b' forced to be type 'm a' and not possibly 'm a -> m a'
by tpledger＠ihug.co.nz 01 Oct '06

01 Oct '06

Vivian McPhail wrote: ... > I need the arg a to be evaluated before it gets > passed to a1 and a2. This definition does the right thing > when type 'a' is a function type, because it is not a > value, but with something like 'm a -> (m a -> m a) -> m > a' with Forkable (a -> b) the first arg gets evaluated > twice, to be more concrete: > > With > > (and golden white) eggs > > I want the 'eggs' that is passed to 'golden' to be the > same as the 'eggs' that is passed to 'white', i.e. ... Could you reduce the need for Forkable instances, by rewriting '(and golden white) eggs' as 'and golden white =<< eggs'? Or would the same piece of code also have to handle combinations such as monadic 'and golden white' and non-monadic eggs? [BTW, thanks for giving me a pretext to use the phrase non-monadic eggs!] > Tom suggested that I might be able to use the Reader monad > , but I'm not clear as to how I could do this. Please ignore that. I only mentioned it in case the sole purpose of fork was to propagate a String, which you've now explained is not so. Regards, Tom

1 0

Greetings...
by tpledger＠ihug.co.nz 01 Oct '06

01 Oct '06

Seth Gordon wrote: > I thought I should check and see if anyone > on this list has used Haskell to munge a > ten-million-row database table, and if > there are any particular gotchas I should > watch out for. Are you sure you want to target the data directly? Another approach, that might have a better chance of a quick win within your time frame, is to use Haskell to generate SQL code. That could still reduce the amount of code you maintain by hand. Regards, Tom

1 0

Re: Greetings
by Paul Johnson 01 Oct '06

01 Oct '06

I've done some stuff with maybe 50k rows at a time. A few bits and pieces: 1: I've used HSQL (http://sourceforge.net/project/showfiles.php?group_id=65248) to talk to ODBC databases. Works fine, but possibly a bit slowly. I'm not sure where the delay is: it might just be the network I was running it over. One gotcha: the field function takes a field name, but its not random access. Access the fields in query order or it crashes. 2: For large data sets laziness is your friend. When reading files "getContents" presents an entire file as a list, but its really evaluated lazily. This is implemented using unsafeInterleaveIO. I've never used this, but in theory you should be able to set up a query that returns the entire database as a list and then step through it using lazy evaluation in the same way. 3: You don't say whether these algorithms are just row-by-row algorithms or whether there is something more sophisticated going on. Either way, try to make things into lists and then apply map, fold and filter operations. Its much more declarative and high level when you do it that way. Let us know how you get on. Paul.

3 2

Greetings...
by Seth Gordon 01 Oct '06

01 Oct '06

I've finally gotten enough round tuits to learn Haskell, and now that I've done some of the exercises from _The Haskell School of Expression_ and I finally (think I) understand what a monad is, the language is making a lot more sense to me (although my code is not always making so much sense to the compiler :-). My employer (MetaCarta) makes a search engine that can recognize geographic data. My group within MetaCarta is responsible for building the "Geographic Data Module" within our software. To do this, we slurp a heap of geographic and linguistic data from a variety of sources, normalize it, and then use some algorithms (that I'm not allowed to describe) to generate the module. This seems like the sort of task that cries out for a functional-programming approach, and that's what we use, sorta: a lot of the code that I'm responsible for is SQL, with chains of "CREATE TEMP TABLE X AS [insert very complicated query here]", some C++ for the parts that would be very time-consuming or impossible to implement in SQL, and shell scripts to tie everything together. I told my tech lead that I want to try porting some of this code to Haskell in the hope that it would run faster and/or be easier to read. He said I should spend two work days on the project and then be prepared to convince my co-workers that further research in this vein is (or is not) worth doing. So before I embark on day 1 of the project, I thought I should check and see if anyone on this list has used Haskell to munge a ten-million-row database table, and if there are any particular gotchas I should watch out for. adTHANKSvance....

3 3

Re: [Haskell-cafe] smallest double eps
by Chad Scherrer 01 Oct '06

01 Oct '06

Tamas, You might want to read Joachim's post more carefully - he's trying to help you, and I think he makes a good point. -Chad > > Am Freitag, den 29.09.2006, 19:30 -0400 schrieb Tamas K Papp: > > > the smallest positive floating point number x such that 1+x /= x? > > That would be the smallest positive number, woudn't it? > > > > Do you mean the smalles postive number x with 1+x /= 1? > > Hi Joachim, > > Specifically, I would be happy with the smallest Double that makes the > statement true. I need it as a convergence bound for an iterative > algorithm. Anyhow, thanks for the clarification, but I would be > happier with an answer. > > Tamas > > > ------------------------------ > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > > > End of Haskell-Cafe Digest, Vol 37, Issue 92 > ******************************************** > -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

8 9

cutting long strings into lines
by Andrea Rossato 01 Oct '06

01 Oct '06

Hello! I've been trying for quite some time to find an elegant solution to cut long strings into lines, but the only solution I was able to come up is the following piece of ugly code. Is there a library function for that? What kind of approach would you suggest? Thanks for your kind attention. Andrea Here's the code: -- does the actual job wrapString str = foldr addNL "" $ rmFirstSpace $ concat $ splitS (getIndx $ indx str) str -- gets the indexes of the spaces within a string indx = findIndices (\x -> if x == ' ' then True else False) -- gets the indexes of where to split the string into lines: lines -- must be between 60 and 75 char long getIndx :: [Int] -> [Int] getIndx = takeFirst . checkBound . (delete 0) . nub . map (\x -> if x > 60 && x `rem` 60 >= 0 && x `rem` 70 <= 10 then x else 0) -- groups indexes when their distance is too short checkBound = groupBy (\x y -> if y - x < 10 then True else False) -- takes the first index of a group of indexes takeFirst = map (\(x:xs) -> x) -- split a string given a list of indexes splitS _ [] = [] splitS (x:xs) (ls) = [take x ls] : splitS (map (\i -> i - x) xs) (drop x ls) splitS _ ls = [ls]:[] -- remove the first space from the begging of a string in a list of strings rmFirstSpace = map (\(x:xs) -> if x == ' ' then xs else x:xs) -- used by foldr to fold the list of substrings addNL s s1 = s ++ "\n" ++ s1 try with putStrLn $ wrapString longString where: longString = "The Haskell XML Toolbox (HXT) is a collection of tools for processing XML with Haskell. The core component of the Haskell XML Toolbox is a domain specific language, consisting of a set of combinators, for processing XML trees in a simple and elegant way. The combinator library is based on the concept of arrows. The main component is a validating and namespace aware XML-Parser that supports almost fully the XML 1.0 Standard. Extensions are a validator for RelaxNG and an XPath evaluator."

7 11

Re: [Haskell-cafe] smallest double eps
by Victor Bandur 01 Oct '06

01 Oct '06

-------- Forwarded Message -------- From: Victor Bandur <bandurvp(a)mcmaster.ca> Reply-To: bandurvp(a)mcmaster.ca To: Brandon Moore <brandonm(a)yahoo-inc.com> Subject: Re: [Haskell-cafe] smallest double eps Date: Sat, 30 Sep 2006 20:17:05 -0400 Hi all, I'm new to this mailing list, so my response may be a little out of place, but I think either what's being asked is what is the smallest x such that 1 + x /= 1 (machine epsilon,) or the largest such that 1+x /= x. The bounds seem to be confused. Victor On Sat, 2006-30-09 at 16:10 -0700, Brandon Moore wrote: > Bryan Burgers wrote: > >> >>> Hang on, hang on, now I'm getting confused. > >> >>> First you asked for the smallest (positive) x such that > >> >>> 1+x /= x > >> >>> which is around x=4.5e15. > >> >> > >> >> 1 + 0 /= 0 > >> >> > >> >> 0 is smaller than 4.5e15 > >> >> > >> >> So I don't understand this at all... > >> > > >> > But then 0 isn't positive. > >> > >> Why not? > >> In any case every positive number nust satisfy the above inequation > >> so what > >> about 0.1, which is certainly smaller than 4500000000000000? > People are confusing equality and inequality - > the nontrivial thing here is to find the smallest positive x > that satisfies the equation 1 + x == x. > > In math, every positive number must satisfy the above inequation, that > > is true. But as Chad said, the smallest number in Haskell (at least > > according to my GHC, it could be different with different processors, > > right?) that satisfies the equation is 2.2e-16. > And you've changed the subject - the stuff above was talking about > x + 1 /= x, you're demonstrating solutions to a different problem, > finding the smallest > x such that 1 + x == 1. That's the number often called epsilon. > >> 1 + 2.2e-16 /= 1 > > True > >> 1 + 2.2e-17 /= 1 > > False > Let's stop confusing ourselves about this. > > Brandon > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe

1 0

cant get trivial c2hs to work
by Anatoly Yakovenko 01 Oct '06

01 Oct '06

I am trying to figure out how to use c2hs, so I wrote a wrapper for asin from math.h: $ cat ASin.chs module MySin (mysin) import C2HS #include "math.h" asin::Double -> Double asin xx = {#call fun asin#} xx and this is my main: $ cat Main.hs module Main where import ASin main = do putStrLn $ show $ asin 0.5 `c2hs ASin.chs` generates this: $ cat ASin.hs -- GENERATED by C->Haskell Compiler, version 0.14.5 Travelling Lightly, 12 Dec 2005 (Haskell) -- Edit the ORIGNAL .chs file instead! {-# LINE 1 "ASin.chs" #-}module MySin (mysin) import C2HS asin::Double -> Double asin xx = asin xx foreign import ccall safe "ASin.h asin" asin :: (CDouble -> CDouble) but, when i try to build the wone thing, i get an error that i dont understand: $ ghc -v --make -fffi Main.hs Glasgow Haskell Compiler, Version 6.4.2, for Haskell 98, compiled by GHC version 6.4.2 Using package config file: /usr/lib/ghc-6.4.2/package.conf Hsc static flags: -static *** Chasing dependencies: Chasing modules from: Main.hs *** Deleting temp files Deleting: ASin.chs:2:0: parse error on input `import' So, what am i missing?

1 1

Is Haskell a 5GL?
by David Curran 30 Sep '06

30 Sep '06

Sorry if this comes across as the rant it is. If you are interested in doing useful stuff rather then navel gazing please stop here. Where are compute languages going? I think multi core, distributed, fault tolerant. So you would end up with a computer of the sort envisioned by Hillis in the 80s with his data parallel programs. The only language that seems even close to this model is Erlang. What am I missing about the ability of Haskell to distribute across processors or a network? Say instead of fault tolerant it is fault avoiding. Can proving programs correct (with Haskell) really reduce our workload? http://www.seas.upenn.edu/~sweirich/wmm/03-benton.pdf Finally is Haskell a language for programming or a mental gymnasium that might be the proving ground for concepts in the next popular language? To quote from a post on the topic "Old functional programming ideas " on programming.reddit.com "Church-Turing equivalence tells us that all models of recursive computing have the same formal power. But it tells us nothing about which models are the most effective way for humans to understand and express definitions of functions. For some reason I'd expect researchers in programming languages to have a lot of opinions on this subject. But they don't seem to talk about it much. Instead, a cynical and mean-spirited person might come to the conclusion that PL researchers (such as Wadler) are actually just mathematicians, who happen to have discovered a new name for their specialty which comes with a lot more funding. They certainly seem quite comfortable working in a notation that almost no programmers understand or seem to be learning. If a responsible scientist wanted to counter this cynical, mean-spirited, and generally Luddite and Philistine argument, what would he or she say?"

6 6

Re: [Haskell-cafe] smallest double eps
by Chad Scherrer 30 Sep '06

30 Sep '06

> > Hang on, hang on, now I'm getting confused. > > First you asked for the smallest (positive) x such that > 1+x /= x > which is around x=4.5e15. > Then Joachim wondered if you wanted > 1+x /= 1 > which is around x=2.2e-16. > But not you claim to be looking for the smallest positive number that > a Double can represent. Which is a totally different beast. The > smallest possible Double depends on if you want to accept > denormalized numbers or not. If you don't, then it's about x=4.5e-308. > > Now what is the number you are looking for? > > -- Lennart > This is the point I was confused about also. Joachim seemed to be correcting what might have been a misstatement of the problem.

1 0

smallest double eps
by Tamas K Papp 30 Sep '06

30 Sep '06

Hi, Is there a built-in constant in Haskell (or, if it is compiler-specific, in ghc) that gives the smallest positive floating point number x such that 1+x /= x? Some languages refer to that as double.eps or similar. I need it for numeric algorithms. Thanks, Tamas

3 4

Optimization problem
by Magnus Jonsson 29 Sep '06

29 Sep '06

Dear Haskell Cafe, When programming the other day I ran into this problem. What I want to do is a function that would work like this: splitStreams::Ord a=>[(a,b)]->[(a,[b])] > splitStreams [(3,x),(1,y),(3,z),(2,w)] [(3,[x,z]),(1,[y]),(2,[w])] I don't care about the order that the pairs are output, so the answer could just as well be [(2,[w],(3,[x,z]),(1,[y])]. However I do care about the order of the xyzw:s, so (3,[z,x]) could not be part of the solution in this example. Furthermore it should work on infinite lists. It can't eat the whole list before producing any output. Now, it's not too hard to come up with an inefficient solution that traverses the input list multiple times. For example a sieving solution: import Data.List splitStreams [] = [] splitStreams ((channel,msg):rest) = let (myMsgs,otherMsgs) = partition (\(c,_)->c==channel) rest in (channel, msg : map snd myMsgs) : splitStreams otherMsgs I'm afraid this algorithm is O(n*m) time in the worst case, where n is the length of the input list, and m is the number of unique channels. But is there any way to write it such that each element is touched only once? Or at least an O(n*log(m)) algorithm? Any takers? / Magnus Jonsson

14 43

Optimizing a title matcher
by Lyle Kopnicky 29 Sep '06

29 Sep '06

Hi folks, I'm competing in a contest at work, and we're allowed to use whatever language we want. I decided this was my chance to prove to people that Haskell was up to the challenge. Unfortunately, I ran into performance problems. Since the contest ends this Friday, I've decided to switch to C++ (gasp!). But if any of you have advice on how to speed up this code, it could help me advocate Haskell in the future. It's supposed to match movie titles from an imported database to a reference database. The version I've sent doesn't do anything very smart - it's just doing literal title matches. The first argument to the program is the filename of the table to be imported, and the second is the filename of the reference table. The first line of each table is a pipe-separated list of field names; the rest of the lines are records, each a pipe-separated list of values. The import files each have 3,000 records, and the reference table has 137,986 records. Building the hash tables out of the files is quick - it just takes a few seconds. But doing the matching of title_id in one table to title_id in the other, in a nested loop between both tables, takes way too long. It's matching two import titles (against each of the reference titles) per second. It needs to do at least 20 per second to qualify for the contest, and it's not doing anything fancy yet. I tried various "improvements" to speed it up. One was to specifically use ByteString, eliminating the AbsString class. Didn't make a difference. Another was to use arrays instead of lists to store each record, and precompute the indices of each of the fields within those records. I also iterated over a list of keys instead of the list of Maps, and only converted each record to a Map one at a time, hoping they would be disposed of sooner. Instead of speeding up the program, this slowed it down by a factor of 20! I've profiled it, and I can't make much out of that. It seemed to be spending 25% of its time doing scoring, and I though the problem must be due to laziness, but I'm not sure. So if anyone has any ideas how to speed this up by a factor of at least 10 times, it would be really appreciated! Even the Ruby solutions are doing that, which is embarrassing. Thanks, Lyle

8 11

instance of String illegal
by Adam Hupp 29 Sep '06

29 Sep '06

I am trying to create an instance of a class for String types. I have the following: class Foo a where mkFoo :: a -> String instance Foo String where mkFoo x = x and receive the following error: test.hs:9:0: Illegal instance declaration for `Foo String' (The instance type must be of form (T a b c) where T is not a synonym, and a,b,c are distinct type variables) In the instance declaration for `Foo String' Failed, modules loaded: none. I see that in general I am not able to create an instance of a class for any type [a], where a is a specific type. I can work around it by wrapping my Strings in some other data type but I'd like to understand why it's not possible. Any insight would be appreciated. -Adam

4 3

Creating DLLs with GHC
by Matthew Bromberg 29 Sep '06

29 Sep '06

I am having some difficulty with creating a dynamic link library using GHC on windows XP. I am attempting to follow the example in http://www.haskell.org/ghc/docs/6.4/html/users_guide/win32-dlls.html though I have a binary build of ghc 6.5 My problem (I think) is that some of my Haskell source files link to an external C library also contained in a DLL. I generate my Haskell object files when I compile my Haskell executable. I then attempt to use the object files in a ghc compiler statement like this, ghc --mk-dll -o netsim.dll ExternLib.o ExternLib_stub.o dllNet.o src1.o src1_stub.o src2.o -optl-lmatrixstack -optl-L"." My external C library is in matrixstack.dll and it has a corresponding static link stub library matrixstack.lib in the same directory as all the sources. It has references in one of the sources (say src1.hs). Unfortunately I get a host of undefined references to basically all the functions in matrixstack.dll and also some undefined references of the form Parsefile.o:ghc2996_0.hc:(.text+0x130): undefined reference to `TextziParserCombinatorsziParsecziError_show_closure' Parsefile.o:ghc2996_0.hc:(.text+0x220): undefined reference to `TextziParserCombinatorsziParsecziChar_spaces_closure' Parsefile.o:ghc2996_0.hc:(.text+0x24a): undefined reference to `TextziParserCombinatorsziParsecziChar_spaces_closure' Parsefile.o:ghc2996_0.hc:(.text+0x29c): undefined reference to `TextziParserCombinatorsziParsecziChar_spaces_closure' ... This appears to be coming from unsatisfied references to Text.ParserCombinators.Parsec, which I thought was a standard library. I note that my stand alone haskell executable links just fine and runs perfectly. What am I missing to make this work?

5 9

flip dot
by Greg Fitzgerald 29 Sep '06

29 Sep '06

Since there's talk of removal of the composition operator in Haskell-prime<http://hackage.haskell.org/trac/haskell-prime/wiki/CompositionAsDot>, how about this: Instead of: foo = f . g you write: foo = .g.f A leading dot would mean, "apply all unnamed parameters to the function on the right". A trailing dot would mean, "apply the result of the left to the function on the right". Prelude> notNull = .null.not => [a] -> Bool notNull [1,2,3] => True [1,2,3].notNull => True [1,2,3].null.not => True I like this because it has the same perks as the composition operator, yet it looks like OO code and the data flows nicely from left to right. It reads especially well when using the bind operator on the same line. Thoughts? Thanks, Greg

8 9

Re: Curious Functor Class
by Ashley Yakeley 29 Sep '06

29 Sep '06

On Sep 28, 2006, at 00:38, Jeremy Gibbons wrote: >> Perhaps the key is that there exist types P and Q s.t. there's an >> isomorphism >> >> F a <=> (P -> a,Q) > > F is Naperian iff there's a P with F a = P -> a; but what's the Q for? > >> This seems to be intuitively Napierian: >> >> ln (P -> a,Q) = (P,ln a) | ln Q >> >> I can believe that Hoistables are in fact Idioms, though I know >> there are Idioms that are not Hoistables (Maybe and Either, for >> instance). > > That's right. Every Monad is an Idiom. So are constant functors (F > a = Int) - which I guess a Naperian anyway. Hoistables are not always Idioms, it turns out. I think this can be made a Hoistable, but not an Idiom (because it has a "Q"): type WithInt = (,) Int -- i.e. WithInt a = (Int,a) I don't know if that counts as Napierian or not. >> (Also I think "Idiom" is a better class name than "Applicative".) > > Me too! Can you tell Ross and Conor? I've tried... Hey Ross, Conor, "Idiom" is a better name than "Applicative". Pretty much everyone thinks so. > * > > I don't subscribe to haskell-cafe, so apparently I can't post. Feel > free to post my reply there, if you think it is useful. -- Ashley Yakeley

2 1

source code for haskell web server?
by mvanier 28 Sep '06

28 Sep '06

Does anyone know where I could find the source code for the Haskell web server described in the papers "Tackling the Awkward Squad" by SPJ and "Writing High-Performance Server Applications in Haskell, Case Study: A Haskell Web Server" by Simon Marlow? Thanks in advance, Mike

8 10