- Haskell-Cafe - Haskell.org

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 03 Oct '06

03 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 03 Oct '06

03 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 03 Oct '06

03 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