Streams in Caml Light 0.5

[HEDDEN@ESDSDF.dnet.ge.com]

I am having a small difficulty using streams in Caml Light v0.5.

The example below might be a bug, but is more likely due to a
lack of understanding on my part.

The exception in the following toplevel session indicates that
there is a problem:


        >       Caml Light version 0.5

        #include "test";;
        map_stream : ('a -> 'b) -> 'a stream -> 'b stream = <fun>
        filter_stream : ('a -> bool) -> 'a stream -> 'a stream = <fun>
        int_stream : int stream = <abstract>
        - : int = 1
        - : int = 9
        - : int = 25
        odd_sq_stream : int stream = <abstract>
        - : int = 49
        Uncaught exception: Parse_failure
        - : unit = ()
        #quit();;


The file "test.ml" (that is loaded above) contains the following:


        (* Maps a function over a stream *)
        let rec map_stream func = function
            [< 'x >]  ->  [< 'func x >]
          | [< >]     ->  [< >]
        ;;

        (* Filters a stream according to a predicate *)
        let rec filter_stream pred strm =
          match strm with
              [< 'x >]  ->  if pred x then [< 'x >]
                                      else filter_stream pred strm
            | [< >]     ->  [< >]
        ;;

        (* The stream of positive integers *)
        let int_stream = ints 1
          where rec ints n = [< 'n; ints (succ n) >]
        ;;

        (* Use `filter_stream' and `map_stream' to create a
           stream of the squares of the odd integers *)
        (* These work correctly *)
        stream_next (map_stream (function x->x*x)
                     (filter_stream (function n->(n mod 2)= 1)
                     int_stream));;
        stream_next (map_stream (function x->x*x)
                     (filter_stream (function n->(n mod 2)= 1)
                     int_stream));;
        stream_next (map_stream (function x->x*x)
                     (filter_stream (function n->(n mod 2)= 1)
                     int_stream));;

        (* Encapsulate the above *)
        let odd_sq_stream =
                map_stream (function x->x*x)
                (filter_stream (function n->(n mod 2)= 1)
                int_stream)
        ;;

        (* Test the above encapsulation *)
        (* This works correctly *)
        stream_next odd_sq_stream;;

        (* This causes an error *)
        stream_next odd_sq_stream;;


Why is it that the first time `odd_sq_stream' is invoked it returns
the correct value, but on subsequent calls it causes an error?  Is
this a bug, or am I doing something wrong?

Jerry D. Hedden
hedden@esdsdf.dnet.ge.com