@explorable-viz/fluid 0.11.1 → 0.11.2

package/dist/fluid/fluid/lib/graphics.fld

@@ -1,17 +1,17 @@
 def coords(Group(gs)): Point(0, 0)
 def coords(Rect(x, y, _, _, _)): Point(x, y)
 def coords(String(x, y, _, _, _)): Point(x, y)
-def coords(Viewport(x, y, _, _, _, _, _, _, _)): Point(x, y);
+def coords(Viewport(x, y, _, _, _, _, _, _, _)): Point(x, y)
 
 def get_x(g):
-  def Point(x, _): coords(g);
+  def Point(x, _): coords(g)
 
-  x;
+  x
 
 def get_y(g):
-  def Point(_, y): coords(g);
+  def Point(_, y): coords(g)
 
-  x;
+  x
 
 def set_x(x, Group(gs)):
   error("Group has immutable coordinates")
@@ -20,10 +20,10 @@ def set_x(x, Rect(_, y, w, h, fill)):
 def set_x(x, String(_, y, str, anchor, baseline)):
   String(x, y, str, anchor, baseline)
 def set_x(x, Viewport(_, y, w, h, fill, margin, scale, translate, g)):
-  Viewport(x, y, w, h, fill, margin, scale, translate, g);
+  Viewport(x, y, w, h, fill, margin, scale, translate, g)
 
 def dimensions2((Point(x1, y1), Point(x2, y2))):
-  Point(max(x1, x2), max(y1, y2));
+  Point(max(x1, x2), max(y1, y2))
 
 def dimensions(Group(gs)):
   foldl(curry(dimensions2), Point(0, 0), map(coords_op, gs))
@@ -34,22 +34,22 @@ def dimensions(String(_, _, _, _, _)): Point(0, 0)
 def dimensions(Viewport(_, _, w, h, _, _, _, _, _)): Point(w, h)
 def coords_op(g):
   def (Point(x, y), Point(w, h)):
-    prod(coords, dimensions, g);
+    prod(coords, dimensions, g)
 
-  Point(x + w, y + h);
+  Point(x + w, y + h)
 
 def width(g):
-  def Point(w, _): dimensions(g);
+  def Point(w, _): dimensions(g)
 
-  w;
+  w
 
 def height(g):
-  def Point(_, h): dimensions(g);
+  def Point(_, h): dimensions(g)
 
-  h;
+  h
 
 def spaceRight(z, sep, gs):
-  zipWith(set_x, iterate(length(gs), (+)(sep), z), gs);
+  zipWith(set_x, iterate(length(gs), (+)(sep), z), gs)
 
 def colours1: [
   "#66c2a5",
@@ -60,7 +60,7 @@ def colours1: [
   "#b3b3b3",
   "#8da0cb",
   "#e78ac3"
-];
+]
 
 def colours2: [
   "#e41a1c",
@@ -71,54 +71,54 @@ def colours2: [
   "#ffff33",
   "#a65628",
   "#f781bf"
-];
+]
 
 def scaleToWidth(w, Rect(x, y, _, h, fill)):
   Rect(x, y, w, h, fill)
 def scaleToWidth(w, Viewport(x, y, w0, h, fill, margin, Scale(x_scale, y_scale), translate, g)):
   def scale:
-    Scale((x_scale * w) / w0, y_scale);
+    Scale((x_scale * w) / w0, y_scale)
 
-  Viewport(x, y, w, h, fill, margin, scale, translate, g);
+  Viewport(x, y, w, h, fill, margin, scale, translate, g)
 
 def stackRight(sep, gs):
-  map(scaleToWidth(1 - sep), spaceRight(sep / 2, 1, gs));
+  map(scaleToWidth(1 - sep), spaceRight(sep / 2, 1, gs))
 
 def groupRight(sep, gs):
-  Viewport(0, 0, length(gs), maximum(map(height, gs)), "none", 0, Scale(1, 1), Translate(0, 0), Group(stackRight(sep, gs)));
+  Viewport(0, 0, length(gs), maximum(map(height, gs)), "none", 0, Scale(1, 1), Translate(0, 0), Group(stackRight(sep, gs)))
 
 def tickEvery(n):
   def m:
