- Re-named "stream" to "sequence".

- Updated copyright dates for lux-mode.

3 files changed, 46 insertions, 46 deletions

diff --git a/lux-mode/lux-mode.el b/lux-mode/lux-mode.el
index dc780b364..5beb7f91c 100644
--- a/lux-mode/lux-mode.el
+++ b/lux-mode/lux-mode.el
@@ -1,6 +1,6 @@
 ;;; lux-mode.el --- Major mode for Lux code -*- lexical-binding: t; -*-
 
-;; Copyright © 2014-2017 Eduardo Julian
+;; Copyright © 2014-2018 Eduardo Julian
 ;;
 ;; Authors: Eduardo Julian <eduardoejp@gmail.com>
 ;; URL: https://github.com/LuxLang/lux/tree/master/lux-mode
@@ -233,7 +233,7 @@ Called by `imenu--generic-function'."
             "list" "list&" "io" "row" "tree"
             "get@" "set@" "update@" "|>" "|>>" "<|" "<<|" "_$" "$_" "~" "~+" "~!" "~'" "::" ":::"
             "|" "&" "->" "All" "Ex" "Rec" "primitive" "$" "type"
-            "^" "^or" "^slots" "^multi" "^@" "^template" "^open" "^|>" "^code" "^stream&" "^regex"
+            "^" "^or" "^slots" "^multi" "^@" "^template" "^open" "^|>" "^code" "^sequence&" "^regex"
             "bin" "oct" "hex"
             "pre" "post"
             "sig" "struct" "derive"
diff --git a/stdlib/source/lux/data/coll/stream.lux b/stdlib/source/lux/data/coll/sequence.lux
index 305a5da4e..b8908403b 100644
--- a/stdlib/source/lux/data/coll/stream.lux
+++ b/stdlib/source/lux/data/coll/sequence.lux
@@ -12,29 +12,29 @@
              bool)))
 
 ## [Types]
-(type: #export (Stream a)
-  {#.doc "An infinite stream of values."}
-  (Cont [a (Stream a)]))
+(type: #export (Sequence a)
+  {#.doc "An infinite sequence of values."}
+  (Cont [a (Sequence a)]))
 
 ## [Utils]
 (def: (cycle' x xs init full)
   (All [a]
-    (-> a (List a) a (List a) (Stream a)))
+    (-> a (List a) a (List a) (Sequence a)))
   (case xs
     #.Nil           (pending [x (cycle' init full init full)])
     (#.Cons x' xs') (pending [x (cycle' x' xs' init full)])))
 
 ## [Functions]
 (def: #export (iterate f x)
-  {#.doc "Create a stream by applying a function to a value, and to its result, on and on..."}
+  {#.doc "Create a sequence by applying a function to a value, and to its result, on and on..."}
   (All [a]
-    (-> (-> a a) a (Stream a)))
+    (-> (-> a a) a (Sequence a)))
   (pending [x (iterate f (f x))]))
 
 (def: #export (repeat x)
   {#.doc "Repeat a value forever."}
   (All [a]
-    (-> a (Stream a)))
+    (-> a (Sequence a)))
   (pending [x (repeat x)]))
 
 (def: #export (cycle xs)
@@ -42,22 +42,22 @@
 
           The list should not be empty."}
   (All [a]
-    (-> (List a) (Maybe (Stream a))))
+    (-> (List a) (Maybe (Sequence a))))
   (case xs
     #.Nil          #.None
     (#.Cons x xs') (#.Some (cycle' x xs' x xs'))))
 
 (do-template [<name> <return> <part>]
   [(def: #export (<name> s)
-     (All [a] (-> (Stream a) <return>))
+     (All [a] (-> (Sequence a) <return>))
      (let [[h t] (continuation.run s)]
        <part>))]
 
   [head a          h]
-  [tail (Stream a) t])
+  [tail (Sequence a) t])
 
 (def: #export (nth idx s)
-  (All [a] (-> Nat (Stream a) a))
+  (All [a] (-> Nat (Sequence a) a))
   (let [[h t] (continuation.run s)]
     (if (n/> +0 idx)
       (nth (dec idx) t)
@@ -66,7 +66,7 @@
 (do-template [<taker> <dropper> <splitter> <pred-type> <pred-test> <pred-step>]
   [(def: #export (<taker> pred xs)
      (All [a]
-       (-> <pred-type> (Stream a) (List a)))
+       (-> <pred-type> (Sequence a) (List a)))
      (let [[x xs'] (continuation.run xs)]
        (if <pred-test>
          (list& x (<taker> <pred-step> xs'))
@@ -74,7 +74,7 @@
 
    (def: #export (<dropper> pred xs)
      (All [a]
-       (-> <pred-type> (Stream a) (Stream a)))
+       (-> <pred-type> (Sequence a) (Sequence a)))
      (let [[x xs'] (continuation.run xs)]
        (if <pred-test>
          (<dropper> <pred-step> xs')
@@ -82,7 +82,7 @@
 
    (def: #export (<splitter> pred xs)
      (All [a]
-       (-> <pred-type> (Stream a) [(List a) (Stream a)]))
+       (-> <pred-type> (Sequence a) [(List a) (Sequence a)]))
      (let [[x xs'] (continuation.run xs)]
        (if <pred-test>
          (let [[tail next] (<splitter> <pred-step> xs')]
@@ -94,53 +94,53 @@
   )
 
 (def: #export (unfold step init)
-  {#.doc "A stateful way of infinitely calculating the values of a stream."}
+  {#.doc "A stateful way of infinitely calculating the values of a sequence."}
   (All [a b]
-    (-> (-> a [a b]) a (Stream b)))
+    (-> (-> a [a b]) a (Sequence b)))
   (let [[next x] (step init)]
     (pending [x (unfold step next)])))
 
 (def: #export (filter p xs)
-  (All [a] (-> (-> a Bool) (Stream a) (Stream a)))
+  (All [a] (-> (-> a Bool) (Sequence a) (Sequence a)))
   (let [[x xs'] (continuation.run xs)]
     (if (p x)
       (pending [x (filter p xs')])
       (filter p xs'))))
 
 (def: #export (partition p xs)
-  {#.doc "Split a stream in two based on a predicate.
+  {#.doc "Split a sequence in two based on a predicate.
 
           The left side contains all entries for which the predicate is true.
 
           The right side contains all entries for which the predicate is false."}
-  (All [a] (-> (-> a Bool) (Stream a) [(Stream a) (Stream a)]))
+  (All [a] (-> (-> a Bool) (Sequence a) [(Sequence a) (Sequence a)]))
   [(filter p xs) (filter (complement p) xs)])
 
 ## [Structures]
-(struct: #export _ (Functor Stream)
+(struct: #export _ (Functor Sequence)
   (def: (map f fa)
     (let [[h t] (continuation.run fa)]
       (pending [(f h) (map f t)]))))
 
-(struct: #export _ (CoMonad Stream)
-  (def: functor Functor<Stream>)
+(struct: #export _ (CoMonad Sequence)
+  (def: functor Functor<Sequence>)
   (def: unwrap head)
   (def: (split wa)
     (let [[head tail] (continuation.run wa)]
       (pending [wa (split tail)]))))
 
 ## [Pattern-matching]
-(syntax: #export (^stream& {patterns (s.form (p.many s.any))}
-                           body
-                           {branches (p.some s.any)})
-  {#.doc (doc "Allows destructuring of streams in pattern-matching expressions."
-              "Caveat emptor: Only use it for destructuring, and not for testing values within the streams."
-              (let [(^stream& x y z _tail) (some-stream-func 1 2 3)]
+(syntax: #export (^sequence& {patterns (s.form (p.many s.any))}
+                             body
+                             {branches (p.some s.any)})
+  {#.doc (doc "Allows destructuring of sequences in pattern-matching expressions."
+              "Caveat emptor: Only use it for destructuring, and not for testing values within the sequences."
+              (let [(^sequence& x y z _tail) (some-sequence-func 1 2 3)]
                 (func x y z)))}
-  (with-gensyms [g!stream]
+  (with-gensyms [g!sequence]
     (let [body+ (` (let [(~+ (List/join (List/map (function (_ pattern)
-                                                    (list (` [(~ pattern) (~ g!stream)])
-                                                          (` ((~! continuation.run) (~ g!stream)))))
+                                                    (list (` [(~ pattern) (~ g!sequence)])
+                                                          (` ((~! continuation.run) (~ g!sequence)))))
                                                   patterns)))]
                      (~ body)))]
