- Haskell-Cafe - Haskell.org

RE: [Haskell] lazy constructors
by Simon Peyton-Jones 13 Oct '04

13 Oct '04

[I think this thread would be more appropriate on haskell-café, so I'm redirecting it] | addToSPair :: Char -> (String, String) -> (String, String) | addToSPair c (xs, ys ) = (c:xs, ys ) | | --------------------------------------------------------------- | | g1 is similar to f1, g2 similar to f2. | | f1 and f2 are evaluated immediately to 'a'; | | g1 evaluates to 'a' after a long computation; | g2 evaluates to Fail: <<loop>> | | As g2 is similar to f2, should it have a value 'a' ? | In | head $ fst $ addToSPair 'a' bottomSPair Try using lazy pattern matching, thus addToSPair :: Char -> (String, String) -> (String, String) addToSPair c ~(xs, ys ) = (c:xs, ys ) The only change is the "~" in the defn of addToSPair. Now g2 will have value 'a'. Simon

1 0

strictness and the simple continued fraction
by William Lee Irwin III 13 Oct '04

13 Oct '04

So, I discovered that simple continued fractions are supposed to be spiffy lazy lists and thought I'd bang out some continued fraction code. But then I discovered ContFrac.hs and couldn't really better it. Of course, I went about trying to actually do things relying on their laziness, and discovered they weren't as lazy as I hoped they'd be. Simple uses of approximations at the ghci command line such as: instance Ord ContFrac where (ContFrac (x:xs)) `compare` (ContFrac (y:ys)) = case x `compare` y of LT -> LT GT -> GT EQ -> (ContFrac ys) `compare` (ContFrac xs) (ContFrac []) `compare` cf = case cf of ContFrac (x:_) -> 0 `compare` x ContFrac [] -> EQ cf `compare` (ContFrac []) = case cf of ContFrac (x:_) -> x `compare` 0 ContFrac [] -> EQ x = expCF (1/2) where expCF x | x < 0 = recip . expCF $ negate x | x == 0 = 1 | x == 1 = let ContFrac es = ecf in ContFrac (take 100 es) | otherwise = case x of ContFrac [y] -> (expCF 1)^y ContFrac (y:ys) -> if y /= 0 then ((expCF 1)^y) *(expCF (ContFrac (0:ys))) else (1+x+x^2/2+x^3/6+x^4/24+x^5/120) ContFrac [] -> expCF 0 where the instance was added to ContFrac.hs seems to fail to terminate, where manually reducing things a bit appears to restore termination. So, what hit me? -- wli

3 5

Tutorial about low-level I/O in Haskell
by Peter Simons 12 Oct '04

12 Oct '04

Hi, while polishing a small library of mine, I ended up writing a tutorial about the use of hGetBufNonBlocking and the related Foreign.* functions you need to do fast, block-oriented I/O in Haskell. There is something to be said for literate programming. Using recent topics for inspiration, the text describes the implementation of a fast word-counting program. :-) Here is the URL: http://cryp.to/blockio/docs/tutorial.html Peter

2 2

Strict evaluation not working?
by Christian Hofer 12 Oct '04

12 Oct '04

Hi, having found a bit of time to play with Haskell, I am trying to figure out how to enforce strict evaluation. I wrote the following program: main = let x = zipWith (+) [5..] [6..] in putStrLn $ show $ x `seq` head x I expected this program not to terminate - because of the seq-Operator, but it happily returns 11 in ghc as well as in ghci. What do I make wrong? Chris

3 3

Re: Language extension idea (was Re: [Haskell-cafe] Re: OCaml list sees...)
by J.Garrett.Morris＠Dartmouth.EDU 12 Oct '04

12 Oct '04

--- Tom Pledger wrote: It could get more convenient, though, if we have data-constructors-as-class-members and move the familiar list constructors into the List class. (The following might need to be built into the compiler, because of the special [] syntax.) --- end of quote --- Changing the subject very slightly, this brings up two questions: 1) Wouldn't implementing the Views proposal allow this? and, 2) Why haven't views been implemented (and why are they a "never" in the HaskellTwo discussion in HaWiki)? /gXm

3 2

