@explorable-viz/fluid 0.10.5 → 0.11.0

package/dist/fluid/fluid/lib/matrix.fld

@@ -1,44 +1,40 @@
 def zero(m, n, image):
-  def (m_max, n_max): dims(image);
-
+  def (m_max, n_max): dims(image)
   if m >= 1 |and| m <= m_max |and| n >= 1 |and| n <= n_max: image ! (m, n)
-  else: 0;
+  else: 0
 
 def wrap(m, n, image):
-  def (m_max, n_max): dims(image);
-
-  image ! (((m - 1) |mod| m_max) + 1, ((n - 1) |mod| n_max) + 1);
+  def (m_max, n_max): dims(image)
+  image ! (((m - 1) |mod| m_max) + 1, ((n - 1) |mod| n_max) + 1)
 
 def extend(m, n, image):
   def (m_max, n_max): dims(image)
   def m':
     min(max(m, 1), m_max)
   def n':
-    min(max(n, 1), n_max);
-
-  image ! (m', n');
+    min(max(n, 1), n_max)
+  image ! (m', n')
 
 def matrixSum(matr):
-  def (m, n): dims(matr);
-
-  foldl((+), 0, [matr ! (i, j) for (i, j) in range((1, 1), (m, n))]);
+  def (m, n): dims(matr)
+  foldl((+), 0, [matr ! (i, j) for (i, j) in range((1, 1), (m, n))])
 
 def convolve(image, kernel, lookup):
   def ((m, n), (i, j)):
     (dims(image), dims(kernel))
   def (half_i, half_j):
     (i |quot| 2, j |quot| 2)
-  def area: i * j;
+  def area: i * j
   def interMatrix(m', n'):
-    @doc("""Intermediate matrix for element ( ${m'} , ${n'} )""")
-    [| @doc("""Multiply these two elements""") lookup(((m' + i') - 1) - half_i, ((n' + j') - 1) - half_j, image) * kernel ! (i', j') for (i', j') in (i, j) |];
+    [| lookup(((m' + i') - 1) - half_i, ((n' + j') - 1) - half_j, image) * kernel ! (i', j') for (i', j') in (i, j) |]
 
-  [| matrixSum(interMatrix(m', n')) |quot| area for (m', n') in (m, n) |];
+  [| matrixSum(interMatrix(m', n')) |quot| area for (m', n') in (m, n) |]
 
 def matMul(a, b):
-  def ((m, n), (i, j)): (dims(a), dims(b));
+  def ((m, n), (i, j)): (dims(a), dims(b))
 
   if not(n == i):
     error("Dimensions don't line up")
   else:
-    @doc("""Intermediate matrix""") [| sum([a ! (i', k) * b ! (k, j') for k in enumFromTo(1, n)]) for (i', j') in (m, j) |];
+    @doc("""Intermediate matrix""")
+    [| sum([a!(i_, k) * b!(k, j_) for k in enumFromTo(1, n)]) for (i_, j_) in (m, j) |]

package/dist/fluid/fluid/lib/prelude.fld

@@ -1,74 +1,103 @@
+# "Num" throughout means (Int + Float).
+
+# Bool -> Bool
 def and(False, y): False
 def and(True, y): y
 
+# Bool -> Bool
 def or(True, y): True
 def or(False, y): y
 
+# Bool -> Bool
 def not(True): False
 def not(False): True
 
+# Int -> Int -> Ordering
 def compare(x, y):
   if x > y: GT
   else:
     if x < y: LT
     else: EQ
 
+# Num -> Num
 def negate: (-)(0)
 
+# Log of x in base y.
+# Float -> Float -> Float
 def logBase(x, y): log(y) / log(x)
 
+# Float -> Float -> Float
 def ceilingToNearest(n, m): ceiling(n / m) * m
 
+# (b -> c) -> (a -> b) -> a -> c
+# Want infix <<<
 def compose(f, g, x): f(g(x))
 
+# ((a, b) -> c) -> a -> b -> c
 def curry(f, x, y): f((x, y))
 
