[Haskell-cafe] strictness and the simple continued fraction

[William Lee Irwin III]

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