stream-utils: redesign

1 files changed, 67 insertions, 36 deletions

diff --git a/src/clojure/contrib/stream_utils/examples.clj b/src/clojure/contrib/stream_utils/examples.clj
index cc19f2c4..10207fff 100644
--- a/src/clojure/contrib/stream_utils/examples.clj
+++ b/src/clojure/contrib/stream_utils/examples.clj
@@ -8,74 +8,105 @@
 
 (ns clojure.contrib.stream-utils.examples
   (:use [clojure.contrib.stream-utils
-	 :only (defst-seq defst-gen pick pick-all stream-as-seq)])
-  (:use [clojure.contrib.monads :only (domonad)]))
+	 :only (defst stream-next
+		pick pick-all
+		stream-type defstream
+		stream-drop stream-map stream-filter stream-flatten)])
+  (:use [clojure.contrib.monads :only (domonad)])
+  (:use [clojure.contrib.seq-utils :only (seq-on)])
+  (:use [clojure.contrib.types :only (deftype)]))
 
-; Transform a stream of numbers into a stream of sums of
-; two consecutive numbers.
-(defst-seq sum-two [] [xs]
-  (domonad
-    [x1 (pick xs)
-     x2 (pick xs)]
-    (+ x1 x2)))
+;
+; Define a stream of Fibonacci numbers
+;
+(deftype ::fib-stream last-two-fib)
+
+(defstream ::fib-stream
+  [fs]
+  (let [[n1 n2] fs]
+    [n1 (last-two-fib [n2 (+ n1 n2)])]))
+
+(def fib-stream (last-two-fib [0 1]))
+
+(take 10 (seq-on fib-stream))
 
-(sum-two '(1 2 3 4 5 6 7 8))
+;
+; A simple random number generator, implemented as a stream
+;
+(deftype ::random-seed rng-seed vector seq)
 
-; The same example, but with a generator interface for the output stream
-(defst-gen sum-two-gen [] [xs]
+(defstream ::random-seed
+  [seed]
+  (let [[seed] seed
+	m      259200
+	value  (/ (float seed) (float m))
+	next   (rem (+ 54773 (* 7141 seed)) m)]
+    [value (rng-seed next)]))
+
+(take 10 (seq-on (rng-seed 1)))
+
+;
+; Various stream utilities
+;
+(take 10 (seq-on (stream-drop 10 (rng-seed 1))))
+(seq-on (stream-map inc (range 5)))
+(seq-on (stream-filter odd? (range 10)))
+(seq-on (stream-flatten (partition 3 (range 9))))
+
+;
+; Stream transformers
+;
+
+; Transform a stream of numbers into a stream of sums of two
+; consecutive numbers.
+(defst sum-two [] [xs]
   (domonad
     [x1 (pick xs)
      x2 (pick xs)]
     (+ x1 x2)))
 
-(def g (sum-two-gen '(1 2 3 4 5 6 7 8)))
-(let [[v1 g] (g :eos)]
-  (let [[v2 g] (g :eos)]
-    (let [[v3 g] (g :eos)]
-      (let [[v4 g] (g :eos)]
-	(let [[v5 g] (g :eos)]
+(def s (sum-two '(1 2 3 4 5 6 7 8)))
+
+(let [[v1 s] (stream-next s)]
+  (let [[v2 s] (stream-next s)]
+    (let [[v3 s] (stream-next s)]
+      (let [[v4 s] (stream-next s)]
+	(let [[v5 s] (stream-next s)]
 	  [v1 v2 v3 v4 v5])))))
 
+(seq-on s)
+
 ; Map (for a single stream) written as a stream transformer
-(defst-seq my-map-1 [f] [xs]
+(defst my-map-1 [f] [xs]
   (domonad
    [x (pick xs)]
    (f x)))
 
-(my-map-1 inc [1 2 3])
+(seq-on (my-map-1 inc [1 2 3]))
 
 ; Map for two stream arguments
-(defst-seq my-map-2 [f] [xs ys]
+(defst my-map-2 [f] [xs ys]
   (domonad
     [x (pick xs)
      y (pick ys)]
     (f x y)))
 
-(my-map-2 + '(1 2 3 4) '(10 20 30 40))
+(seq-on (my-map-2 + '(1 2 3 4) '(10 20 30 40)))
 
 ; Map for any number of stream arguments
-(defst-seq my-map [f] [& streams]
+(defst my-map [f] [& streams]
   (domonad
     [vs pick-all]
     (apply f vs)))
 
-(my-map inc [1 2 3])
-(my-map + '(1 2 3 4) '(10 20 30 40))
+(seq-on (my-map inc [1 2 3]))
+(seq-on (my-map + '(1 2 3 4) '(10 20 30 40)))
 
 ; Filter written as a stream transformer
-(defst-seq my-filter [p] [xs]
+(defst my-filter [p] [xs]
   (domonad
    [x (pick xs) :when (p x)]
    x))
 
-(my-filter odd? [1 2 3])
-
-; A simple random number generator, implemented as a generator function
-(defn rng [seed]
-  (fn [eos]
-    (let [m      259200
-	  value  (/ (float seed) (float m))
-	  next   (rem (+ 54773 (* 7141 seed)) m)]
-      [value (rng next)])))
+(seq-on (my-filter odd? [1 2 3]))
 
-(take 10 (stream-as-seq (rng 1)))