+# (a -> b -> c) -> (a, b) -> c
 def uncurry(f, (x, y)): f(x, y)
 
+# a -> b -> a
 def const(x, _): x
 
+# (a -> b) -> (a, c) -> (b, c)
 def first(f, (a, c)): (f(a), c)
 
+# (a, b) -> b
 def snd((_, y)): y
 
+# (a -> b) -> (c, a) -> (c, b)
 def second(f, (c, a)): (c, f(a))
 
+# (a -> b -> c) -> b -> a -> c
 def flip(f, x, y): f(y, x)
 
+# (a, b) -> a
 def fst((x, _)): x
 
+# a -> a
 def id(x): x
 
+# (a -> b) -> (a -> c) -> a -> (b, c)
+# Want infix &&&
 def prod(f, g, x): (f(x), g(x))
 
+# (a, b) -> (b, a)
 def swap((a, b)): (b, a)
 
+# List a -> a
 def head([]):
   error("Can't take head of empty list")
 def head(x :| _): x
 
+# List a -> List a
 def tail([]):
   error("Can't take tail of empty list")
 def tail(_ :| xs): xs
 
+# Eq a => a -> List a -> Bool
 def elem(x, []): False
 def elem(x, y :| xs):
   x == y |or| elem(x, xs)
 
+# (a -> Bool) -> List a -> Option a
 def find(p, []): error("not found")
 def find(p, x :| xs):
   if p(x): Some(x)
   else: find(p, xs)
 
-def findWithKey(fname, fval, table):
-  find((lambda y: y[fname] == fval), table)
+# String -> String -> List Dict -> Option Dict
+def findWithKey(fname, fval, d):
+  find((lambda y: y[fname] == fval), d)
 
-def fromSome(option):
-  match option:
-    case None:
-      error("Expected Some!")
-    case Some(x): x
+# Option a -> a
+def fromSome(None):
+  error("Expected Some!")
+def fromSome(Some(x)): x
 
+# (a -> Bool) -> List a -> List a
 def filter(p, []): []
 def filter(p, x :| xs):
   def ys: filter(p, xs)
@@ -76,6 +105,7 @@ def filter(p, x :| xs):
   if p(x): x :| ys
   else: ys
 
+# (a -> Option b) -> List a -> List b
 def filterMap(p, []): []
 def filterMap(p, x :| xs):
   match p(x):
@@ -83,20 +113,25 @@ def filterMap(p, x :| xs):
     case Some(y):
       y :| filterMap(f, xs)
 
+# (a -> b -> a) -> a -> List b -> a
 def foldl(op, z, []): z
 def foldl(op, z, x :| xs):
   foldl(op, op(z, x), xs)
 
+# (a -> b -> a) -> List b -> a
 def foldl1(op, x :| xs): foldl(op, x, xs)
 
+# (a -> b -> b) -> b -> List a -> b
 def foldr(op, z, []): z
 def foldr(op, z, x :| xs):
   op(x, foldr(op, z, xs))
 
+# (a -> b -> b) -> List a -> b
 def foldr1(op, [x]): x
 def foldr1(op, x :| y :| xs):
   op(x, foldr1(op, y :| xs))
 
+# (a -> b -> a) -> a -> List b -> List a
 def scanl1(op, z, xs):
   def go(x, continue, acc):
     def next: op(acc, x)
@@ -105,48 +140,63 @@ def scanl1(op, z, xs):
 
   foldr(go, const([]), xs, z)
 
+# (a -> b -> a) -> a -> List b -> List a
 def scanl(op, z, xs):
   z :| scanl1(op, z, xs)
 
+# (a -> b) -> List a -> List b
 def map(f, []): []
 def map(f, x :| xs): f(x) :| map(f, xs)
 
+# (List a, List a) -> List a
 def append(([], ys)): ys
 def append((x :| xs, ys)):
   x :| append((xs, ys))
 
+# List a -> List -> List a
+# Want infix ++
 def concat2([], ys): ys
 def concat2(x :| xs, ys):
   x :| concat2(xs, ys)
 
