@explorable-viz/fluid 0.11.1 → 0.11.3

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

@@ -1,18 +1,26 @@
+# type Colour = Str
+# type Colours = List Colour
+# type Cat = Str
+
+# Group has location (0, 0) because it doesn't interfere with positioning of its children.
+# GraphicsElement -> Point
 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)
 
+# GraphicsElement -> Float
 def get_x(g):
-  def Point(x, _): coords(g);
-
-  x;
+  def Point(x, _): coords(g)
+  x
 
+# GraphicsElement -> Float
 def get_y(g):
-  def Point(_, y): coords(g);
-
-  x;
+  def Point(_, y): coords(g)
+  y
 
+# Want some kind of typeclass mechanism plus record accessors/updaters.
+# Float -> GraphicsElement -> GraphicsElement
 def set_x(x, Group(gs)):
   error("Group has immutable coordinates")
 def set_x(x, Rect(_, y, w, h, fill)):
@@ -20,11 +28,16 @@ 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)
 
+# (Point, Point) -> Point
 def dimensions2((Point(x1, y1), Point(x2, y2))):
-  Point(max(x1, x2), max(y1, y2));
+  Point(max(x1, x2), max(y1, y2))
 
+# For Group, dimensions are relative to implicit coords of (0, 0), since a Group's children are effectively
+# positioned relative to parent of Group. For Polymarker, will probably have to ignore the markers themselves,
+# since they are scale-invariant.
+# GraphicsElement -> Point
 def dimensions(Group(gs)):
   foldl(curry(dimensions2), Point(0, 0), map(coords_op, gs))
 def dimensions(Polyline(ps, _, _)):
@@ -32,25 +45,28 @@ def dimensions(Polyline(ps, _, _)):
 def dimensions(Rect(_, _, w, h, _)): Point(w, h)
 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);
-
-  Point(x + w, y + h);
+    prod(coords, dimensions, g)
+  Point(x + w, y + h)
 
+# GraphicsElement -> Float
 def width(g):
-  def Point(w, _): dimensions(g);
-
-  w;
+  def Point(w, _): dimensions(g)
+  w
 
+# GraphicsElement -> Float
 def height(g):
-  def Point(_, h): dimensions(g);
-
-  h;
+  def Point(_, h): dimensions(g)
+  h
 
+# Float -> Float -> List GraphicsElement -> List GraphicsElement
 def spaceRight(z, sep, gs):
-  zipWith(set_x, iterate(length(gs), (+)(sep), z), gs);
+  zipWith(set_x, iterate(length(gs), (+)(sep), z), gs)
 
+# Bake colour decisions into the library for the time being. Provide two palettes, so we can have two
+# different sets of categorical values (e.g. countries and energy types). Palettes from colorbrewer2.org
 def colours1: [
   "#66c2a5",
   "#a6d854",
@@ -60,7 +76,7 @@ def colours1: [
   "#b3b3b3",
   "#8da0cb",
   "#e78ac3"
-];
+]
 
 def colours2: [
   "#e41a1c",
@@ -71,176 +87,188 @@ def colours2: [
   "#ffff33",
   "#a65628",
   "#f781bf"
-];
+]
 
+# Compositionality principle: child coords/dimensions are always expressed directly using parent reference
+# frame, to avoid depending on content of child, and so are not themselves scaled. Polyline can't be scaled
+# directly because it inherits its frame of reference from its parent. For Viewport, margin will shrink the
+# available area, possibly to zero, at which point nothing will be rendered.
+# Float -> GraphicsElement -> GraphicsElement
 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);
-
-  Viewport(x, y, w, h, fill, margin, scale, translate, g);
+  def scale: Scale((x_scale * w) / w0, y_scale)
+  Viewport(x, y, w, h, fill, margin, scale, translate, g)
 
+# Float -> List GraphicsElement -> List GraphicsElement
 def stackRight(sep, gs):
-  map(scaleToWidth(1 - sep), spaceRight(sep / 2, 1, gs));
+  map(scaleToWidth(1 - sep), spaceRight(sep / 2, 1, gs))
 
+# Float -> List GraphicsElement -> GraphicsElement
 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)))
 
+# Heuristic saying how often to place a tick on an axis of length n.
+# Float -> Float
 def tickEvery(n):
-  def m:
-    floor(logBase(10, n));
+  def m: 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
 
+# Helpers for axis functions.
+# Orient -> Colour -> Float -> GraphicsElement
 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)
 
+# Orient -> Float -> Float -> Str -> GraphicsElement
 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")
 
+# Orient -> Colour -> Float -> Str -> GraphicsElement
 def labelledTick(orient, colour, len, str):
   Group([
     tick(orient, colour, len),
     label(orient, 0, len, str)
-  ]);
+  ])
 
+# Orient -> Float -> Float -> Point
 def mkPoint(Horiz, x, y): Point(y, x)
-def mkPoint(Vert, x, y): Point(x, y);
+def mkPoint(Vert, x, y): Point(x, y)
 
+# x is position of this axis on the other axis. Returns axis and position of last tick.
+# Orient -> Float -> Float -> Float -> GraphicsElement
 def axis(orient, x, start, end):
-  def tickSp:
-    tickEvery(end - start)
-  def firstTick:
-    ceilingToNearest(start, tickSp)
-  def lastTick:
-    ceilingToNearest(end, tickSp)
-  def n:
-    floor((end - firstTick) / tickSp) + 1
-  def ys:
-    iterate(n, (+)(tickSp), firstTick)
+  def tickSp: tickEvery(end - start)
+  def firstTick: ceilingToNearest(start, tickSp)
+  def lastTick: ceilingToNearest(end, tickSp)
+  def n: floor((end - firstTick) / tickSp) + 1
+  def ys: iterate(n, (+)(tickSp), firstTick)
   def ys:
