- Beginners - Haskell.org

parsing exif file: binary, binary-strict, or cereal?
by Emmanuel Touzery 13 Apr '14

13 Apr '14

Hello, I could not find a pure haskell library to parse EXIF so I wrote one (pretty basic so far): https://github.com/emmanueltouzery/hsexif I wrote it with binary-strict. I also considered binary, but I would like the library not to throw an exception if the file that it's given is not a JPEG or is a JPEG without EXIF, but rather return an Either. I didn't manage to do that with binary (I mean I could offer an IO monad wrapper with try* but to do that even if you give me a lazy bytestring, when it could be done only with pure code, is annoying). It annoys me to load the full JPEG in memory just to parse its EXIF though. Then again with binary I'd have to be pretty careful with strictness annotations and so on, although parsing the EXIF is going to be fast and it won't contain that much data. Still, I want the lazy bytestring holding the JPEG file to be released ASAP. It'd be a shame to have it lying in memory, together with holding the JPEG file open until the library caller actually makes use of the EXIF contents... And then I realized that binary-strict was last updated in 2010, it seems cereal is recommended for strict binary file parsing nowadays. So, what should I do? Leave it as it is? Port to cereal? Port to binary? Otherwise I did write this because I'd like to make a program to parse EXIF file which will have to run also on windows. The haskell exif parsing library that I could find uses the C library libexif, which is going to get complicated to get running on windows. Plus it was fun :-) Thanks, Emmanuel

2 3

Convert my own types to the Haskell types using typeclass
by ke dou 12 Apr '14

12 Apr '14

Hi, I want to define a typeclass that can convert my own types like MyBool, MyInt, MyOption to according Haskell types -- Bool, Int, Maybe. Currently I can convert the first two types, but for MyOption, I don't how to do, since it is a polymophic type. Here is my toy program: -------------------------------------------------------------- {-# LANGUAGE TypeFamilies #-} module Coercible where import qualified Prelude data MyBool = MyTrue | MyFalse data MyInt = Zero | One | Two data MyOption a = Some a | None class Coercible a where type Return a :: * toHaskell :: a -> (Return a) instance Coercible MyBool where type Return MyBool = Prelude.Bool toHaskell MyTrue = Prelude.True toHaskell MyFalse = Prelude.False instance Coercible MyInt where type Return MyInt = Prelude.Int toHaskell Zero = 0 toHaskell One = 1 toHaskell Two = 2 instance Coercible (MyOption a) where type Return (MyOption a) = Prelude.Maybe a toHaskell (Some a) = Prelude.Just a toHaskell None = Prelude.Nothing -------------------------------------------------------------------------- The problem occurs when I am trying to use "toHaskell (Some MyBool)", the error message is "Not in scope: data constructor `MyBool'". Any hints will be appreciated !! Best, --Ke

4 5

Windows x64 ?
by John M. Dlugosz 12 Apr '14

12 Apr '14

The Haskell Platform has a single download link for "Windows" which seems to be 32-bit only. But GHC is available for Win x64. Their site dissuades downloading their installation and recommends getting Haskell Platform instead. So, is there an easy way to get 64-bit versions of compiler or compiled executables so produced?

1 0

Guards problem
by Stijn Muylle 11 Apr '14

11 Apr '14

All, I ran into a small problem using guards, and I don't really understand what I'm doing wrong. I have this code: ---------------------------------- import Data.List.Split type Cell = Bool data Board = Board [[Cell]] deriving Show trueList = True : trueList createBoard :: Int -> Int -> Board createBoard x y = Board (chunksOf x (take (x * y) trueList)) getCellAt :: Int -> Int -> Board -> Cell getCellAt x y (Board b) | x >= (length b) = False | y >= (length (b !! 0)) = False | otherwise = (b !! x) !! y ----------------------------------- When I try to execute this: getCellAt (-1) 0 $ createBoard 3 3 I get a negative index exception. However, as -1 is smaller than 3 (length of the board), I would expect False to be returned. Am I overlooking something? Thanks! Stijn

