- Haskell-Cafe - Haskell.org

Re: [Haskell] lazy constructors
by Serge D. Mechveliani 13 Oct '04

13 Oct '04

On Wed, Oct 13, 2004 at 09:23:43AM +0100, MR K P SCHUPKE wrote: > You can only return a list of pair's lazily, not > a pair of lists. If the two strings are independant, then > generate each in a separate function, and pair off the > results lazily. No, I have several labeled fields in a record, which are very dependent. As people teach, the costruct of ~(..,..) helps for the Pair. Maybe, the labeled record can also be handled ... ----------------- Serge Mechveliani mechvel(a)botik.ru

1 0

Re: [Haskell-cafe] RE: [Haskell] lazy constructors
by MR K P SCHUPKE 13 Oct '04

13 Oct '04

>addToSPair c ~(xs, ys ) =3D (c:xs, ys ) I thought pattern bindings had an implicit "~"? Keean.

1 0

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 13 Oct '04

13 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 13 Oct '04

13 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 13 Oct '04

13 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