September 2011 - Beginners

回复： a parse error....i can't fix it
by anyzhen 09 Sep '11

09 Sep '11

a ha ... thanks Daniel ------------------ 原始邮件 ------------------ 发件人: "Daniel Fischer"; 发送时间: 2011年9月9日(星期五) 晚上11:06 收件人: "beginners"; 抄送: "anyzhen"; 主题: Re: [Haskell-beginners] a parse error....i can't fix it On Friday 09 September 2011, 16:53:06, anyzhen wrote: > sorry and please forget the name and what it is meaning for. > just look at in syntax aspect > > > the error : "parse error on input `|' > Failed, modules loaded: none." > > > > linerFind :: [Int] -> Int -> MaxSA -> MaxSA --MaxSA is > MaximumSubarray linerFind xs len ms1@(MaxSA l h m) -- > (MaxSA leftPosition rightPosition maxsum) > > | h<len = keepFind ms1 > > where keepFind ms'@(MaxSA l' h' m')= > let ms2@(MaxSA l2 h2 m2)= find' xs l' (h'+1) in > if m < m2 then linerFind xs len ms2 > else keepFind ms2 > > |otherwise = ms1 --compiler say > |error is in this line You must have the where clause after the guards, linerFind ... | h < len = keepFind ms1 | otherwise = ms1 where ...

1 0

Question about lazy evaluation
by Zhi-Qiang Lei 08 Sep '11

08 Sep '11

Hi, I am confused about this piece of explanation in Real World Haskell. -- file: ch08/append.hs (++) :: [a] -> [a] -> [a] (x:xs) ++ ys = x : (xs ++ ys) [] ++ ys = ys In a strict language, if we evaluate "foo" ++ "bar", the entire list is constructed, then returned. Non-strict evaluation defers much of the work until it is needed. If we demand an element of the expression "foo" ++ "bar", the first pattern of the function's definition matches, and we return the expression x : (xs ++ ys). Because the (:) constructor is non-strict, the evaluation of xs ++ ys can be deferred: we generate more elements of the result at whatever rate they are demanded. When we generate more of the result, we will no longer be using x, so the garbage collector can reclaim it. Since we generate elements of the result on demand, and do not hold onto parts that we are done with, the compiler can evaluate our code in constant space. When ('f' : "oo") ++ "bar" becomes 'f' : ("oo" ++ "bar") and then becomes 'f' : ('o' : ("o" ++ "bar")), we still need 'f', don't we? Best regards, Zhi-Qiang Lei zhiqiang.lei(a)gmail.com

3 2

Converting wiki pages into pdf
by mukesh tiwari 08 Sep '11

08 Sep '11

Hello all I am trying to write a Haskell program which download html pages from wikipedia including images and convert them into pdf . I wrote a small script import Network.HTTP import Data.Maybe import Data.List main = do x <- getLine htmlpage <- getResponseBody =<< simpleHTTP ( getRequest x ) --open url --print.words $ htmlpage let ind_1 = fromJust . ( \n -> findIndex ( n `isPrefixOf`) . tails $ htmlpage ) $ "" ind_2 = fromJust . ( \n -> findIndex ( n `isPrefixOf`) . tails $ htmlpage ) $ "" tmphtml = drop ind_1 $ take ind_2 htmlpage writeFile "down.html" tmphtml and its working fine except some symbols are not rendering as it should be. Could some one please suggest me how to accomplish this task. Thank you Mukesh Tiwari

2 1

Re: [Haskell-beginners] Question about lazy evaluation
by anyzhen 08 Sep '11

08 Sep '11

i think , garbage collector reclaim the ‘f' just only when "foo" can't access .because i think the 'f' is shared between “foo” with "foobar"( "foo" ++ "bar" ). Zhen Jiang jiangzhen3s(a)gmail.com ------------------ Original ------------------ From: "Zhi-Qiang Lei"; Date: 2011年9月8日(星期四) 中午1:56 To: "Haskell Beginer"; Subject: [Haskell-beginners] Question about lazy evaluation Hi, I am confused about this piece of explanation in Real World Haskell. -- file: ch08/append.hs (++) :: [a] -> [a] -> [a] (x:xs) ++ ys = x : (xs ++ ys) [] ++ ys = ys In a strict language, if we evaluate "foo" ++ "bar", the entire list is constructed, then returned. Non-strict evaluation defers much of the work until it is needed. If we demand an element of the expression "foo" ++ "bar", the first pattern of the function's definition matches, and we return the expression x : (xs ++ ys). Because the (:) constructor is non-strict, the evaluation of xs ++ ys can be deferred: we generate more elements of the result at whatever rate they are demanded. When we generate more of the result, we will no longer be using x, so the garbage collector can reclaim it. Since we generate elements of the result on demand, and do not hold onto parts that we are done with, the compiler can evaluate our code in constant space. When ('f' : "oo") ++ "bar" becomes 'f' : ("oo" ++ "bar") and then becomes 'f' : ('o' : ("o" ++ "bar")), we still need 'f', don't we? Best regards, Zhi-Qiang Lei zhiqiang.lei(a)gmail.com

