- Haskell-Cafe - Haskell.org

Enumerators, Enumeratees and Iterators
by Sævar Berg 28 Jun '11

28 Jun '11

Hey Café. I've been playing with Enumerators, Iteratees and Enumeratees today after having spent a few days writing a server application using lazy IO, then reading slides from Oleg's DEFUN8 talk notes, and I quote: "Lazy IO in serious, server-side programming is unprofessional", "I can talk a lot how disturbingly, distressingly wrong lazy IO is theoretically, how it breaks all equational reasoning" after which my OCD self has been eating me up to take a proper look at this, so here I am. I'm already beginning to see how Iteratees, Enumerators and Enumeratees can be nifty, but I have a couple of questions about a couple of ideas and whether, and if so how they can be implemented. The first question is, I think, to be solved with enumeratees but I can't really grok how. Let's say I have an iteratee that consumes all input. Is it possible to implement an enumeratee or something else to stick between the enumerator and the iteratee to basically modify the input to the iteratee to only be a part of the input? Something like this: enumFile "someFile" && printFileLines -- prints file with prepended line numbers enumFile "someFile" ?? onlyGet10Lines && printFileLines -- print only 10 lines The second question could actually have an application in the server I'm writing. I was wondering if it was possible to write iteratees/enumerators that would only generate/consume when a certain something was the next chunk to be processed? It's a bit hard to explain, but let me try to give you an example. Let's say my application takes input from the network which contains commands that the server reacts to. Let's say I have a list of command handlers that I want to run this command through, but the handlers will only execute when they are passed the command that they are responsible for handling. Can this list of command handlers be enumerators/iteratees/enumeratees? E.g. is it possible to 'concat' them, making them each peek at the next chunk to see if it's theirs to handle and put it back if it isn't? I know this is possible to do differently and I have an idea for how I would do this, but I'm wondering if this is possible. If I can get answers to either or both of the questions it would help me a bit on my way to completely realize the roles that enumerators vs. iteratees vs. enumeratees have, as the lines seem a bit blurred -- sometimes, anyway. Thanks in advance. :)

4 4

Re: [Haskell-cafe] Possible bug in GHC 7.0.3
by Alberto G. Corona 28 Jun '11

28 Jun '11

Reported: http://hackage.haskell.org/trac/ghc/ticket/5287 2011/6/28 Alberto G. Corona <agocorona(a)gmail.com> > > 2011/6/28 Jason Dagit <dagitj(a)gmail.com> > >> On Tue, Jun 28, 2011 at 3:43 AM, Alberto G. Corona <agocorona(a)gmail.com> >> wrote: >> > I have an "'impossible' happened" error. >> > The code may look a little bit convoluted but it is part of my real >> code.: >> >> I don't know why it's crashing, but did you already report it as a >> bug? If not, you definitely should. >> >> > Please report this as a GHC bug: http://www.haskell.org/ghc/reportabug >> >> That URL should have the info you need to report it. >> >> Jason >> > > Not published yet. I wanted to publish it in the list before reporting the > bug. Just in case anyone tell something interesting about it. A sorter > expression that produces the same bug or something similar. >

1 0

What is a "simple pattern binding"?
by dm-list-haskell-cafe＠scs.stanford.edu 28 Jun '11

28 Jun '11

Section 4.4.3.2 of the 2010 Haskell report says: A simple pattern binding has form p = e. The pattern p is matched “lazily” as an irrefutable pattern, as if there were an implicit ~ in front of it. This makes it sound as though p is a pattern, which I assume means what section 3.17 defines as the non-terminal "pat". pat -> lpat qconop pat | lpat This is further suggested by the explicit mention of ~, which would be redundant if p had to be a var, since variables always match (according to section 3.17.2 rule 1). So my reading of section 4.4.3.2 is that the following is considered a simple pattern binding (because it has no guards): (f, g) = (\x -> x, f) However, section 4.5.5 seems to contradict this. It reads: Recall that a variable is bound by either a function binding or a pattern binding, and that a simple pattern binding is a pattern binding in which the pattern consists of only a single variable (Section 4.4.3). Moreover, it goes on to give an example and explanation: [(n,s)] = reads t ... Hence, when non-simple pattern bindings are used This text makes it sound as though a "simple pattern binding" can have only a single variable to the left of the = sign, meaning: f = \x -> x Further confusing things, GHC accepts the following: g1 x y z = if x>y then show x ++ show z else g2 y x g2 :: (Show a, Ord a) => a -> a -> String g2 | False = \p q -> g1 q p () | otherwise = \p q -> g1 q p 'a' where x = True and infers type: g1 :: (Show a, Show a1, Ord a1) => a1 -> a1 -> a -> [Char] According to 4.4.3.2, g2 definitely does not have a simple pattern binding, as its binding is not of the form p = e where p is a pattern. Yet by section 4.5.5, if g2 were not considered a simple pattern binding, the constrained type variables in the binding group containing g1 and g2 (in particular the inferred type (Show a => a) of z in g1) would not be allowed to be generalized. So is section 4.4.3.2 of the Haskell 2010 report just wrong? Or is GHC allowing code prohibited by the standard? Or am I somehow misreading the standard? Anyway, if someone can provide a less ambiguous definition of the term "simple pattern binding", I would appreciated it, particularly if you can point to support for your definition in the Haskell 2010 report... Thanks, David

