- Haskell-Cafe - Haskell.org

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

Re: [Haskell-cafe] Data.Enumerator.List.concatMap is to Data.Iteratee.?
by John Lato 27 Jun '11

27 Jun '11

> > From: David Place <d(a)vidplace.com> > > Hi: > > I've been studying iteratee IO. Is there a function in the iteratee > package that is analogous to Data.Enumerator.List.concatMap? > Iteratee's 'Data.Iteratee.Iteratee.convStream', or the more general 'Data.Iteratee.Iteratee.unfoldConvStream', would be the rough equivalents. The difference is that DEL.concatMap operates on each chunk, whereas DII.convStream operates on the stream. This makes it possible to specify operations which work on multiple chunks. If you want a function more like DEL.concatMap, it would be > concatMap f = convStream (fmap f getChunk) Note that stream type 's' in enumerator should generally be translated to '[s]' in iteratee. John

1 0

View Thunk Evaluation
by Tom Murphy 27 Jun '11

27 Jun '11

Hi All, Is there a way to determine whether a thunk was evaluated during code's execution? Thanks, Tom

2 2

Trouble with `foldl` in composition chain.
by David Banas 27 Jun '11

27 Jun '11

When profiling this code: consolidateRPR :: [Sample] -> [Sample] smplUnionRecursRev :: [Sample] -> Sample -> [Sample] sortSamps :: [Sample] -> [Sample] smplSetUnion :: [Sample] -> [Sample] smplSetUnion = consolidateRPR . (foldl smplUnionRecursRev []) . sortSamps I'm getting this: smplSetUnion Data.RandProc 1038 32794 0.7 0.2 76.9 72.6 consolidateRPR Data.RandProc 1041 32794 0.0 0.0 8.2 11.8 smplUnionRecursRev Data.RandProc 1040 918112 8.8 5.6 8.8 5.6 sortSamps Data.RandProc 1039 1081514 21.1 55.0 59.2 55.0 I'm confused as to why `sortSamps` is being called so many times. I would expect it to be called 32794 times, just like `consolidateRPR`. It's as if having a `foldl` to the left of `sortSamps` in the composition chain is causing it to execute more than once, per call of `smplSetUnion`, but I wouldn't expect that. This doesn't change anything: smplSetUnion = consolidateRPR . (\ss -> foldl smplUnionRecursRev [] ss) . sortSamps (I thought it might explicitly close the `foldl`.) In fact, even this: smplSetUnion ss = consolidateRPR $ foldl smplUnionRecursRev [] ss' where ss' = sortSamps ss doesn't change anything. `sortSamps` still gets entered 1081514 times! Can anyone help clear up this newbie's fog? Thanks, in advance! -db

1 0

Alex Lexer Performance Issues
by Tristan Ravitch 26 Jun '11

26 Jun '11

Hi Cafe, In one of my projects I have a lexer that seems to be taking an inordinate amount of time and space. The lexer is generated by Alex using the lazy ByteString (with position information) template. I compiled and ran with profiling enabled and I get a report like this: ------------------------------------------------------------------------------- Tue Jun 21 16:56 2011 Time and Allocation Profiling Report (Final) ViewCallGraph +RTS -p -RTS gnutls.bc total time = 51.80 secs (2590 ticks @ 20 ms) total alloc = 9,482,333,244 bytes (excludes profiling overheads) COST CENTRE MODULE %time %alloc alexScanTokens Data.LLVM.Private.Lexer 24.1 4.5 alex_scan_tkn Data.LLVM.Private.Lexer 21.2 32.7 tokenAs Data.LLVM.Private.Parser.Primitive 6.7 2.9 alexGetChar Data.LLVM.Private.Lexer 6.5 22.7 ------------------------------------------------------------------------------- The entries below these four are marginal. The third entry is from my code and isn't a big deal (yet), but the other three seem to indicate that the lexer is responsible for about 50% of my runtime and memory allocation. For reference, this particular input is about 18M of text, though the ratios are just as bad for smaller inputs. My uneducated suspicion is that Alex is constructing separate ByteStrings that it passes to each of my token constructors, and that this is responsible for a large part of this allocation. Most of my token constructors just ignore this ByteString - assuming there really is an allocation for each token, is there any way to avoid it? I was looking at alexScanTokens, alex_scan_tkn, and alexGetChar but didn't see any obvious ways to improve them. Alternatively, does any one have lexing performance tips that might help? Thanks

4 4