May 2011 - Beginners - Haskell.org

Function for working with functions in data?
by Mike Meyer 06 May '11

06 May '11

I'm filling a functional itch that Haskell isn't scratching. I'm looking for a function to take a list of functions, and apply them all to a value. The signature is obvious :: [a -> b] -> a -> [b], and it's nearly trivial to write (\fs a -> map ($ a) [fs]), but Haskell has most useful list functions already provided. I couldn't turn it up in hoogle or the prelude. Am I just missing it somewhere, or is it really not available in a library? Thanks, <mike -- Mike Meyer <mwm(a)mired.org> http://www.mired.org/ Independent Software developer/SCM consultant, email for more information. O< ascii ribbon campaign - stop html mail - www.asciiribbon.org

3 2

Get things from IO monad
by jianqiuchi＠gmail.com 06 May '11

06 May '11

Hi, I have a silly question, Can i get things out of IO monad? for example, function 'anotherFun' doesn't work. genFunc :: IO String anotherFunc :: (Monad m) => m String -- m is a complex monad and is not an IO monad -- m is not an instance of MonadIO so liftIO will not work anotherFunc = do genStr <- genFunc return genStr I just want to get something from IO monad and wrap it with some other monad. Is there anyway to do that? Thanks.

6 6

Haskell GUI library
by Nathan Hüsken 05 May '11

05 May '11

Hey, looking on the haskell homepage, there are a lot of gui libraries (or at least bindings) available. One big difference seems to be that some are based on "Functional Reactive Programming" (I do not know what that is, just read it). So if I want to write a gui in haskell, which library should I use? Which is stable enough? Has anyone experience with some of these gui libraries? Thanks! Nathan

4 4

Return a Foldable instance
by Federico Mastellone 05 May '11

05 May '11

