Return to stream.sml CVS log

Up to [Research Unix] / researchv10no / cmd / sml / doc / examples

Annotation of researchv10no/cmd/sml/doc/examples/stream.sml, revision 1.1

1.1     ! root        1: (* stream.sml *)
        !             2: 
        !             3: (* Streams as a structure *)
        !             4: (* The type is named Stream to avoid conflict with the i/o type stream *)
        !             5: 
        !             6: signature STREAM = sig
        !             7:     type 'a Stream
        !             8:     val lazyCons: (unit -> '1a * '1a Stream) -> '1a Stream
        !             9:     and cons: '1a * '1a Stream -> '1a Stream
        !            10:     and head: 'a Stream -> 'a
        !            11:     and tail: 'a Stream -> 'a Stream
        !            12:        and suffix : int -> 'a Stream -> 'a list
        !            13:        and lazyMap : ('1a -> '1b) -> '1a Stream -> '1b Stream
        !            14: end
        !            15: 
        !            16: structure Stream : STREAM = struct
        !            17:     datatype 'a Stream = mkstream of 'a str ref
        !            18:         and 'a str = SOLID of 'a * 'a Stream
        !            19:                    | SUSPENDED of unit -> ('a * 'a Stream);
        !            20:     fun solidify(mkstream(ref(SOLID p))) = p 
        !            21:       | solidify(mkstream(s as ref(SUSPENDED f))) =
        !            22:          let val p = f() in (s := SOLID p; p) end
        !            23:     fun lazyCons(f) = mkstream(ref(SUSPENDED f))
        !            24:     and cons(x,ss) = mkstream(ref(SOLID(x,ss)))
        !            25:     and head s = let val (hd,_) = solidify s in hd end
        !            26:     and tail s = let val (_,tl) = solidify s in tl end
        !            27:     and suffix 0 s = nil
        !            28:       | suffix n s = (head s)::(suffix (n-1) (tail s))
        !            29:     fun lazyMap f s =
        !            30:        let fun g (mkstream(ref(SOLID(x, s)))) = lazyCons(fn () => (f x, g s))
        !            31:              | g (s) = lazyCons
        !            32:                         (fn () => let val (x, s') = solidify s in (f x, g s') end)
        !            33:         in lazyCons(fn () => solidify(g s))
        !            34:        end
        !            35: end

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.