-    match firstTick > start:
-      case True: start :| ys
-      case False: ys
+    if firstTick > start: start :| ys
+    else: ys
   def ys:
-    match lastTick > end:
-      case True:
-        concat2(ys, [lastTick])
-      case False: ys
-  def ps:
-    map(mkPoint(orient, x), ys)
+    if lastTick > end: concat2(ys, [lastTick])
+    else: ys
+  def ps: map(mkPoint(orient, x), ys)
   def ax:
     Group([
       Line(head(ps), last(ps), axisColour, axisStrokeWidth),
       Polymarkers(ps, flip(map, ys, compose(labelledTick(orient, axisColour, tickLength), numToStr)))
-    ]);
+    ])
 
-  (ax, lastTick);
+  (ax, lastTick)
 
+# x is position of this axis on the other axis.
+# Orient -> Float -> List Cat -> GraphicsElement
 def catAxis(orient, x, catValues):
-  def ys:
-    iterate(length(catValues) + 1, (+)(1), 0)
-  def ps:
-    map(mkPoint(orient, x), ys);
+  def ys: iterate(length(catValues) + 1, (+)(1), 0)
+  def ps: 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))
+  ])
 
+# Float -> Float -> Float -> Float -> List GraphicsElement -> GraphicsElement
 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))
 
+# Plot a map of x values to lists of (categorical value, y value) pairs. Importantly, assume all data is uniform
+# (categorical keys are the same for each x value and are ordered the same each time).
+# Bool -> Colours -> Float -> List (Float, List (Cat, Float)) -> GraphicsElement
 def lineChart(withAxes, colours, x_start, data):
   def xs: map(fst, data)
-  def nCat:
-    length(snd(head(data)));
+  def nCat: length(snd(head(data)))
 
+  # (Int, Colour) -> GraphicsElement
   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)))
-    ]);
+    ])
 
+  # List GraphicsElement
   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)))));
-
-  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);
+    maximum(flip(map, data, lambda (_, kvs): maximum(map(snd, kvs))))
 
-      viewport(x_start, x_finish, y_finish', defaultMargin, x_axis :| y_axis :| lines)
-    case False:
-      viewport(x_start, x_finish, y_finish, 0, lines);
+  if withAxes:
+    def (x_axis, x_finish): axis(Horiz, 0, x_start, x_finish)
+    def (y_axis, y_finish_): axis(Vert, x_start, 0, y_finish)
+    viewport(x_start, x_finish, y_finish_, defaultMargin, x_axis :| y_axis :| lines)
+  else:
+    viewport(x_start, x_finish, y_finish, 0, lines)
 
+# Plot a chart of categorical values on the x-axis and renderings of the corresponding a-value on the y-axis.
+# (Colours -> List a -> GraphicsElement) -> Bool -> Colours -> Float -> List (Cat, a) -> GraphicsElement
 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));
-
-  match withAxes:
-    case True:
-      def x_axis:
-        catAxis(Horiz, 0, map(fst, data))
-      def (y_axis, h'): axis(Vert, 0, 0, h);
+  def h: maximum(map(height, gs))
 
-      viewport(0, w, h', defaultMargin, concat2(gs, [x_axis, y_axis]))
-    case False:
-      viewport(0, w, h, 0, gs);
+  if withAxes:
+    def x_axis: catAxis(Horiz, 0, map(fst, data))
+    def (y_axis, h_): axis(Vert, 0, 0, h)
+    viewport(0, w, h_, defaultMargin, concat2(gs, [x_axis, y_axis]))
+  else:
+    viewport(0, w, h, 0, gs)
 
+# Colours -> List a -> GraphicsElement
 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)
 
+# First component of data (categorical value) currently ignored; values just mapped positionally to colors.
+# Can we use Group instead of Viewport here?
+# Colours -> List (a, Num) -> GraphicsElement
 def stackedBar(colours, ns):
   def heights: map(snd, ns)
-  def subtotals:
-    scanl1((+), 0, heights)
-  def dims:
-    zip(0 :| subtotals, heights)
+  def subtotals: scanl1((+), 0, heights)
+  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))
 
+# Bool -> Colours -> Float -> List (a, Float) -> GraphicsElement
 def barChart:
-  categoricalChart(rects);
+  categoricalChart(rects)
 
+# For each categorical value of type a, plot a bar chart for the corresponding b-indexed data.
+# Bool -> Colours -> Float -> List (a, List (b, Float)) -> GraphicsElement
 def groupedBarChart:
-  categoricalChart(compose(map, flip(barChart(False), 0)));
+  categoricalChart(compose(map, flip(barChart(False), 0)))
 
+# See stackedBar for strong (unjustified) assumption about uniformity of data.
+# Bool -> Colours -> Num -> List (a, List (b, Num)) -> GraphicsElement
 def stackedBarChart:
-  categoricalChart(compose(map, stackedBar));
+  categoricalChart(compose(map, stackedBar))
 
+# Bit of a hack, but how text fits into our model is a bit unclear at the moment.
+# Str -> GraphicsElement -> GraphicsElement
 def caption(str, Viewport(x, y, w, h, fill, margin, scale, translate, g)):
-  def 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) ++ "%"