-    floor(logBase(10, n));
+    floor(logBase(10, n))
 
   if n <= 2 * 10 ** m: 2 * 10 ** (m - 1)
-  else: 10 ** m;
+  else: 10 ** m
 
 def axisStrokeWidth: 0.5
 def axisColour: "black"
 def backgroundColour: "white"
 def defaultMargin: 24
 def markerRadius: 3.5
-def tickLength: 4;
+def tickLength: 4
 
 def tick(Horiz, colour, len):
   Line(Point(0, 0), Point(0, 0 - len), colour, axisStrokeWidth)
 def tick(Vert, colour, len):
-  Line(Point(0, 0), Point(0 - len, 0), colour, axisStrokeWidth);
+  Line(Point(0, 0), Point(0 - len, 0), colour, axisStrokeWidth)
 
 def label(Horiz, x, distance, str):
   String(x, (0 - distance) - 4, str, "middle", "hanging")
 def label(Vert, x, distance, str):
-  String(0 - distance, x, str, "end", "central");
+  String(0 - distance, x, str, "end", "central")
 
 def labelledTick(orient, colour, len, str):
   Group([
     tick(orient, colour, len),
     label(orient, 0, len, str)
-  ]);
+  ])
 
 def mkPoint(Horiz, x, y): Point(y, x)
-def mkPoint(Vert, x, y): Point(x, y);
+def mkPoint(Vert, x, y): Point(x, y)
 
 def axis(orient, x, start, end):
   def tickSp:
@@ -146,75 +146,75 @@ def axis(orient, x, start, end):
     Group([
       Line(head(ps), last(ps), axisColour, axisStrokeWidth),
       Polymarkers(ps, flip(map, ys, compose(labelledTick(orient, axisColour, tickLength), numToStr)))
-    ]);
+    ])
 
-  (ax, lastTick);
+  (ax, lastTick)
 
 def catAxis(orient, x, catValues):
   def ys:
     iterate(length(catValues) + 1, (+)(1), 0)
   def ps:
-    map(mkPoint(orient, x), ys);
+    map(mkPoint(orient, x), ys)
 
   Group([
     Line(head(ps), last(ps), axisColour, axisStrokeWidth),
     Polymarkers(tail(ps), map(const(tick(orient, axisColour, tickLength)), catValues)),
-    Polymarkers(flip(map, tail(ps), (lambda Point(x, y): Point(x - 0.5, y))), map(label(orient, -0.5, 0), catValues))
-  ]);
+    Polymarkers(flip(map, tail(ps), lambda Point(x, y): Point(x - 0.5, y)), map(label(orient, -0.5, 0), catValues))
+  ])
 
 def viewport(x_start, x_finish, y_finish, margin, gs):
-  Viewport(0, 0, x_finish - x_start, y_finish, backgroundColour, margin, Scale(1, 1), Translate(0 - x_start, 0), Group(gs));
+  Viewport(0, 0, x_finish - x_start, y_finish, backgroundColour, margin, Scale(1, 1), Translate(0 - x_start, 0), Group(gs))
 
 def lineChart(withAxes, colours, x_start, data):
   def xs: map(fst, data)
   def nCat:
-    length(snd(head(data)));
+    length(snd(head(data)))
 
   def plot((n, colour)):
     def ps:
-      map((lambda (x, kvs): Point(x, snd(nth(n, kvs)))), data);
+      map(lambda (x, kvs): Point(x, snd(nth(n, kvs))), data)
 
     Group([
       Polyline(ps, colour, 1),
       Polymarkers(ps, repeat(length(ps), Circle(0, 0, markerRadius, colour)))
-    ]);
+    ])
 
   def lines:
     zipWith(curry(plot), iterate(nCat, (+)(1), 0), colours)
   def x_finish: last(xs)
   def y_finish:
