group-by, qsort et al (#183)

- Added some experimental prelude functions `group-by`, `discriminate`, `fnil`, `qsort`.

Author: gmorpheme

harness/test/052_group_by.eu

@@ -0,0 +1,14 @@
+"Tests for prelude `group-by`"
+
+class(n): if(n < 5, :small, :big)
+
+tests: {
+  α: [2, 4, 6, 8, 7] group-by(class) //= { small: [2, 4], big: [6, 8, 7] }
+  β: ["red", "yellow", "ruby", "rose", "blue", "beryl"]
+     group-by(sym ∘ first ∘ str.letters)
+     map-values(count)
+     //= { r: 3 y: 1 b: 2}
+  γ: [] group-by(identity) //= {}
+}
+
+RESULT: tests values all-true? then(:PASS, :FAIL)

harness/test/053_discriminate.eu

@@ -0,0 +1,9 @@
+"Tests for prelude `discriminate`"
+
+tests: {
+  α: [3, 6, 8, 7, 4] discriminate(_ < 6) //= [[3, 4], [6, 8, 7]]
+  β: [] discriminate(pos?) //= [[], []]
+  γ: [-32, 32, -64, 64, 0] discriminate(pos?) //= [[32, 64], [-32, -64, 0]]
+}
+
+RESULT: tests values all-true? then(:PASS, :FAIL)

harness/test/054_qsort.eu

@@ -0,0 +1,12 @@
+"Tests for prelude `qsort`."
+
+tests: {
+  α: [7,3,4,7,1,9] qsort(<) //= [1, 3, 4, 7, 7, 9]
+  β: [] qsort(<) //= []
+  γ: null fnil(qsort(<), []) //= []
+  δ: ["one", "two", "three", "four", "five", "six"]
+     qsort({ lhs: • rhs: • }.( (lhs str.letters count) < (rhs str.letters count) ))
+     //= ["one", "two", "six", "four", "five", "three"]
+}
+
+RESULT: tests values all-true? then(:PASS, :FAIL)

lib/prelude.eu

@@ -436,6 +436,11 @@ cond(l, d): l foldr(uncurry(if), d)
 ` "`juxt(f, g) - return function of `x` returning list of `f(x)` and g(x)`."
 juxt(f, g, x): [x f, x g]
 
+#
+# Utilities
+#
+` "`fnil(f, v, x)` - return a function equivalent to f except it sees `x` instead of `null` when null is passed."
+fnil(f, v, x): if(x = null, f(v), f(x))
 
 #
 # Metadata basics
@@ -645,6 +650,28 @@ over-sliding-pairs(f, l): l window(2, 1) map(f uncurry)
 ` "differences(l) - calculate difference between each overlapping pair in list of numbers `l`"
 differences: over-sliding-pairs(_1 - _0)
 
+` "`discriminate(pred, xs)` - return pair of `xs` for which `pred(_)` is true and `xs` for which `pred(_)` is false."
+discriminate(pred, xs): {
+  acc(a, e): a if(e pred, bimap(cons(e), identity), bimap(identity, cons(e)))
+}.(xs foldl(acc, [[], []]) bimap(reverse, reverse))
+
+` "`group-by(k, xs)` - group xs by key function returning block of key to subgroups, maintains order."
+group-by(k, xs): {
+  acc(a, e): a update-value-or(e._k, cons(e._v), [e._v])
+}.(xs map({ _k: k(•0), _v: •0 }) foldl(acc, {}) map-values(reverse))
+
+` "`qsort(lt, xs)` - sort `xs` using 'less-than' function `lt`"
+qsort(lt, xs): if(xs nil?,
+                  xs,
+                  {
+                    h: xs head
+                    t: xs tail
+                    less(x): lt(x, h)
+                    partitions: t discriminate(less)
+                    smaller: partitions first qsort(lt)
+                    bigger: partitions second qsort(lt)
+                  }.(smaller ++ [h] ++ bigger))
+
 #
 # Block library functions
 #

tests/harness_test.rs

@@ -250,3 +250,18 @@ pub fn test_harness_050() {
 pub fn test_harness_051() {
     run_test(&opts("051_head_or.eu"));
 }
+
+#[test]
+pub fn test_harness_052() {
+    run_test(&opts("052_group_by.eu"));
+}
+
+#[test]
+pub fn test_harness_053() {
+    run_test(&opts("053_discriminate.eu"));
+}
+
+#[test]
+pub fn test_harness_054() {
+    run_test(&opts("054_qsort.eu"));
+}