Seq.expand

Author: jmagaram

CHANGELOG.md

@@ -1,3 +1,7 @@
+## Version 4.4.0
+
+- `Seq.expand` is new and similar to `Seq.unfold` but recursively generates a sequence of sequences.
+
 ## Version 4.3.0
 
 - `Seq.iterateWhile` generates a sequence until the interation function returns `None`.

README.md

@@ -56,6 +56,7 @@ let cons: ('a, t<'a>) => t<'a>
 let cycle: t<'a> => t<'a>
 let delay: (unit => t<'a>) => t<'a>
 let empty: t<'a>
+let expand: ('a, 'a => t<('b, 'a)>) => t<t<'b>>
 let forever: 'a => t<'a>
 let foreverWith: (unit => 'a) => t<'a>
 let fromArray: (~start: int=?, ~end: int=?, array<'a>) => t<'a>

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmagaram/rescript-seq",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "module": "",
   "description": "Lazy sequences for ReScript.",
   "keywords": [

src/Seq.res

@@ -952,3 +952,9 @@ let iterateWhile = (seed, f) => () => {
     }
   Next(seed, go(seed))
 }
+
+let rec expand = (seed, f) =>
+  seed
+  ->f
+  ->flatMap(((n, seed)) => expand(seed, f)->map(result => cons(n, result)))
+  ->orElse(empty->once)

src/Seq.resi

@@ -35,6 +35,12 @@ Seq.unfold(1, i => i < 100 ? Some(i, i * 2) : None) // [1, 2, 4, 8, 16, 32, 64]
 */
 let unfold: ('seed, 'seed => option<('a, 'seed)>) => t<'a>
 
+/**
+`expand(seed, f)` creates a sequence of sequences through a recursive
+computation. Similar to `unfold`.
+*/
+let expand: ('seed, 'seed => t<('a, 'seed)>) => t<t<'a>>
+
 /**
 `init(count, f)` initializes a sequence based on a `count` and a function `f`
 that is provided index values from 0 up to `count-1`.

tests/Seq__SeqTests.res

@@ -797,6 +797,42 @@ let unfoldTests =
     ),
   ])
 
+let expandTests = {
+  // for a given seed string, return each character and a new seed which is all
+  // the characters that follow it
+  let combos = s => {
+    s
+    ->String.split("")
+    ->Seq.fromArray
+    ->Seq.indexed
+    ->Seq.map(((char, inx)) => (char, s->String.sliceToEnd(~start=inx + 1)))
+  }
+
+  let format = xxx =>
+    xxx
+    ->Seq.map(xx => xx->Seq.toArray->Array.joinWith(""))
+    ->Seq.toArray
+    ->Seq.fromArray
+
+  makeSeqEqualsTests(
+    ~title="expand",
+    [
+      (S.expand("abcd", combos)->format, ["abcd", "abd", "acd", "ad", "bcd", "bd", "cd", "d"], ""),
+      (S.expand("abc", combos)->format, ["abc", "ac", "bc", "c"], ""),
+      (S.expand("ab", combos)->format, ["ab", "b"], ""),
+      (S.expand("a", combos)->format, ["a"], ""),
+      (
+        S.expand("abcdefghijklmnopqrstuv", combos)
+        ->Seq.last
+        ->Option.map(s => s->Seq.once->format)
+        ->Option.getExn,
+        ["v"],
+        "millions",
+      ),
+    ],
+  )
+}
+
 let initTests =
   makeSeqEqualsTests(
     ~title="init",
@@ -2229,6 +2265,7 @@ let tests =
     everySomeTests,
     everyTests,
     exactlyOneTests,
+    expandTests,
     filterMapiTests,
     filterMapTests,
     filterOkTests,