4 12

Cleaner way to write code and handle errors?
by John Ky 28 Jun '11

28 Jun '11

Hi all, I'm practising my Haskell by writing a simple TCP echo server and finding that getting my program control to be succinct is rather tricky. In particular, I have return () everywhere, my error handling is verbose and I'm not entirely sure my recursion is the cleanest way syntactically to get my loops going and terminating. I must be doing something obviously un-Haskell-like. Any suggestions on how I can improve my code? Code below. Cheers, -John import Control.Concurrent import Control.Exception import Control.Monad import Network import System.IO import System.IO.Error (isEOFError) main = withSocketsDo $ do sListen <- listenOn (PortNumber 8000) putStrLn "Listening on Port 8000" forkIO $ forever $ do (sSession, hostname, port) <- accept sListen putStrLn ("Connected to " ++ hostname ++ ":" ++ (show port)) let processLine = forkIO $ do lineResult <- try (hGetLine sSession) case lineResult of Right line -> do putStrLn line processLine return () Left e -> if isEOFError e then putStrLn (show e) else do ioError e return () return () processLine return() line <- getLine return ()

4 5

Data Flow Programming in FP
by Richard Senington 28 Jun '11

28 Jun '11

Hi all, I have recently become interested in Dataflow programming and how it related to functional languages. I am wondering if the community has any advice on reading matter or other directions to look at. So far I have been looking through the FRP libraries, using Haskell functions with lazy lists for co-routines and the Essence of Dataflow Programming by Uustalu and Vene where they propose using co-monads. It looks as though Iteratees are also relevant but I have not got round to looking at them in detail yet. Have I missed anything? Regards RS

6 8

Fwd: Re: Period of a sequence
by Steffen Schuldenzucker 28 Jun '11

28 Jun '11