+# List (List a) -> List a
 def concat: foldl(concat2, [])
 
+# (a -> List b) -> List a -> List b
 def concatMap(f, xs): concat(map(f, xs))
 
+# List a -> a -> List a
 def intersperse([], _): []
 def intersperse([x], _): [x]
 def intersperse(x :| y :| ys, sep):
   x :| sep :| intersperse(y :| ys, sep)
 
+# Int -> (a -> a) -> a -> List a
 def iterate(n, f, z):
   if n == 0: []
   else:
     z :| map(f, iterate(n - 1, f, z))
 
+# List Int -> Int
 def sum: foldr((+), 0)
 
+# List a -> a
 def last([x]): x
 def last(x :| y :| ys): last(y :| ys)
 
+# List a -> Int
 def length([]): 0
 def length(_ :| xs): 1 + length(xs)
 
+# List a -> List a
 def reverse([]): []
 def reverse(x :| xs):
   append((reverse(xs), [x]))
 
+# Int -> a -> List a
 def repeat: flip(iterate, id)
 
+# Int -> List a -> List a
 def take(n, xs):
   if n <= 0: []
   else:
@@ -155,6 +205,7 @@ def take(n, xs):
       case x :| xs:
         x :| take(n - 1, xs)
 
+# Int -> List a -> List a
 def drop(n, xs):
   if n <= 0: xs
   else:
@@ -162,58 +213,76 @@ def drop(n, xs):
       case []: []
       case _ :| xs: drop(n - 1, xs)
 
+# Int -> List a -> List a
 def lastN(n, xs):
   foldl(compose(const, drop(1)), xs, drop(n, xs))
 
+# Expects non-negative integer as first argument and non-empty list as second argument.
+# Int -> List a -> a
 def nth(n, x :| xs):
   if n == 0: x
   else: nth(n - 1, xs)
 
+# Matrix Int -> Int -> Int -> Int
 def nth2(i, j, xss):
   nth(j - 1, nth(i - 1, xss))
 
+# Partial; requires k to be in the map.
+# Int -> List (Int, b) -> b
 def lookup(k, []):
   error("Key not found in map")
 def lookup(k, (k_, v) :| kvs):
   if k == k_: v
   else: lookup(k, kvs)
 
+# Int -> Int -> Int
 def max(n, m):
   if n > m: n
   else: m
 
+# Int -> Int -> Int
 def min(n, m):
   if n < m: n
   else: m
 
+# List Int -> Int
 def maximum: foldr1(max)
 
+# List Int -> Int
 def minimum: foldr1(min)
 
+# List (a, b) -> (List a, List b)
 def unzip([]): ([], [])
 def unzip((x, y) :| zs):
   def (xs, ys): unzip(zs)
-
   (x :| xs, y :| ys)
 
+# (a -> b -> c) -> List a -> List b -> List c
 def zipWith(op, [], ys): []
 def zipWith(op, x :| xs, []): []
 def zipWith(op, x :| xs, y :| ys):
   op(x, y) :| zipWith(op, xs, ys)
 
+# List a -> List b -> List (a, b)
 def zip: zipWith(curry(id))
 
+# Rename to 'range'
+# Int -> Int -> List Int
 def enumFromTo(n, m):
   if n <= m: n :| [n + 1 .. m]
   else: []
 
+# Rename to 'range2'
+# (Int, Int) -> (Int, Int) -> List (Int, Int)
 def range((m1, n1), (m2, n2)):
   [(i1, i2) for i1 in [m1 .. m2] for i2 in [n1 .. n2]]
 
+# Int -> Int -> Int
 def abs(x, y):
   if x - y < 0: negate(x - y)
   else: x - y
 
+# Eq a => [a] -> [a]
 def nub(xs):
   def nub_([], _): []
   def nub_(x :| xs, ys):
@@ -223,9 +292,11 @@ def nub(xs):
 
   nub_(xs, [])
 
+# Int -> Int -> [a] -> [a]
 def slice(begin, end, xs):
   take(end - begin, drop(begin, xs))
 