3 4

Nonsensical behavior with http-conduit, httpLbs
by Christopher Allen 10 Apr '14

10 Apr '14

Repro'd on GHC 7.8.1 and 7.6.3 Original code is: https://github.com/bitemyapp/bloodhound/ The code only works if I manually (out of band) run insertData (in a REPL) and then run main with the insertData invocation stripped out. If I run main with the insertData invocation included, it throws an exception (head) because the search results are empty. The behavior is as if queryTweet was executing after insertData deleted the index, but before it inserted the new data. The following is a stripped down example: insertData :: IO () insertData = do let encoded = encode exampleTweet _ <- deleteExampleIndex created <- createExampleIndex docCreated <- indexDocument (Server "http://localhost:9200") "twitter" "tweet" exampleTweet "1" print "test" return () el queryTweet :: IO (Either String Tweet) queryTweet = do let queryFilter = BoolFilter (MustMatch (Term "user" "bitemyapp") False) <||> IdentityFilter let search = Search Nothing (Just queryFilter) reply <- searchByIndex testServer "twitter" search let result = eitherDecode (responseBody reply) :: Either String (SearchResult Tweet) let myTweet = fmap (hitSource . head . hits . searchHits) result return myTweet main :: IO () main = do _ <- insertData myTweet <- queryTweet print myTweet further up the call chain, the http call is getting dispatched with http-conduit's gear, the result returned with the expression: withManager $ httpLbs req Included this in case it affects the semantics. Can anybody help? This has stumped me for a couple hours and I couldn't get anything clueful on IRC. Thanks to any that help. --- Chris

2 6

Re: [Haskell-beginners] function not working as expected, type issues (David McBride)
by Alexej Magura 10 Apr '14

10 Apr '14

Thanks displayD :: String -> Int -> IO () displayD string 0 = return () …. is exactly what I was looking for. -- Alexej Magura Sent with Airmail

1 0

Problem combining monads <sigh!>
by John M. Dlugosz 10 Apr '14

10 Apr '14

I think I was looking at the page <http://learnyouahaskell.com/for-a-few-monads-more#state> a few paragraphs under the H3 “The join function”. It mentions “…we wanted to combine several of them into one, be it with <*> or >>=,…” Now I'm actually quite comfortable with Applicative syntax, and am preferring it in places where older texts and examples use monads or fmap etc. (I look forward to an updated standard where Monads are derived from Applicatives.) (Aside: is there a "history" function in GHCi to show the last few commands I typed?) So, I tried a GHCi example starting with: λ>(+7) <$> [1,2,3] λ>[(+7), (*2)] <*> [1,2,3] no sweat. Now use >>= to do the same thing: λ>[(+7), (*2)] >>= [1,2,3] -- nope (I'll spare the error messages, which inspired some of the other things to try, some of which were just to explore the errors themselves) λ>[(+7), (*2)] <<= [1,2,3] -- nope λ>[(+7), (*2)] =<< [1,2,3] -- nope λ>[return (+7), return(*2)] =<< [1,2,3] -- nope (Use a single function as a simpler starting point) λ>(+7) =<< [1,2,3] -- nope λ>return (+7) =<< [1,2,3] -- nope λ>return (+7) >>= [1,2,3] -- nope λ>return [1,2,3] [1,2,3] it :: [Integer] -- just checking λ>[1,2,3] >>= (+7) -- nope λ>[1,2,3] >>= do (+7) -- nope. Error messages are talking about No instance for (Num [b0]) arising from the literal `1' so why is it looking inside the monad at one of the values and thinking that itself should be a list? λ>[1,2,3] >>= [(+7)] -- nope λ>[1,2,3] >>= (+7).return -- nope, but got *two* errors out of that one λ>[1,2,3] >>= liftM(+7) -- nope λ>[1,2,3] >>= liftM(+7) ::[Integer] -- nope λ>[1,2,3] >>= liftM(+7) ::Integer -- nope λ>[1,2,3] >>= liftM((+7) :: Integer -> Integer) -- nope λ>[[1,2,3]] >>= liftM((+7) :: Integer -> Integer) [8,9,10] it :: [Integer] Ah, I'm getting somewhere. But back to the question of why is the element of the list (nondeterminism monad) want its own element to be a list too? λ>return [1,2,3] >>= liftM((+7) :: Integer -> Integer) [8,9,10] it :: [Integer] Same thing. But the list is already a monad, not a bare (scalar) value, so what's going on? λ>[1,2,3] >>= (+7) -- nope λ>[1,2,3] >>= map(+7) -- nope λ>[1,2,3] >>= liftM(+7) -- nope Am I starting to repeat myself? λ>[1,2,3] >>= liftM(+7) ::[Integer] -- nope Give up for the evening. I wonder if that is a record for how many ways it can be incorrect? I'm frustrated, especially since the Applicative syntax worked so easily. But the referenced page and other texts casually say how they are interchangable. Urrrgh! Please enlighten? —John