-    maximum(flip(map, data, (lambda (_, kvs): maximum(map(snd, kvs)))));
+    maximum(flip(map, data, lambda (_, kvs): maximum(map(snd, kvs))))
 
   match withAxes:
     case True:
       def (x_axis, x_finish):
         axis(Horiz, 0, x_start, x_finish)
       def (y_axis, y_finish'):
-        axis(Vert, x_start, 0, y_finish);
+        axis(Vert, x_start, 0, y_finish)
 
       viewport(x_start, x_finish, y_finish', defaultMargin, x_axis :| y_axis :| lines)
     case False:
-      viewport(x_start, x_finish, y_finish, 0, lines);
+      viewport(x_start, x_finish, y_finish, 0, lines)
 
 def categoricalChart(plotValue, withAxes, colours, sep, data):
   def gs:
     stackRight(sep, plotValue(colours, map(snd, data)))
   def w: length(gs)
   def h:
-    maximum(map(height, gs));
+    maximum(map(height, gs))
 
   match withAxes:
     case True:
       def x_axis:
         catAxis(Horiz, 0, map(fst, data))
-      def (y_axis, h'): axis(Vert, 0, 0, h);
+      def (y_axis, h'): axis(Vert, 0, 0, h)
 
       viewport(0, w, h', defaultMargin, concat2(gs, [x_axis, y_axis]))
     case False:
-      viewport(0, w, h, 0, gs);
+      viewport(0, w, h, 0, gs)
 
 def rects(colours, ns):
-  zipWith((lambda colour, n: Rect(0, 0, 1, n, colour)), colours, ns);
+  zipWith(lambda colour, n: Rect(0, 0, 1, n, colour), colours, ns)
 
 def stackedBar(colours, ns):
   def heights: map(snd, ns)
@@ -223,24 +223,24 @@ def stackedBar(colours, ns):
   def dims:
     zip(0 :| subtotals, heights)
   def rects:
-    map((lambda ((y, height), colour): Rect(0, y, 1, height, colour)), zip(dims, colours));
+    map(lambda ((y, height), colour): Rect(0, y, 1, height, colour), zip(dims, colours))
 
-  Viewport(0, 0, 1, last(subtotals), "none", 0, Scale(1, 1), Translate(0, 0), Group(rects));
+  Viewport(0, 0, 1, last(subtotals), "none", 0, Scale(1, 1), Translate(0, 0), Group(rects))
 
 def barChart:
-  categoricalChart(rects);
+  categoricalChart(rects)
 
 def groupedBarChart:
-  categoricalChart(compose(map, flip(barChart(False), 0)));
+  categoricalChart(compose(map, flip(barChart(False), 0)))
 
 def stackedBarChart:
-  categoricalChart(compose(map, stackedBar));
+  categoricalChart(compose(map, stackedBar))
 
 def caption(str, Viewport(x, y, w, h, fill, margin, scale, translate, g)):
   def g':
     Group([
       String(x + w / 2, -2, str, "middle", "hanging"),
       Viewport(0, 0, w, h, fill, margin, scale, translate, g)
-    ]);
+    ])
 
-  Viewport(x, y, w, h, backgroundColour, defaultMargin / 2 + 4, Scale(1, 1), Translate(0, 0), g');
+  Viewport(x, y, w, h, backgroundColour, defaultMargin / 2 + 4, Scale(1, 1), Translate(0, 0), g')

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

@@ -36,5 +36,5 @@ def matMul(a, b):
   if not(n == i):
     error("Dimensions don't line up")
   else:
-    @doc("""Intermediate matrix""")
+    @doc(f"""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,12 +1,15 @@
 # "Num" throughout means (Int + Float).
 
+# To resolve in new semantics: expected dependencies don't arise for and/or unless they  make a fresh value.
 # Bool -> Bool
 def and(False, y): False
-def and(True, y): y
+def and(True, True): True
+def and(True, False): False
 
 # Bool -> Bool
 def or(True, y): True
-def or(False, y): y
+def or(False, True): True
+def or(False, False): False
 
 # Bool -> Bool
 def not(True): False
@@ -19,6 +22,10 @@ def compare(x, y):
     if x < y: LT
     else: EQ
 
+# (b -> b -> c) -> (a -> b) -> a -> a -> c
+def on(binOp, prop, x, y):
+  binOp(prop(x), prop(y))
+
 # Num -> Num
 def negate: (-)(0)
 
@@ -83,20 +90,23 @@ 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, []): None
 def find(p, x :| xs):
   if p(x): Some(x)
   else: find(p, xs)
 
 # String -> String -> List Dict -> Option Dict
-def findWithKey(fname, fval, d):
-  find((lambda y: y[fname] == fval), d)
+def findWithKey(k, v, rs):
+  find(lambda y: y[k] == v, rs)
 
 # Option a -> a
-def fromSome(None):
-  error("Expected Some!")
+def fromSome(None): error("Expected Some!")
 def fromSome(Some(x)): x
 
+# Option a -> a -> a
+def fromOption(None, y): y
+def fromOption(Some(x), _): x
+
 # (a -> Bool) -> List a -> List a
 def filter(p, []): []
 def filter(p, x :| xs):
@@ -113,6 +123,30 @@ def filterMap(p, x :| xs):
     case Some(y):
       y :| filterMap(f, xs)
 
+# Equivalent to but more efficient than length ∘ filter(p)
+def count_if(p):
+  def f(n, x):
+    if p(x): n + 1
+    else: n
+  foldl(f, 0)
+
+# Split list into longest initial segment whose elements satisfy a predicate, and the rest.
+# (a -> Bool) -> List a -> { init :: List a, rest :: List a }
+def span(p, Nil): { init: Nil, rest: Nil }
+def span(p, x :| xs_):
+  if p(x):
+    def { init: ys, rest: zs }: span(p, xs_)
+    { init: x :| ys, rest: zs }
+  else:
+    { init: Nil, rest: x :| xs_ }
+
+# Each returned list is non-empty.
+# (a -> a -> Bool) -> List a -> List (List a)
+def groupBy(eq, Nil): Nil
+def groupBy(eq, x :| xs):
+  def { init: ys, rest: zs }: span(eq(x), xs)
+  (x :| ys) :| groupBy(eq, zs)
+
 # (a -> b -> a) -> a -> List b -> a
 def foldl(op, z, []): z
 def foldl(op, z, x :| xs):
@@ -135,9 +169,7 @@ def foldr1(op, x :| y :| xs):
 def scanl1(op, z, xs):
   def go(x, continue, acc):
     def next: op(acc, x)
-
     next :| continue(next)
-
   foldr(go, const([]), xs, z)
 
 # (a -> b -> a) -> a -> List b -> List a
@@ -177,8 +209,13 @@ def iterate(n, f, z):
   else:
     z :| map(f, iterate(n - 1, f, z))
 
-# List Int -> Int
-def sum: foldr((+), 0)
+# List Num -> Num
+def sum: foldl((+), 0)
+
+# List Num -> Num
+def mean(xs):
+  def (s, n): foldl(lambda (s, n), x: (s + x, n + 1), (0, 0), xs)
+  s / n
 
 # List a -> a
 def last([x]): x
@@ -286,7 +323,8 @@ def abs(x, y):
 def nub(xs):
   def nub_([], _): []
   def nub_(x :| xs, ys):
-    if x |elem| ys: nub_(xs, ys)
+    if x |elem| ys:
+      nub_(xs, ys)
     else:
       x :| nub_(xs, x :| ys)
 

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

@@ -19,7 +19,7 @@ def mergesort(xs):
 
 def findQuantile(q, p, xs):
   def rank:
-    (p / q) * (length(xs) - 1);
+    (p / q) * (length(xs) - 1)
 
   if rank == floor(rank):
     nth(rank, xs)
@@ -36,7 +36,7 @@ def accumBins(data, Nil): []
 def accumBins(data, [l]): []
 def accumBins(data, l :| r :| es):
   def (ge, le):
-    splitOn((lambda x: x <= r), data)
+    splitOn(lambda x: x <= r, data)
   (le, r - l) :| accumBins(ge, r :| es)
 
 def cut(xs, nbins):
@@ -46,7 +46,7 @@ def cut(xs, nbins):
   def edges:
     [low + x * binwidth for x in enumFromTo(0, nbins)]
 
-  accumBins(xs, edges);
+  accumBins(xs, edges)
 
 def qcut(xs, qs):
   def (low, high):
@@ -57,13 +57,13 @@ def qcut(xs, qs):
   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) ++ "%"