1 0

Help me with designing my daemon, please.
by Michael Litchard 07 Sep '11

07 Sep '11

I have a daemon I need to build, and need to work out some design details I am having difficulty with. Here's what the design looks like right now When the daemon starts it creates an empty MVar and an empty TChan. Then it listens for a usrSIG1. when it gets one, it checks to see if the MVar is empty. If it is, it does some stuff to fill the MVar, which is then used to pass around state for a list of functions. These functions are always the same. After evaluating these functions, the TChan is checked. As long as the TChan has something in it, it populates an MVar and the same three functions are evaluated in the same order again. If the MVar is full, it creates another MVar of the same type and puts it in the TChan. Is this a sound design? Does it prompt any questions from you? Here's my question. If this is basically a sound design, I know I will need use forkIO. I'm not sure where. If this is not a sound design, please ask questions or give other feedback so I can make changes and restore sanity.

2 5

rational exponents
by Christopher Howard 07 Sep '11

07 Sep '11

Hi. I'm working with simple functions involving rational exponents. I noticed that the (**) function seems to do okay with negative powers, but that something else is needed for rational exponents: Prelude> 2 ** (-2) 0.25 Prelude> 8 ** (1/3) 2.0 Prelude> 8 ** (2/3) 3.9999999999999996 Would there be a module meant for that sort of thing? I spent some time in Hoogle and Hackage looking around, but nothing obvious stood out. -- frigidcode.com theologia.indicium.us

3 5

$= question
by Sergiy Nazarenko 04 Sep '11

04 Sep '11

Hello all! Could anyone explaines me what function $= is mean? I saw it in a haskell.org in opengl examples. There is no answers in hoogle. Thanks, Sergiy

3 2

Unwrap an expression?
by Christopher Howard 04 Sep '11

04 Sep '11

Perhaps this is a dumb question, but I was pondering the whole "Lazy" aspect of Haskell, and was curious: is there someway you could create a function "M", which you could pass an expression into, so that... M (f (g... (n (x)) ...)) returns f and/or returns the inner value (g... (n (x)) ...) I don't know if that breaks the whole "referential transparency" idea or not, but with all those lambda calculus tricks I've heard about, and the lazy evaluation, I thought it would be worth asking. -- frigidcode.com theologia.indicium.us

3 2

Help with enumerator pipeline
by Michael Xavier 01 Sep '11

01 Sep '11

I've just recently started learning how to use the enumerator library. I'm designing a utility that parses a file where each line is a JSON object. I've designed it to look like: source enumerator (enumHandle pretty much) -> chunk by lines (enumeratee) -> parse a line into an Object (enumeratee) -> filter objects based on a criteria (enumeratee) -> limit some keys from each object (enumeratee) -> encode the object into a lazy bytestring (enumeratee) -> output the file to stdout (iteratee) I'm having difficulties with the types, particularly composing the enumeratees in the middle. Someone in #haskell said that's a good case for >=> from Control.Monad but that seems to not like it if an enumeratee changes the type between the input and output. Here's the relevant types: type Object = Map Text Value pipeline :: MonadIO m => (Enumerator ByteString IO ()) -> [Text] -> [Filter] -> Iteratee a m () pipeline s rfs fs = s $$ splitLines >=> parseLine >=> (filterObjects fs) >=> (restrictFields rfs) >=> encoder $$ output splitLines :: Monad m => Enumeratee ByteString ByteString m b parseLine :: Monad m => Enumeratee ByteString Object m b filterObjects :: Monad m => [Filter] -> Enumeratee Object Object m b restrictObjects :: Monad m => [Text] -> Enumeratee Object Object m b encoder :: Monad m => Enumeratee Object LBS.ByteString m b output :: MonadIO m => Iteratee LBS.ByteString m () I'm using >=> because I'd prefer to compose them left-right for readability Here's the error I get Couldn't match expected type `ByteString' with actual type `M.Map Text Value' Expected type: Data.Enumerator.Step ByteString m b1 -> Iteratee ByteString m b2 Actual type: Enumeratee ByteString Object m0 b0 In the first argument of `(>=>)', namely `parseLine' In the second argument of `(>=>)', namely `parseLine >=> (filterObjects fs) >=> (restrictFields rfs) >=> encoder' Any ideas? -- Michael Xavier http://www.michaelxavier.net LinkedIn <http://www.linkedin.com/pub/michael-xavier/13/b02/a26>

5 7