- Haskell-Cafe - Haskell.org

Haskell-cafe message-length restriction
by Graham Klyne 23 Nov '04

23 Nov '04

To the list Haskell-cafe admin... May I suggest that the maximum message length for postings to the haskell-cafe list without moderation be raised from its current 5K limit? It seems to me that a value of (say) 20K would reduce the moderator's workload without obviously allowing too many undesirables ... (though I allow the moderator surely knows more about what is thrown at the list that most of us don't see.) Just a thought. #g ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

Mutable and persistent values (was: Top Level TWI's again)
by Graham Klyne 23 Nov '04

23 Nov '04

[I'm moving my response to the Haskell-cafe mailing list, as it seems more appropriate for this kind of discussion.] Your question seems to touch on the old chestnut of how to reconcile pure functional programs with the inherently procedural aspects of I/O and state management. Most of the richness to which you refer is, to my mind, a fairly esoteric corner of Haskell with which I've had little cause to engage. I sense you may be coming from a perspective similar to mine of a couple of years ago, hence this response. Maybe what follows is already well known to you (some of it is basic stuff), so please accept my apologies if I'm retreading well-worn paths for you. The classical work (c. 1970's) on using functions to describe programs that update machine state models such programs as functions that take a state and return a new state, maybe returning some other values as well. This could get complicated to handle, and along the way functional structures based on monads were invoked to tidy up the housekeeping. (A paper by Simon Peyton-Jones and John Launchbury [1] about handling state in Haskell was useful for me.) Note the central role of higher order functions in dealing with this: a state-monad function represents a computation on some state, not the result of that state; the result of the computation is available only when the function is applied to some initial state. The do-notation is a syntactic sugar to make this easier to write, but (I think) it can sometimes obscure what is going on. Philip Wadler's paper "The Essence of Functional Programming" [3] nicely illustrates how monads can take care of various housekeeping chores. The IO monad can be viewed as a special case that allows a program to access and update state ("the real world") that exists outside the program. So, turning to your specific questions/concerns: >Also, ultimately, I want to be able to save my work and restart >the next day (say) picking up the tags where I left off. Your top-level program must be "in the IO monad" (or: is an expression that describes an IO monad value, which is a computation that interacts with the real world). Thus, it can access yesterdays work, and also your interactive inputs, and compute a new value that is today's work. The IO monad allows you to sequence the various interactions with persistent state and user dialogue, in a purely functional way. >I'm darned if I can see how to do this in a callback without a global >variables (and references from other callbacks, by the way). I would expect the callback function to accept an initial value of the "global" variable(s), and return its new value(s), leaving the calling site to ensure that the new value is used as required. (This interaction may be "hidden" in a monad (e.g. a state monad), and if the "callback" itself involves interaction with a user must use the IO monad.) > I want to use the old value of a tag to compute the new value, in a > callback, > > I want to access the tag from other callbacks, and > > I want to the value to a mutable list from within the callback. All of these are accommodated by adopting the accept-a-value-and-return-a-new-value perspective. The calling program that invokes the callbacks deals with ensuring that the callbacks have access to the appropriate results from other callbacks. It is my view that use a functional language effectively, it is necessary to think differently about its structure than one would for a conventional imperative program. Global values become parameters and return values; mutable values become input values and new (separate) return values. If you're used to writing imperative programs that do not use global state, but rather use parameters to pass values, the difference isn't always quite as great as might be imagined. For complex values, this sounds horribly inefficient, but because values are pure (not mutable), very high levels of sharing can (sometimes, with good design!) be extensively shared. Thus, a return value may well consist mostly of a copy of the input value, with differences, rather than actually being a complete new copy. (Chris Okasaki's book shows well how to design to obtain these benefits.) Also, because Haskell is lazy, complex structures passed between functions don't necessarily ever exist in their entirety. Sometimes, I think of a data structure as describing a computational traversal through some data, rathert than something that actually exists. (This leads to very elegant expression of things like Prolog search-and-backtrack algorithms.) So the main point of this posting is to say that I think that the "richness" of "implicit parameters, linear implicit parameters, unsafePerformIO, ..." to which you refer is a shoal of red herring, as far as your goals are concerned. I hope this helps. I've added below a couple of links to my web site to stuff that I accumulated while learning Haskell over the past couple of years. #g -- [1] Simon Peyton-Jones and John Launchbury, State in Haskell, linked from: http://research.microsoft.com/Users/simonpj/Papers/papers.html#monads, document at: http://research.microsoft.com/Users/simonpj/Papers/state-lasc.ps.gz, also at: http://www.cse.ogi.edu/~jl/Papers/stateThreads.ps. Introduces monads as a general technique for handling state, and then introduces a concept of "the world" as a state manipulated by IO. I found this to be one of the more illuminating introductions to Monads (which are central to Haskell I/O). [2] Chris Okasaki, "Purely Functional Data Structures", Cambridge University Press, 1998 [3] Philip Wadler, "The essence of functional programming", linked from http://homepages.inf.ed.ac.uk/wadler/topics/monads.html, paper at http://homepages.inf.ed.ac.uk/wadler/papers/essence/essence.ps . [4] http://www.ninebynine.org/Software/Learning-Haskell-Notes.html [5] http://ninebynine.org/Links.html#Programming-Haskell At 15:34 22/11/04 -0800, John Velman wrote: >On Mon, Nov 22, 2004 at 07:27:44PM +0100, Lennart Augustsson wrote: > > >[snip] > > I admit there are proper uses of global variables, but they are very > > rare. You have not convinced me you have one. > > > > -- Lennart > >It's with some trepidation I bring a problem as a total newbie, but I've >been obsessed with this and hung up on it ever since I decided a couple of >weeks ago to learn Haskell by using it. > >Some brief background: > >A while back I decided I wanted a simple 'concept mapping' program that >would work the way I work instead of the way someone else works. I >envisioned a GUI with a canvas and an entry box (TK/tcl). I type a >"concept name" into the entry box, and it shows up on the canvas (initially >in a slightly randomized position), in a box, with a unique sequenced >identifier. The identifier is also used as a canvas tag for the item. >Similar input for relations between concepts. I think that's enough >description for now. > >Initially, I started programming this with PerlTK, but that effort was >interrupted for a few weeks. When I got back to it, I decided to do it in >Python instead. But that effort also got interrupted for a few weeks. >Before I got back to it, I ran across some material on Haskell I've had in >my files for a few years, and decided that I'd use this as a vehicle to >actually learn Haskell. (This all sounds a bit unfocused, and it is: I'm >retired, sometimes describe myself as an ex mathematician or an ex-PhD >having spent years in the aerospace industry instead of academia. Anyway, >I have both the luxury and lack of focus of no deadlines, no pressure to >publish. I hope to use Haskell to further my main hobby of knowledge >representation.) > >In perl, my labels/tags were very easy: > >In the initialization code: > > my @taglist = (); > my $nextag = "a"; > >and in the callback for the entry box: > > push(@taglist,$nextag); > $nextag++; > >(With the starting tag of "a" this results in "a",...."z","aa","ab",...) > >Also, ultimately, I want to be able to save my work and restart >the next day (say) picking up the tags where I left off. > >I'm darned if I can see how to do this in a callback without a global >variables (and references from other callbacks, by the way). > >In looking for a method, I've discovered that Haskell is a lot richer than >I thought (or learned when I tinkered with it back in the late '90s ). >I've found out about (but don't know how to use properly) implicit >parameters, linear implicit parameters, unsafePerformIO, "safe and sound >implementation of polymorphic heap with references and updates (Oleg >Kiselyov, (http://www.haskell.org/pipermail/haskell/2003-June/011939.html) >implicit configurations, phantom types, ... > >I've also found warnings against many of these. I'm inclined to try the >unsafePerformIO route as being the simplest, and most commonly used, even >though perhaps the least haskell-ish. I like implicit configurations, but >couldn't begin to say I understand them yet, and it's a bit heavy for a >novice. > >In a nutshell: > > I want to use the old value of a tag to compute the new value, in a > callback, > > I want to access the tag from other callbacks, and > > I want to the value to a mutable list from within the callback. > >I'd certainly be interested in doing without global variables, and would >appreciate any advice. > >(By the way, I'm using Linux, and so far it looks like HTk is my choice for >the GUI interface.) > >Best, > >John Velman >_______________________________________________ >Haskell mailing list >Haskell(a)haskell.org >http://www.haskell.org/mailman/listinfo/haskell ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