Re: [Haskell-cafe] List implementation.
by MR K P SCHUPKE 12 Oct '04

12 Oct '04

>class List l where > head :: IArray UArray a => l a -> Maybe a > tail :: IArray UArray a => l a -> Maybe (l a) changed my mind about this... you cannot do: tail $ tail $ tail x so added a 'null' test instead.

1 0

Re: [Haskell-cafe] List implementation.
by MR K P SCHUPKE 12 Oct '04

12 Oct '04

Hows this: ... tail (Many i a l) | i < (e-s) = (Many (i+1) a l) | otherwise = l where (s,e) = bounds a ... a ++: l | e >= s = Many s a l | otherwise = l where (s,e) = bounds a A futher though is that with constructors you can do: f (a:as) = f [] = As you cannot use the constructors to access the list elements here, maybe the following would be more useful: class List l where head :: IArray UArray a => l a -> Maybe a tail :: IArray UArray a => l a -> Maybe (l a) then you can write: f x | Just h <- head x = ... | otherwise = ... Keean.

1 0

List implementation.
by MR K P SCHUPKE 12 Oct '04

12 Oct '04

With reference to the discussion a couple of days ago about list implementations, here is some code showing the idea I was talking about... Its a list that you can write either single elements or blocks (UArrays) to, but it always reads like a list of elements, so blocks can be read in, but you can recurse over individual elements. There is obviously some overhead with this in-haskell implementation, but if this were the default list implementation in the RTS, you could use the encoding trick I mentioned before to get practically no overhead for its use. -------------------------------------------------------------- {-# OPTIONS -fglasgow-exts #-} {-# OPTIONS -fallow-undecidable-instances #-} module List where import Data.Array.Unboxed data AList a = One !a (AList a) | Many !Int !(UArray Int a) (AList a) | Nil class List l where head :: IArray UArray a => l a -> a tail :: IArray UArray a => l a -> l a (+:) :: IArray UArray a => a -> l a -> l a (++:) :: IArray UArray a => (UArray Int a) -> l a -> l a infixr 9 +: infixr 9 ++: instance List AList where head (One a _) = a head (Many i a _) = a!i tail (One _ l) = l tail (Many i a l) | i < la = (Many (i+1) a l) | otherwise = l where (_,la) = bounds a a +: l = One a l a ++: l = Many 0 a l --------------------------------------------------------------- Keean.

2 1

Re: [Haskell-cafe] Re: OCaml list sees abysmal Language Shootout results
by MR K P SCHUPKE 12 Oct '04

12 Oct '04

One to add to your list, string edit distance - as its hard, and useful. Keean.

1 0

RE: [Haskell-cafe] strictness and the simple continued fraction
by Simon Peyton-Jones 12 Oct '04

12 Oct '04

If you are interested in arbitrary precision arithmetic using continued fractions, you may want to check out the work of David Lester. And Peter Potts et al. Just type "exact real arithmetic" into Google. Simon | -----Original Message----- | From: haskell-cafe-bounces(a)haskell.org [mailto:haskell-cafe-bounces@haskell.org] On Behalf Of | William Lee Irwin III | Sent: 12 October 2004 04:53 | To: Scott Turner | Cc: haskell-cafe(a)haskell.org | Subject: Re: [Haskell-cafe] strictness and the simple continued fraction | | On Mon, Oct 11, 2004 at 09:53:16PM -0400, Scott Turner wrote: | > I tried using continued fractions in a "spiffy lazy list" implementation a | > while ago. Never got them working as well as expected. | > Evenutally I realized that calculating with lazy lists is not as | > smooth as you might expect. | > For example, the square root of 2 has a simple representation | > as a lazy continued fraction, but if you multiply the square root of 2 by | > itself, your result lazy list will never get anywhere. The calculation will | > keep trying to determine whether or not the result is less than 2, this being | > necessary to find the first number in the representation. But every finite | > prefix of the square root of 2 leaves uncertainty both below and above, so | > the determination will never be made. | > Your problems may have some other basis, but I hope this helps. | | I hit that one, too. That's nasty enough it may be best to give up on | the infinite case, at least. I can't think of a way to salvage all this. | | | -- wli | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe(a)haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe

2 1