+# (a -> Boolean) -> List a -> (List a, List a)
 def splitOn(p, data):
   def go(fls, trs, []):
     (reverse(fls), reverse(trs))

package/dist/fluid/fluid/lib/stats.fld

@@ -1,53 +1,50 @@
 def split([]): ([], [])
 def split(x :| xs):
-  def (ys, zs): split(xs);
-
-  (x :| zs, ys);
+  def (ys, zs): split(xs)
+  (x :| zs, ys)
 
 def merge(xs, ys):
   match (xs, ys):
     case ([], _): ys
-    case (x :| xs', []): xs
-    case (x :| xs', y :| ys'):
-      if x < y: x :| merge(xs', ys)
-      else: y :| merge(xs, ys');
+    case (x :| xs_, []): xs
+    case (x :| xs_, y :| ys_):
+      if x < y: x :| merge(xs_, ys)
+      else: y :| merge(xs, ys_)
 
 def mergesort(xs):
   if length(xs) < 2: xs
   else:
-    def (ys, zs): split(xs);
-
-    merge(mergesort(ys), mergesort(zs));
+    def (ys, zs): split(xs)
+    merge(mergesort(ys), mergesort(zs))
 
 def findQuantile(q, p, xs):
   def rank:
     (p / q) * (length(xs) - 1);
 
-  if rank == floor(rank): nth(rank, xs)
+  if rank == floor(rank):
+    nth(rank, xs)
   else:
     def x1: floor(rank)
     def x2: ceiling(rank)
     def left: nth(x1, xs)
-    def right: nth(x2, xs);
-
-    left + (rank - x1) * (right - left);
+    def right: nth(x2, xs)
+    left + (rank - x1) * (right - left)
 
-def findPercentile: findQuantile(100);
+def findPercentile: findQuantile(100)
 
 def accumBins(data, Nil): []
 def accumBins(data, [l]): []
 def accumBins(data, l :| r :| es):
   def (ge, le):
-    splitOn((lambda x: x <= r), data);
-
-  (le, r - l) :| accumBins(ge, r :| es);
+    splitOn((lambda x: x <= r), data)
+  (le, r - l) :| accumBins(ge, r :| es)
 
 def cut(xs, nbins):
   def low: minimum(xs)
   def binwidth:
     (maximum(xs) - low) / nbins
   def edges:
-    [low + x * binwidth for x in enumFromTo(0, nbins)];
+    [low + x * binwidth for x in enumFromTo(0, nbins)]
 
   accumBins(xs, edges);
 
@@ -55,32 +52,32 @@ def qcut(xs, qs):
   def (low, high):
     (minimum(xs), maximum(xs))
   def edges:
-    append((low :| [findPercentile(x, xs) for x in qs], [high]));
+    append((low :| [findPercentile(x, xs) for x in qs], [high]))
 
-  accumBins(xs, edges);
+  accumBins(xs, edges)
 
 def likelihoodLE(xs, target):
-  length(filter((lambda x: x <= target), xs)) / length(xs);
+  length(filter((lambda x: x <= target), xs)) / length(xs)
 
 def likelihoodGE(xs, target):
-  length(filter((lambda x: x >= target), xs)) / length(xs);
+  length(filter((lambda x: x >= target), xs)) / length(xs)
 
 def likelihoodMap(table, prob):
-  fromSome(find((lambda x: x.prob <= prob), table)).msg;
+  fromSome(find((lambda x: x.prob <= prob), table)).msg
 
 def mkPercent(num):
-  numToStr(num * 100) ++ "%";
+  numToStr(num * 100) ++ "%"
 
 def leqP(n, m):
   if n <= m: "less"
-  else: "more";
+  else: "more"
 
 def gradedLeqP(n, m):
-  def ratio: n / m;
+  def ratio: n / m
 
   if ratio <= 1.0:
     if ratio <= 0.5: "much less"
     else: "less"
   else:
     if ratio >= 2.0: "much more"
-    else: "more";
+    else: "more"