Hi, I want to make a function that returns a Foldable instance, briefly, something like this: import Data.Foldable test :: Foldable f => f Int test = [1,2,3,4] But I get this error: Couldn't match expected type `f' against inferred type `[]' `f' is a rigid type variable bound by the type signature for `test' at Test.hs:3:17 In the expression: [1, 2, 3, 4] In the definition of `test': test = [1, 2, 3, ....] How can I make a function like the one above? I'm creating different implementations of a multimap, using a Set and a [], and instead of providing functions getValuesList and getValuesSet that return a [] and a Set respectively I want to provide a more generic one, getValues that returns a Foldable instance. Thanks!!! -- Federico Mastellone Computer Science Engineer - ITBA ".. there are two ways of constructing a software design: One way is to make it so simple that there are obviously no deficiencies, and the other way is to make it so complicated that there are no obvious deficiencies. The first method is far more difficult." Tony Hoare, 1980 ACM Turing Award Lecture.

11 27

Re: [Haskell-beginners] Return a Foldable instance
by Antoine Latter 04 May '11

04 May '11

On May 4, 2011 1:33 AM, "Federico Mastellone" <fmaste(a)gmail.com> wrote: > > Sorry, the function type was incorrect, is for a part of the multimap, > not the entire multimap. But it's the same problem, a function that > returns a Foldable. > > getValues :: Foldable f => k -> MultiMap k v -> f v > > When the user asks for the values that a certain key contains I want > to return something that is generic and easy to play with while also > taking advantages of the underlying structure functions to avoid > repeated code. Well, "generic and easy to play with" is pretty much the definition of a list. If the only thing the caller is doing with the list is folding over it, the compiler should get rid of the intermediary list anyway, if things work out right. So I think you're worrying too soon. But if this something you want to do anyway, I still don't see what is wrong with: > newtype LookupResult a = L [a] > deriving (Foldable) Then when you change your implementation of the multimap you can change your newtype without affecting the caller. Antoine > > On Wed, May 4, 2011 at 2:51 AM, Chaddaï Fouché <chaddai.fouche(a)gmail.com> wrote: > > On Wed, May 4, 2011 at 7:18 AM, Federico Mastellone <fmaste(a)gmail.com> wrote: > >> Yes, I got confused between haskell type classes and OO classes. > >> > >> I want to create different implementations of a multimap, for example > >> using lists and using Data.Set, and instead of providing functions > >> getValuesList and getValuesSet that return a [] and a Set respectively > >> I want to provide a more generic one, getValues that returns a > >> Foldable and avoid unnecessary conversions to and from lists. This way > >> the user folds directly the underlying structure, without having to > >> worry about which function is the best to fold the values. But I don't > >> know how to do this without an extra intermediate data type. > >> > >> One implementation returns a list and the other a set, both Foldables. > >> But I can't make a function like the one below for this two > >> getValues :: Foldable f => MultiMap k v -> f v > >> > > > > Writing this function given your intention (doing different thing > > depending on the type) is equivalent to writing an instance of > > Foldable for your (MultiMap k). If the underlying structure of your > > multimaps is always foldable, it doesn't make sense to make a function > > like this, the multimaps themselves should be Foldable. This is not > > hard to do, refer to the doc ( > > http://www.haskell.org/ghc/docs/7.0-latest/html/libraries/base-4.3.1.0/Data… > > ) to see how to write a minimal instance of Foldable. > > > > -- > > Jedaï > > > > > > -- > Federico Mastellone > Computer Science Engineer - ITBA > ".. there are two ways of constructing a software design: One way is > to make it so simple that there are obviously no deficiencies, and the > other way is to make it so complicated that there are no obvious > deficiencies. The first method is far more difficult." > > Tony Hoare, 1980 ACM Turing Award Lecture.

1 0

fmap versus bind
by Sean Perry 03 May '11

03 May '11

i came across hlint today and ran it on my experiments. It pointed out places where I was overly cautious with parens or used a $ and forget to remove it later. But one suggestion it made I was curious about. Why does it recommend using fmap over >>=? Idiomatically does fmap make more sense when the Monad is more like a collection? For instance I had "(applyOp op x y) >>= (flip (:) ds)". This seems more clear than "fmap ((:) ds) (applyOp op x y)".

5 6

Re: [Haskell-beginners] fmap versus bind
by Sean Perry 03 May '11

03 May '11

On Tue May 3 8:50 , Felipe Almeida Lessa sent: >On Tue, May 3, 2011 at 12:32 PM, Patrick LeBoutillier >patrick.leboutillier(a)gmail.com> wrote: >> I'm trying to understand this example and I can't get the types to line up. >> Can you provide the "real" types for ds and (applyOp op x y)? >> >> This is what I'm working out: >> >> fmap ((:) ds) (applyOp op x y) >> == fmap (ds :) (applyOp op x y) >> == fmap (\dss -> ds : dss) (applyOp op x y) >> >> (applyOp op x y) >>= (flip (:) ds) >> == (applyOp op x y) >>= (: ds) >> == (applyOp op x y) >>= (\d -> d : ds) >> >> To my untrained eyes is doesn't even look like the code is doing the >> same thing... >> What am I missing here (or more probably where is my mistake)? > >I think that OP forgot a return, i.e., he meant 'applyOp op x y >>= >return . flip (:) ds'. > You are correct, I did forget the return. Sorry for the confusion. This particular bit of code was pulled out of the middle of a RPN calculator. So 'ds' is a list of doubles. applyOp takes 2 numbers and emits a 'm double' which we then want to extract and add to the top of the list. The 'm' is there because I do my calculation in the Either monad to support unknown operators, invalid numbers, etc. A left value in the bind call stops the execution. To my still novice eyes 'foo >>= handleResult' is more readable than 'fmap handleResult foo'. When I look at the fmap call it looks like handlResult is the more important computation.

1 0

Trying to convert from planar NV12 to RGB
by John Obbele 02 May '11

02 May '11

I'm playing with some raw video streams. These raw data provide YUV (or YCrCb) components interleaved between each other and it is sometimes quite cumbersome to find a triplet of matching YUV bytes before converting them to RGB. For "packed" formats such as YUY2, the operation seems pretty straight forward in Haskell: >-- | Converting from packed YUY2 4:2:2 pixels to RGB ones. >-- YUY2: Y0 U0 Y1 V0 < -- 2 macro pixels --> (Y0:U0:V0)+(Y1:U0:V0) >yuy2ToRGB :: B.ByteString -> B.ByteString >yuy2ToRGB bs = f [] bs > where > f acc xs | B.null xs = B.pack $ reverse acc -- > | otherwise = let [y0, u0, y1, v0] = B.unpack (B.take 4 xs) > (r0,g0,b0) = yuv2rgb (y0,u0,v0) > (r1,g1,b1) = yuv2rgb (y1,u0,v0) > in f (b1:g1:r1:b0:g0:r0:acc) (B.drop 4 xs) But on the other hand, I'm having some headaches converting from planar NV12 to RGB. For example, A width=4 and height=4 NV12 frame is stored in a 1-dimensional array of (4 * 4 * 3/2 = 24) elements: | Y00 | Y01 | Y02 | Y03 | Y04 | Y05 | Y06 | Y07 | Y08 | Y09 | Y10 | Y11 | Y12 | Y13 | Y14 | Y15 | U00 | V00 | U01 | V01 | U02 | V02 | U03 | V03 | This array could be unfold to the following matrix representation, and you see that the luminance (Y) bytes are provided first, followed by a sequence of (U,V) pairs. | Y00 | Y01 | Y02 | Y03 | | Y04 | Y05 | Y06 | Y07 | | Y08 | Y09 | Y10 | Y11 | | Y12 | Y13 | Y14 | Y15 | |-----------------------| | U00 | V00 | U01 | V01 | | U02 | V02 | U03 | V03 | Now, if you want to get the RGB value for every pixel, you have to fetch the corresponding (U,V) components at the end of the frame. pixel00 will need (Y00,U00,V00) pixel02 will need (Y02,U01,V01) ... pixel15 will need (Y15,U03,V03) So far, I have this Haskell function to convert NV12 to RGB. >nv12ToRGB w h bs = > B.pack $ concatMap f [0.. w * h - 1] > where > f i = let m = (i `div` w) `div` 2 -- line index modulo 2 > n = (i `rem` w) `div` 2 -- column index modulo 2 > iuv = m * w `div` 2 + n > (r,g,b) = yuv2rgb (pixelY i, pixelU iuv, pixelV iuv) > in [r,g,b] > > pixelY i = B.index bs i > pixelU i = B.index bs (w*h+2*i) > pixelV i = B.index bs (w*h+2*i+1) I don't know if converting ByteString to list, using map with a not-so-simple f function, then concatenating and repacking the ByteString is the best solution one could find in Haskell and I would like to know if by chance some "senior" haskellers would know some tricks (like list comprehension or ByteString.unfoldWhatever) to improve the previous code. regards, /john

1 0

Looking for more information about Pattern Matching
by Graham Hopper 02 May '11

02 May '11

Thanks to all who replied. This is a lot clearer now. Thanks, Graham

1 0

All about monads, exercise 4
by Nathan Hüsken 01 May '11

01 May '11

Hey, I am currently reading "All about monads". Unfortanlty I have only a pdf without the solutions to the exercises. in the previous exercises I defined: data Sheep = Sheep (Maybe Sheep) (Maybe Sheep) father :: Sheep -> Maybe Sheep father (Sheep f m) = f mother :: Sheep -> Maybe Sheep mother (Sheep f m) = m parent :: Sheep -> Maybe Sheep parent s = (mother s) `mplus` (father s) parentList :: Sheep -> [Sheep] parentList s = (maybeToList (mother s)) `mplus` (maybeToList (father s)) Now I am supposed to combine "parent" and "parentList" to a function parent :: MonadPlus m => Sheep -> m Sheep Problem, my parent function relies on "mother" and "father", and they give a Maybe monad. So I need: mother :: MonadPlus m => Sheep -> m Sheep do I not? But I have no Idea of how the body of this function would look. Anyone can give me a hint? Thanks! Nathan but what I really need, is a function

1 1