-      (wrap (list& g!stream body+ branches)))))
+      (wrap (list& g!sequence body+ branches)))))
diff --git a/stdlib/test/test/lux/data/coll/stream.lux b/stdlib/test/test/lux/data/coll/sequence.lux
index 9431e2a46..44eea350b 100644
--- a/stdlib/test/test/lux/data/coll/stream.lux
+++ b/stdlib/test/test/lux/data/coll/sequence.lux
@@ -7,12 +7,12 @@
              [text "Text/" Monoid<Text>]
              text/format
              (coll [list]
-                   ["&" stream])
+                   ["&" sequence])
              [number "Nat/" Codec<Text,Nat>])
        ["r" math/random])
   lux/test)
 
-(context: "Streams"
+(context: "Sequences"
   (<| (times +100)
       (do @
         [size (|> r.nat (:: @ map (|>> (n/% +100) (n/max +2))))
@@ -25,7 +25,7 @@
                sample0 (&.iterate inc +0)
                sample1 (&.iterate inc offset)]]
         ($_ seq
-            (test "Can move along a stream and take slices off it."
+            (test "Can move along a sequence and take slices off it."
                   (and (and (List/= (list.n/range +0 (dec size))
                                     (&.take size sample0))
                             (List/= (list.n/range offset (dec (n/+ offset size)))
@@ -50,12 +50,12 @@
             (test "Can repeat any element and infinite number of times."
                   (n/= elem (&.nth offset (&.repeat elem))))
 
-            (test "Can obtain the head & tail of a stream."
+            (test "Can obtain the head & tail of a sequence."
                   (and (n/= offset (&.head sample1))
                        (List/= (list.n/range (inc offset) (n/+ offset size))
                                (&.take size (&.tail sample1)))))
 
-            (test "Can filter streams."
+            (test "Can filter sequences."
                   (and (n/= (n/* +2 offset)
                             (&.nth offset
                                    (&.filter n/even? sample0)))
@@ -65,8 +65,8 @@
                               (n/= (inc (n/* +2 offset))
                                    (&.nth offset odds))))))
 
-            (test "Functor goes over 'all' elements in a stream."
-                  (let [(^open "&/") &.Functor<Stream>
+            (test "Functor goes over 'all' elements in a sequence."
+                  (let [(^open "&/") &.Functor<Sequence>
                         there (&/map (n/* factor) sample0)
                         back-again (&/map (n// factor) there)]
                     (and (not (List/= (&.take size sample0)
@@ -74,16 +74,16 @@
                          (List/= (&.take size sample0)
                                  (&.take size back-again)))))
 
-            (test "CoMonad produces a value for every element in a stream."
-                  (let [(^open "&/") &.Functor<Stream>]
+            (test "CoMonad produces a value for every element in a sequence."
+                  (let [(^open "&/") &.Functor<Sequence>]
                     (List/= (&.take size (&/map (n/* factor) sample1))
                             (&.take size
-                                    (be &.CoMonad<Stream>
+                                    (be &.CoMonad<Sequence>
                                       [inputs sample1]
                                       (n/* factor (&.head inputs)))))))
 
             (test "'unfold' generalizes 'iterate'."
-                  (let [(^open "&/") &.Functor<Stream>
+                  (let [(^open "&/") &.Functor<Sequence>
                         (^open "List/") (list.Eq<List> text.Eq<Text>)]
                     (List/= (&.take size
                                     (&/map Nat/encode (&.iterate inc offset)))
@@ -91,7 +91,7 @@
                                     (&.unfold (function (_ n) [(inc n) (Nat/encode n)])
                                               offset)))))
 
-            (test "Can cycle over the same elements as an infinite stream."
+            (test "Can cycle over the same elements as an infinite sequence."
                   (|> (&.cycle cycle-seed)
                       maybe.assume
                       (&.nth cycle-sample-idx)