1 0

foldlWhile
by Serge D. Mechveliani 22 Nov '04

22 Nov '04

Is such a function familia to the Haskell users? foldlWhile :: (a -> b -> a) -> (a -> Bool) -> a -> [b] -> a foldlWhile f p a bs = case (bs, p a) of ([], _ ) -> a (_, False) -> a (b:bs', _ ) -> foldlWhile f p (f a b) bs' foldl does not seem to cover this. Example. Sum the list while the sum is less than bound: boundSum :: Integer -> [Integer] -> Integer boundSum b = foldlWhile (+) (< b) 0 Example: boundSum 100 $ map (^2) [1 ..] Is this reasonable? More `generic' variant: foldlWhileJust :: (a -> b -> Maybe a) -> a -> [b] -> a foldlWhileJust f a bs = case bs of [] -> a b:bs' -> case f a b of Just a' -> foldlWhileJust f a' bs' _ -> a Please, copy the replies to mechvel(a)botik.ru ----------------- Serge Mechveliani mechvel(a)botik.ru

3 2

Re: [Haskell-cafe] foldlWhile
by Serge D. Mechveliani 22 Nov '04

22 Nov '04

To my question of >> foldlWhile :: (a -> b -> a) -> (a -> Bool) -> a -> [b] -> a >> foldlWhile f p a bs = >> case >> (bs, p a) >> of >> ([], _ ) -> a >> (_, False) -> a >> (b:bs', _ ) -> foldlWhile f p (f a b) bs' >> >> foldl does not seem to cover this. Dylan Thurston wrote: On Nov 20, 2004 > An alternative is > > foldlWhile f p a bs = last $ takeWhile p $ scanl f a bs > Yes. Thank you. Inspecting Prelude, we find out that scanl expresses, mainly, the thing. ----------------- Serge Mechveliani mechvel(a)botik.ru

2 1

Predicates in HaXml
by Tom Spencer 21 Nov '04

21 Nov '04

Hi there, In XSLT there is an XPath function that will let you select a particular node in the current context, for example; <xsl:value-of select="team[1] "/> in Michael Kay's article http://www-106.ibm.com/developerworks/xml/library/x-xslt/?article=xr This selects the first team element in the current context. Is there a work around to get similar functionality from the HaXml library? Many Thanks Tom Spencer

2 2

Re: [Haskell-cafe] foldlWhile
by dpt＠bostoncoop.net 20 Nov '04

20 Nov '04

On Sat, Nov 20, 2004 at 03:48:23PM +0000, Jorge Adriano Aires wrote: > > On Sat, Nov 20, 2004 at 12:47:58PM +0300, Serge D. Mechveliani wrote: > > > foldlWhile :: (a -> b -> a) -> (a -> Bool) -> a -> [b] -> a > > > foldlWhile f p a bs = > > > case > > > (bs, p a) > > > of > > > ([], _ ) -> a > > > (_, False) -> a > > > (b:bs', _ ) -> foldlWhile f p (f a b) bs' > > > > Why not just > > foldlWhile f p a bs = takeWhile p $ foldl f a bs > > Quite different. The former stops a foldl when the accumulating parameter no > longer satisfies p, the later assumes the accumulating parameter of the foldl > is a list, and takes the portion of the list that does satisfy p. Yes, this was a mistake. > The following is closer to the original, but doesn't work when the whole list > is folded (i.e., p always satisfied): > foldlWhile f p a = head . dropWhile p . scanl f a Serge's version returns the last 'a' that satisfies 'p', while yours returns the first 'a' that does not satisfy 'p'. This should be an equivalent version: foldlWhile f p a = tail . takeWhile p . scanl f a But what about the version with Maybe? There ought to be a concise way to write that too. Peace, Dylan

2 1

No need for integer literals
by Henning Thielemann 19 Nov '04

19 Nov '04

In addition to Paul Hudak's "The Haskell School of Expression", Appendix A "Built-in types are not special" I want to note that there is also hardly a need for integer literals. :-] module Digits where infixl 9 # (#) :: a -> (a -> b) -> b x # f = f x int :: Num a => a int = 0 d0, d1, d2, d3, d4, d5, d6, d7, d8, d9 :: (Enum a, Num a) => a -> a d0 n = n+n+n+n+n+n+n+n+n+n d1 = succ . d0 d2 = succ . d1 d3 = succ . d2 d4 = succ . d3 d5 = succ . d4 d6 = succ . d5 d7 = succ . d6 d8 = succ . d7 d9 = succ . d8 test :: (Enum a, Num a) => a test = int#d1#d4#d2#d8#d5#d7 * int#d2#d1

1 0

Sample rate inference
by Henning Thielemann 19 Nov '04

19 Nov '04

I want to connect several functions for signal processing. The typical case is that in a network of signal processor there are parts that are already discretized such as sampled sounds, and there are processors with no particular sample rate such as amplifiers. But when it comes to computation each processor must choose a sample rate for processing. There are also processors for converting sample rates. They divide the network into components of equal sample rate. The computation sample rate should be propagated through the network as follows: If in a component of equal sample rate some processors have the same fixed sample rate, all uncertain processors must adapt that. If some processors have different fixed sample rates this is an error. If no processor has a fixed sample rate, the user must provide one manually. To me this looks very similar to type inference. Is there some mechanism in Haskell which supports this programming structure?

6 10

RE: [Haskell-cafe] Parsec question
by Bayley, Alistair 19 Nov '04

19 Nov '04

I've also used Parsec for separated lexer + parser and currently have something like this to invoke them: testParse inputString = do case (parse myLexer "" inputString) of Left err -> fail ("lexical error: " ++ err) Right tokens -> case (parse myParser "" tokens) of Left err -> fail ("parse error: " ++ err) Right result -> return result ... or was this the "manual startup" that you were referring to? The above seems clunky to me, so I'd also welcome suggestions for piping the lexer output into the parser. What do you mean by "makes position calculations very complex"? Are you talking about reporting the position of lexical or parse errors? (If so, Parsec supports this quite well.) Alistair. > -----Original Message----- > From: John Goerzen [mailto:jgoerzen@complete.org] > Sent: 19 November 2004 14:28 > To: haskell-cafe(a)haskell.org > Subject: [Haskell-cafe] Parsec question > > Hi, > > I'm porting a parser over from an OCamllex/Ocamlyacc version and I'm > using Parsec for both the tokenizer and the resulting token > stream parser. > > I have both of them working fine, but now my question is: how do I > combine them? I can't quite figure out how to say "take the > output from > this GenParser Char () Tok and use it as the input for this > GenParser Tok () ParserOutput". > > Well, I have figured out an ugly way involving manually > starting up both > parsers, but it makes position calculations very complex. I > suspect I'm > missing something. > > Ideas? ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

2 1

Parsec question
by Tomasz Zielonka 19 Nov '04

19 Nov '04

On Fri, 19 Nov 2004 14:28:07 +0000 (UTC), John Goerzen <jgoerzen(a)complete.org> wrote: > Hi, > > I'm porting a parser over from an OCamllex/Ocamlyacc version and I'm > using Parsec for both the tokenizer and the resulting token stream parser. > > I have both of them working fine, but now my question is: how do I > combine them? I can't quite figure out how to say "take the output from > this GenParser Char () Tok and use it as the input for this > GenParser Tok () ParserOutput". > > Well, I have figured out an ugly way involving manually starting up both > parsers, but it makes position calculations very complex. Did you try to pair tokens with their SourcePos'es? What I did in my program was this: tokenize :: CharParser st tok -> CharParser st [(SourcePos, tok)] tokenize tp = do l <- many t eof return l where t = do pos <- getPosition tok <- tp return (pos, tok) token :: (Show tok) => (tok -> Maybe a) -> GenParser (SourcePos, tok) st a token f = Parsec.token (show . snd) fst (f . snd) This has a space leak, but I didn't care, because my inputs are at most 10kb long. You can do a lazy version with getInput. BTW, it would be useful if Parsec allowed to throw a ParseError from one type of parser in another parser. It would help me in a situation, where I parse the whole file with one parser, but I retokenize some parts of it and parse them with another parser type. Right now I am using this workaround, but it doesn't work well: cs <- chars pos <- getPosition x <- case p pos cs of Left err -> do setPosition (errorPos err) fail (messageString (head (errorMessages err))) Right x -> return x How about making an instance for instance Control.Monad.Error.MonadError ParseError (GenParser tok st) PS. I guess I could do this myself. Best regards, Tomasz

1 0