Posted: Sat Mar 17, 2007 2:26 pm
Yes, pretty much. Except, you can do operations on that array like any normal array. Most of the functions in the Haskell Prelude are designed so that they work just fine on infinite arrays.
Code: Select all
struct list_of_int { int x; list_of_int * rest; }
list_of_int ones;
ones.x = 1;
ones.rest = &ones;
More interesting stuff can be done. Suppose you want an infinite list of squares (my syntax might be off since I don't know Haskell for real):
Code: Select all
square x = x * x
ints = [1, 2, 3 .. ]
map fn [] = []
map fn [x:xs] = [fn x : map fn xs]
squares = map square ints
Now, squares is an infinite list of squares, that is [1, 4, 9, 16 ... ] continuing as far as you care to look at it.
Also notice how it is possible to avoid explicit conditionals in many cases by relying on pattern matching instead. That is, the version of "map" is selected automatically based on whether second argument is empty or non-empty list.
Ofcourse there's easier way to write that in Haskell, because (AFAIK) you can just as well use so called list-comprehensions:
Code: Select all
squares = [ x * x | x <- [1, 2, 3 ..]]
Anyway.. the really interesting part of Haskell isn't really that it's lazy or allows list comprehensions, because both of those are pretty easy to implement:
- for lazy evaluation use promises and force them as required, caching values
- for comprehensions, just rewrite then in terms of map and filter (map defined above, filter looking something like:
Code: Select all
filter fn [] = []
filter fn [x:xs] = if fn x
then [x : filter fn xs]
else filter fn xs