Forwarding to -cafe -------- Original Message -------- Subject: Re: [Haskell-cafe] Period of a sequence Date: Mon, 27 Jun 2011 04:46:10 -0700 (PDT) From: michael rice <nowgate(a)yahoo.com> To: Steffen Schuldenzucker <sschuldenzucker(a)uni-bonn.de> Hi Steffen, Repeating decimals. 5/7 == 0.714285 714285 7142857 ... Period = 6 It does seem like a difficult problem. This one is eventually repeating, with Period = 3 3227/555 = 5.8144 144 144… Michael --- On *Mon, 6/27/11, Steffen Schuldenzucker /<sschuldenzucker(a)uni-bonn.de>/*wrote: From: Steffen Schuldenzucker <sschuldenzucker(a)uni-bonn.de> Subject: Re: [Haskell-cafe] Period of a sequence To: "michael rice" <nowgate(a)yahoo.com> Cc: haskell-cafe(a)haskell.org Date: Monday, June 27, 2011, 4:32 AM On 06/26/2011 04:16 PM, michael rice wrote: > MathWorks has the function seqperiod(x) to return the period of sequence > x. Is there an equivalent function in Haskell? Could you specify what exactly the function is supposed to do? I am pretty sure that a function like seqPeriod :: (Eq a) => [a] -> Maybe Integer -- Nothing iff non-periodic cannot be written. If "sequences" are represented by the terms that define them (or this information is at least accessible), chances might be better, but I would still be interested how such a function works. The problem seems undecidable to me in general. On finite lists (which may be produced from infinite ones via 'take'), a naive implementation could be this: > > import Data.List (inits, cycle, isPrefixOf) > import Debug.Trace > > -- Given a finite list, calculate its period. > -- The first parameter controls what is accepted as a generator. See below. > -- Set it to False when looking at chunks from an infinite sequence. > listPeriod :: (Eq a) => Bool -> [a] -> Int > listPeriod precisely xs = case filter (generates precisely xs) (inits xs) of > -- as (last $ init xs) == xs, this will always suffice. > (g:_) -> length g -- length of the *shortest* generator > > -- @generates prec xs g@ iff @g@ generates @xs@ by repitition. If @prec@, the > -- lengths have to match, too. Consider > -- > -- >>> generates True [1,2,3,1,2,1,2] [1,2,3,1,2] > -- False > -- > -- >>> generates False [1,2,3,1,2,1,2] [1,2,3,1,2] > -- True > generates :: (Eq a) => Bool -> [a] -> [a] -> Bool > generates precisely xs g = if null g > then null xs > else (not precisely || length xs `mod` length g == 0) > && xs `isPrefixOf` cycle g > -- Steffen

5 5

Re: [Haskell-cafe] Hoopl: Combining CheckingFuelMonad with State?
by Antoine Latter 27 Jun '11

27 Jun '11

Hi Justin, this message might be better on the haskell-cafe list (or the excellent beginers list!). When you tried to write the get/put implementations, what problems were you running into? Antoine On Sat, Jun 25, 2011 at 7:50 AM, Justin Bailey <jgbailey(a)gmail.com> wrote: > I'd like to carry around some state when rewriting. It seems like > CheckingFuelMonad, etc. are set up to use with other monads but I > can't get the types to agree. > > Using MTL I've managed to come up with these types: > >> newtype RewriteOnce a = R (State Bool a) >> deriving (Monad) >> >> instance MonadState s (CheckingFuelMonad RewriteOnce) where >> get = undefined >> put = undefined > > > But I cannot write the definitions for get and put. Is this possible > or am I misundersanding CheckingFuelMonad? Is there a better approach > altogether? > > Thanks in advance for any help! > > Justin > > _______________________________________________ > Glasgow-haskell-users mailing list > Glasgow-haskell-users(a)haskell.org > http://www.haskell.org/mailman/listinfo/glasgow-haskell-users >

2 1

toSql and fromSql, for Algebraic Data Type
by Tom Murphy 27 Jun '11

27 Jun '11

Hi *, The title is self-explanatory. I'd like to store information from an algebraic data type in an SQL database, but the type signature of toSql (toSql :: Data.Convertible.Base.Convertible a SqlValue => a -> SqlValue) doesn't make sense to me. How is this done (how do I make an instance of a typeclass like that?) Thanks for your time, Tom

2 1

Help
by Stoyan Peev 27 Jun '11

27 Jun '11

Hello all, I am experiencing some issues to do my course task in university. I have to write a calculator- function in Haskell. The function argument is a list of strings and also form such list, as each string of the argument made definite action: - If the string has the form of an arithmetic _expression_ - calculate this _expression_. The string result becomes part of the list-result. If the _expression_ contains a variable which is not assigned value, the result is displayed "undefined". - If the string has the form- Name = value calculated from the last _expression_ is assigned to the variable with the corresponding name in the list, and in the result list is formed a string with type - If there is not a calculated _expression_ to be assigned to form a string "no value". - If the string is non-blank, but there is a species different from the above two case, form the string "error". - If the string is empty, incl. when it contains only spaces, in the result there is not form a string. Expressions consist of integers without sign variables, operations + (Addition), - (subtraction), * (multiplication) and / (divide) and parentheses. Where no brackets, the operations are performed from left to right, but * and / precede the + and -. Implementation of any operation gives integer; in the division rejected the fractional part, if any. Variables have names of one letter - from the Latin small letter. In the beginning, end or between the elements of each row can have spaces - they are irrelevant to its correctness. Example: the list-argument ["3 +7 / 2" "2 + x", "= s", "2 * s +4", "", "2 + +4 / 5] function should provide a result-list ["6", "undefined", "s = 6", "16", "error"]. I say another person have the same task, but he didn't do anything. I started doing this task myself but i get stuck in the middle. Then i started searching for something that could help me and find out you :) The code i have written so far uses the library file "Parsing.lhs" but what i have written is taking those actions that i already described, only for a string. I cannot modify it to work for list of string, and complete the whole task. I'll be glad to finish the task myself, but i am going to need some help. Here is the code i have already written: import Parsing expr :: Parser Int expr = do t <- term do symbol "+" e <- expr return (t+e) +++ do symbol "-" e <- expr return (t-e) +++ return t term :: Parser Int term = do f <- factor do symbol "*" t <- term return (f * t) +++ do symbol "/" t <- term return (f-t) +++ return f factor :: Parser Int factor = do symbol "(" e <- expr symbol ")" return e +++ natural eval :: String -> Int eval xs = case (parse expr xs) of [(n,[])] -> n [(_,out)] -> error ("undefined") [] -> error "error" Thanks all in advance :) -- Best Wishes Stoyan Peev

3 9

Re: [Haskell-cafe] Data.Time
by Daniel Schüssler 27 Jun '11

27 Jun '11

On 2011-June-27 Monday 10:15:28 Yitzchak Gale wrote: > The biggest shortcoming, in my opinion, is that the documentation > assumes that the reader is very familiar with the Haskell type > system, and with viewing type signatures and instance lists as an > integral and central part of the documentation. > > In particular, Haskell's standard numeric type classes and the > conversion functions between them play a central role in the API > of Data.Time. Making use of Haddock's recently added(?) support for comments on instance declaration would help a lot here, I think (even if it was just to draw attention to the Num/Integral/Real/Fractional instances). > Before you undertake writing a whole new time library, why not > try writing some improved documentation for Data.Time first? I got the impression that Tony's issue with Data.Time was the lack of some feature, not usability. Seems like the details that were omitted for the sake of constructiveness are quite relevant :) Cheers, Daniel

1 0