6 7

How to read: Pearls of Functional Algorithm Design
by Kim-Ee Yeoh 09 Apr '14

09 Apr '14

Bruce earlier emailed about trying to read this book but struggled with not having basics like fold laws and list induction. It turns out there's still a lot to gain from the book even if the mathematical content is out of grasp for now. I've written up some tips on how to get started: http://www.atamo.com/blog/how-to-read-pearls-by-richard-bird-1/ The preamble is a bit long but it helps to keep the big picture firmly in mind. -- Kim-Ee

1 0

monad transformers and laziness
by Dennis Raddle 09 Apr '14

09 Apr '14

I wrote some code as part of my effort to do backtracking search of musical structures. Most recently I wrote a function that "pruned" the search tree by looking for illegal combinations of notes. In the interest of efficiency I wanted this algorithm to terminate as soon as it encountered an illegal combination rather than hunt the entire structure for every illegality. This made me think of the laziness of "or": a function like g = x || y || z will not evaluate y and z if x turns out to be true. I was also writing this code within a stack of monad transformers: State, ErrorT, and WriterT. This was primarily for debugging reasons: I wanted to have ErrorT to give good error messages with context, WriterT to log events for later perusal, and State was there for convenience. I called this monad stack "Er." So the first thing I wrote was something like this: -- return True if an illegal combination is found prune :: Music -> Er Bool prune music = do flags <- forM [0..size music-1] (\ix -> checkOneNote music ix) return $ or flags checkOneNote :: Music -> Int -> Er Bool checkOneNote music ix = do tell $ "Checking note " ++ show ix ++ "\n" -- note: were thunks created by following line left unevaluated thanks to laziness of "or flags" above? doSomething music ix I already knew from past experience that mapM (and forM) evaluate every computation within the list so I wasn't really expecting this to be lazy, and it wasn't. Judging from what was "told" to my MonadWriter, I could see it was checking every note and not stopping early at the first illegal note. My first question is: by any chance was this an illusion through my use of "tell"? What I mean, is that was it leaving thunks unevaluated thanks to the "or flags" expressions lazy behavior, or would it have left them unevaluated if I hadn't had the "tell" there? I rewrote this using this function: pruneRecursive :: Music -> Int -> Int -> Er Bool pruneRecursive music maxIx ix | ix == maxIx = return False | do flag <- checkOneNote music maxIx ix if flag then return True else checkOneNote music maxIx (ix+1) According to the writer messages, this was not doing any unnecessary work. Just wondering if it was really necessary to rewrite this. What if I removed the tell messages later, or put them inside 'when' like this when (debugFlag) (tell ..) and then set debugFlag to False for time-critical program runs? Dennis

1 0

What is a "Monad Comprehension" ?
by John M. Dlugosz 08 Apr '14

08 Apr '14

I know about List Comprehensions, but what is a general Monad Comprehension? List Comprehensions are the use of set-builder notation to define a list, so I don't understand how that would generalize.

4 4