On 28 Mar 2008, at 03:03, Ryan Ingram wrote:
Another way to defer the evaluation of the second argument of (-+)
is like this:
(-+) :: a -> List a -> List a
x -+ y = List(f) where
f 0 = x
f k = case y of List g -> g (k-1)
This is exactly what the lazy pattern will do at compile-time. Does
this give you a better understanding of how lazy patterns work and why
they fix the problem?
I have various other patterns that need to be forced lazy - inputs
welcome. In the code below, where I have put in a "0" instead of the
first uncountable ordinal w, if I include in "show" the case a == 0,
then
h (list 6)
won't print, as then the value of "a" is computed.
And in the ordinal version
data List a = (Ordinal->a) :+ Ordinal
then the function
(-+) :: a -> List a -> List a
x -+ ~(y :+ q) = f:+(1+q) where
f 0 = x
f k = y(k-1)
does not compute, because there is a similar problem with the 1+q
evaluation, I think this is because the class Ordinal + uses case:
instance Num Ordinal where
x + y | finite x && finite y = toOrdinal(tcoef x + tcoef y)
x + y | lexp x < lexp y = y
x + y | lexp x == lexp y = prepend (lexp x, lcoef x + lcoef y)
(trail y)
x + y = prepend (lexp x, lcoef x) ((trail x) + y)
So these patterns perhaps should be made lazy. though I do not know
exactly how.
Hans
--------
infixr 5 :+
data List a = (Integer->a) :+ Integer
instance Show a => Show (List a) where
-- show (f:+a) | a == 0 = "[]"
show (f :+ a) = "[" ++ show (f(0)) ++
concat ["," ++ show (f(toInteger i))| i<-[1..]] ++ "]"
list :: Integer -> List Integer
list x = (\z -> x+z) :+ 0
(-+) :: a -> List a -> List a
x -+ ~(y :+ q) = f:+(1+q) where
f 0 = x
f k = y(k-1)
first :: List a -> a
first (f :+ _) = f 0
rest :: List a -> List a
rest (y :+ _) = f :+ 0 where
f k = y(k+1)
h :: List a -> List a
h x = (-+) (first x) (h (rest x))
--------
_______________________________________________
Haskell-Cafe mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-cafe
