@explorable-viz/fluid 0.11.4 → 0.12.2

package/README.md

@@ -1,31 +1,44 @@
 ## Fluid: Language-integrated data provenance
 
-Fluid is an experimental programming language which integrates a bidirectional dynamic analysis to connect outputs to data sources in a fine-grained way. Fluid is implemented in PureScript and runs in the browser.
+Fluid is a pure functional programming language, with a provenance-tracking runtime and Pythonic syntax. Fluid is implemented in PureScript and runs in the browser.
 
 [![develop](https://github.com/explorable-viz/fluid/actions/workflows/develop.yml/badge.svg)](https://github.com/explorable-viz/fluid/actions/workflows/develop.yml)
 [![GitHub pages](https://github.com/explorable-viz/fluid/actions/workflows/pages/pages-build-deployment/badge.svg)](https://github.com/explorable-viz/fluid/actions/workflows/pages/pages-build-deployment)
 
-## Installation
+## End-user setup
 
 ### Software required
-- git
 - Node.js >=18.0.0
 - yarn >= 1.22
 
-Additionally, for Windows users only:
+### Initial configuration
+
+Building a Fluid website usually involves building a Node application:
+
+- `yarn add @explorable-viz/fluid`
+- `yarn install` to install Node dependencies
+- `yarn install-website article` to copy example article website from `@exploreable-viz/fluid`
+- Add `dist/` and `website/` folders to `.gitignore` 
 
-- [Ubuntu WSL](https://ubuntu.com/desktop/wsl)
+### Bundling and serving website
+- `yarn bundle-website $WEBSITE_NAME` to bundle website to `dist/$WEBSITE_NAME`
+- `npx http-serve dist/$WEBSITE_NAME -c-1` to serve website at localhost
+
+## Development setup
+
+### Additional software required
+- git
+- (Windows only) [Ubuntu WSL](https://ubuntu.com/desktop/wsl)
 
-### Building
+### Initial configuration
 
-- Clone the repository (for Windows users, do this under the Ubuntu WSL)
+- Clone repository (for Windows users, under Ubuntu WSL)
 - Run `./script/setup/dev-setup.sh` from the top-level directory
 - `yarn install` to install Node dependencies
-- `yarn build`
 
 ## Use
 
-The following assumes you have already successfully run `yarn build` (see above).
+- `yarn build` to build interpreter
 
 ### Running programs from the command line
 

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

@@ -62,8 +62,8 @@ def height(g):
   h
 
 # Float -> Float -> List GraphicsElement -> List GraphicsElement
-def spaceRight(z, sep, gs):
-  zipWith(set_x, iterate(length(gs), (+)(sep), z), gs)
+def space_right(z, sep, gs):
+  zip_with(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
@@ -94,41 +94,41 @@ def colours2: [
 # 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)):
+def scale_to_width(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_to_width(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)
 
 # Float -> List GraphicsElement -> List GraphicsElement
-def stackRight(sep, gs):
-  map(scaleToWidth(1 - sep), spaceRight(sep / 2, 1, gs))
+def stack_right(sep, gs):
+  map(scale_to_width(1 - sep), space_right(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)))
+def group_right(sep, gs):
+  Viewport(0, 0, length(gs), maximum(map(height, gs)), "none", 0, Scale(1, 1), Translate(0, 0), Group(stack_right(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 tick_every(n):
+  def m: floor(log_base(10, n))
 
   if n <= 2 * 10 ** m: 2 * 10 ** (m - 1)
   else: 10 ** m
 
-def axisStrokeWidth: 0.5
-def axisColour: "black"
-def backgroundColour: "white"
-def defaultMargin: 24
-def markerRadius: 3.5
-def tickLength: 4
+def axis_stroke_width: 0.5
+def axis_colour: "black"
+def background_colour: "white"
+def default_margin: 24
+def marker_radius: 3.5
+def tick_length: 4
 
 # Helpers for axis functions.
 # Orient -> Colour -> Float -> GraphicsElement
 def tick(Horiz, colour, len):
-  Line(Point(0, 0), Point(0, 0 - len), colour, axisStrokeWidth)
+  Line(Point(0, 0), Point(0, 0 - len), colour, axis_stroke_width)
 def tick(Vert, colour, len):
-  Line(Point(0, 0), Point(0 - len, 0), colour, axisStrokeWidth)
+  Line(Point(0, 0), Point(0 - len, 0), colour, axis_stroke_width)
 
 # Orient -> Float -> Float -> Str -> GraphicsElement
 def label(Horiz, x, distance, str):
@@ -137,61 +137,61 @@ def label(Vert, x, distance, str):
   String(0 - distance, x, str, "end", "central")
 
 # Orient -> Colour -> Float -> Str -> GraphicsElement
-def labelledTick(orient, colour, len, str):
+def labelled_tick(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 mk_point(Horiz, x, y): Point(y, x)
+def mk_point(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 tick_sp: tick_every(end - start)
+  def first_tick: ceiling_to_nearest(start, tick_sp)
+  def last_tick: ceiling_to_nearest(end, tick_sp)
+  def n: floor((end - first_tick) / tick_sp) + 1
+  def ys: iterate(n, (+)(tick_sp), first_tick)
   def ys:
-    if firstTick > start: start :| ys
+    if first_tick > start: start :| ys
     else: ys
   def ys:
-    if lastTick > end: concat2(ys, [lastTick])
+    if last_tick > end: concat2(ys, [last_tick])
     else: ys
-  def ps: map(mkPoint(orient, x), ys)
+  def ps: map(mk_point(orient, x), ys)
   def ax:
     Group([
-      Line(head(ps), last(ps), axisColour, axisStrokeWidth),
-      Polymarkers(ps, flip(map, ys, compose(labelledTick(orient, axisColour, tickLength), numToStr)))
+      Line(head(ps), last(ps), axis_colour, axis_stroke_width),
+      Polymarkers(ps, flip(map, ys, compose(labelled_tick(orient, axis_colour, tick_length), num_to_str)))
     ])
 
-  (ax, lastTick)
+  (ax, last_tick)
 
 # 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 cat_axis(orient, x, cat_values):
+  def ys: iterate(length(cat_values) + 1, (+)(1), 0)
+  def ps: map(mk_point(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))
+    Line(head(ps), last(ps), axis_colour, axis_stroke_width),
+    Polymarkers(tail(ps), map(const(tick(orient, axis_colour, tick_length)), cat_values)),
+    Polymarkers(flip(map, tail(ps), lambda Point(x, y): Point(x - 0.5, y)), map(label(orient, -0.5, 0), cat_values))
   ])
 
 # 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, background_colour, 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 line_chart(with_axes, colours, x_start, data):
   def xs: map(fst, data)
-  def nCat: length(snd(head(data)))
+  def n_cat: length(snd(head(data)))
 
   # (Int, Colour) -> GraphicsElement
   def plot((n, colour)):
@@ -200,46 +200,46 @@ def lineChart(withAxes, colours, x_start, data):
 
     Group([
       Polyline(ps, colour, 1),
-      Polymarkers(ps, repeat(length(ps), Circle(0, 0, markerRadius, colour)))
+      Polymarkers(ps, repeat(length(ps), Circle(0, 0, marker_radius, colour)))
     ])
 
   # List GraphicsElement
   def lines:
-    zipWith(curry(plot), iterate(nCat, (+)(1), 0), colours)
+    zip_with(curry(plot), iterate(n_cat, (+)(1), 0), colours)
   def x_finish: last(xs)
   def y_finish:
     maximum(flip(map, data, lambda (_, kvs): maximum(map(snd, kvs))))
 
-  if withAxes:
+  if with_axes:
     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)
+    viewport(x_start, x_finish, y_finish_, default_margin, 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 categorical_chart(plot_value, with_axes, colours, sep, data):
   def gs:
-    stackRight(sep, plotValue(colours, map(snd, data)))
+    stack_right(sep, plot_value(colours, map(snd, data)))
   def w: length(gs)
   def h: maximum(map(height, gs))
 
-  if withAxes:
-    def x_axis: catAxis(Horiz, 0, map(fst, data))
+  if with_axes:
+    def x_axis: cat_axis(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]))
+    viewport(0, w, h_, default_margin, 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)
+  zip_with(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 stacked_bar(colours, ns):
   def heights: map(snd, ns)
   def subtotals: scanl1((+), 0, heights)
   def dims: zip(0 :| subtotals, heights)
@@ -249,18 +249,18 @@ def stackedBar(colours, ns):
   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)
+def bar_chart:
+  categorical_chart(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)))
+def grouped_bar_chart:
+  categorical_chart(compose(map, flip(bar_chart(False), 0)))
 
-# See stackedBar for strong (unjustified) assumption about uniformity of data.
+# See stacked_bar for strong (unjustified) assumption about uniformity of data.
 # Bool -> Colours -> Num -> List (a, List (b, Num)) -> GraphicsElement
-def stackedBarChart:
-  categoricalChart(compose(map, stackedBar))
+def stacked_bar_chart:
+  categorical_chart(compose(map, stacked_bar))
 
 # Bit of a hack, but how text fits into our model is a bit unclear at the moment.
 # Str -> GraphicsElement -> GraphicsElement
@@ -271,4 +271,4 @@ def caption(str, Viewport(x, y, w, h, fill, margin, scale, translate, g)):
       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, background_colour, default_margin / 2 + 4, Scale(1, 1), Translate(0, 0), g_)

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

@@ -1,23 +1,23 @@
 def zero(m, n, 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)
+  def (m_size, n_size): dims(image)
+  if m >= 0 and m < m_size and n >= 0 and n < n_size: image ! (m, n)
   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_size, n_size): dims(image)
+  image ! (m % m_size, n % n_size)
 
 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')
+  def (m_size, n_size): dims(image)
+  def m_:
+    min(max(m, 0), m_size - 1)
+  def n_:
+    min(max(n, 0), n_size - 1)
+  image ! (m_, n_)
 
-def matrixSum(matr):
+def matrix_sum(matr):
   def (m, n): dims(matr)
-  foldl((+), 0, [matr ! (i, j) for (i, j) in range((1, 1), (m, n))])
+  foldl((+), 0, [matr ! (i, j) for (i, j) in range2d((0, 0), (m, n))])
 
 def convolve(image, kernel, lookup):
   def ((m, n), (i, j)):
@@ -25,16 +25,16 @@ def convolve(image, kernel, lookup):
   def (half_i, half_j):
     (i |quot| 2, j |quot| 2)
   def area: i * j
-  def interMatrix(m', n'):
-    [| lookup(((m' + i') - 1) - half_i, ((n' + j') - 1) - half_j, image) * kernel ! (i', j') for (i', j') in (i, j) |]
+  def interMatrix(m_, n_):
+    [| lookup(m_ + i_ - half_i, n_ + j_ - half_j, image) * kernel ! (i_, j_) for (i_, j_) in (i, j) |]
 
-  [| matrixSum(interMatrix(m', n')) |quot| area for (m', n') in (m, n) |]
+  [| matrix_sum(interMatrix(m_, n_)) |quot| area for (m_, n_) in (m, n) |]
 
-def matMul(a, b):
+def mat_mul(a, b):
   def ((m, n), (i, j)): (dims(a), dims(b))
 
   if not(n == i):
     error("Dimensions don't line up")
   else:
     @doc(f"""Intermediate matrix""")
-    [| sum([a!(i_, k) * b!(k, j_) for k in enumFromTo(1, n)]) for (i_, j_) in (m, j) |]
+    [| sum([a!(i_, k) * b!(k, j_) for k in range(0, n)]) for (i_, j_) in (m, j) |]

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

@@ -23,18 +23,18 @@ def compare(x, y):
     else: EQ
 
 # (b -> b -> c) -> (a -> b) -> a -> a -> c
-def on(binOp, prop, x, y):
-  binOp(prop(x), prop(y))
+def on(bin_op, prop, x, y):
+  bin_op(prop(x), prop(y))
 
 # Num -> Num
 def negate: (-)(0)
 
 # Log of x in base y.
 # Float -> Float -> Float
-def logBase(x, y): log(y) / log(x)
+def log_base(x, y): log(y) / log(x)
 
 # Float -> Float -> Float
-def ceilingToNearest(n, m): ceiling(n / m) * m
+def ceiling_to_nearest(n, m): ceiling(n / m) * m
 
 # (b -> c) -> (a -> b) -> a -> c
 # Want infix <<<
@@ -87,7 +87,7 @@ 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)
+  x == y or elem(x, xs)
 
 # (a -> Bool) -> List a -> Option a
 def find(p, []): None
@@ -96,16 +96,16 @@ def find(p, x :| xs):
   else: find(p, xs)
 
 # String -> String -> List Dict -> Option Dict
-def findWithKey(k, v, rs):
+def find_with_key(k, v, rs):
   find(lambda y: y[k] == v, rs)
 
 # Option a -> a
-def fromSome(None): error("Expected Some!")
-def fromSome(Some(x)): x
+def from_some(None): error("Expected Some!")
+def from_some(Some(x)): x
 
 # Option a -> a -> a
-def fromOption(None, y): y
-def fromOption(Some(x), _): x
+def from_option(None, y): y
+def from_option(Some(x), _): x
 
 # (a -> Bool) -> List a -> List a
 def filter(p, []): []
@@ -116,12 +116,12 @@ def filter(p, x :| xs):
   else: ys
 
 # (a -> Option b) -> List a -> List b
-def filterMap(p, []): []
-def filterMap(p, x :| xs):
+def filter_map(p, []): []
+def filter_map(p, x :| xs):
   match p(x):
-    case None: filterMap(f, xs)
+    case None: filter_map(f, xs)
     case Some(y):
-      y :| filterMap(f, xs)
+      y :| filter_map(f, xs)
 
 # Equivalent to but more efficient than length ∘ filter(p)
 def count_if(p):
@@ -142,10 +142,10 @@ def span(p, 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 group_by(eq, Nil): Nil
+def group_by(eq, x :| xs):
   def { init: ys, rest: zs }: span(eq(x), xs)
-  (x :| ys) :| groupBy(eq, zs)
+  (x :| ys) :| group_by(eq, zs)
 
 # (a -> b -> a) -> a -> List b -> a
 def foldl(op, z, []): z
@@ -192,10 +192,13 @@ def concat2(x :| xs, ys):
   x :| concat2(xs, ys)
 
 # List (List a) -> List a
-def concat: foldl(concat2, [])
+def concat: foldr(concat2, [])
 
 # (a -> List b) -> List a -> List b
-def concatMap(f, xs): concat(map(f, xs))
+def concat_map(f, xs): concat(map(f, xs))
+
+# List String -> String
+def join: foldr((++), "")
 
 # List a -> a -> List a
 def intersperse([], _): []
@@ -210,7 +213,7 @@ def iterate(n, f, z):
     z :| map(f, iterate(n - 1, f, z))
 
 # List Num -> Num
-def sum: foldl((+), 0)
+def sum: foldr((+), 0)
 
 # List Num -> Num
 def mean(xs):
@@ -251,7 +254,7 @@ def drop(n, xs):
       case _ :| xs: drop(n - 1, xs)
 
 # Int -> List a -> List a
-def lastN(n, xs):
+def last_n(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.
@@ -260,9 +263,9 @@ def nth(n, x :| xs):
   if n == 0: x
   else: nth(n - 1, xs)
 
-# Matrix Int -> Int -> Int -> Int
+# Int -> Int -> List (List Int) -> Int
 def nth2(i, j, xss):
-  nth(j - 1, nth(i - 1, xss))
+  nth(j, nth(i, xss))
 
 # Partial; requires k to be in the map.
 # Int -> List (Int, b) -> b
@@ -295,24 +298,22 @@ def unzip((x, y) :| 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)
+def zip_with(op, [], ys): []
+def zip_with(op, x :| xs, []): []
+def zip_with(op, x :| xs, y :| ys):
+  op(x, y) :| zip_with(op, xs, ys)
 
 # List a -> List b -> List (a, b)
-def zip: zipWith(curry(id))
+def zip: zip_with(curry(id))
 
-# Rename to 'range'
 # Int -> Int -> List Int
-def enumFromTo(n, m):
-  if n <= m: n :| [n + 1 .. m]
+def range(n, m):
+  if n < m: n :| range(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]]
+def range2d((m1, n1), (m2, n2)):
+  [(i1, i2) for i1 in range(m1, m2) for i2 in range(n1, n2)]
 
 # Int -> Int -> Int
 def abs(x, y):
@@ -335,7 +336,7 @@ def slice(begin, end, xs):
   take(end - begin, drop(begin, xs))
 
 # (a -> Boolean) -> List a -> (List a, List a)
-def splitOn(p, data):
+def split_on(p, data):
   def go(fls, trs, []):
     (reverse(fls), reverse(trs))
   def go(fls, trs, x :| xs):

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

@@ -17,7 +17,7 @@ def mergesort(xs):
     def (ys, zs): split(xs)
     merge(mergesort(ys), mergesort(zs))
 
-def findQuantile(q, p, xs):
+def find_quantile(q, p, xs):
   def rank:
     (p / q) * (length(xs) - 1)
 
@@ -30,49 +30,49 @@ def findQuantile(q, p, xs):
     def right: nth(x2, xs)
     left + (rank - x1) * (right - left)
 
-def findPercentile: findQuantile(100)
+def find_percentile: find_quantile(100)
 
-def accumBins(data, Nil): []
-def accumBins(data, [l]): []
-def accumBins(data, l :| r :| es):
+def accum_bins(data, Nil): []
+def accum_bins(data, [l]): []
+def accum_bins(data, l :| r :| es):
   def (ge, le):
-    splitOn(lambda x: x <= r, data)
-  (le, r - l) :| accumBins(ge, r :| es)
+    split_on(lambda x: x <= r, data)
+  (le, r - l) :| accum_bins(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 [0 .. nbins]]
 
-  accumBins(xs, edges)
+  accum_bins(xs, edges)
 
 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 :| [find_percentile(x, xs) for x in qs], [high]))
 
-  accumBins(xs, edges)
+  accum_bins(xs, edges)
 
-def likelihoodLE(xs, target):
+def likelihood_le(xs, target):
   length(filter(lambda x: x <= target, xs)) / length(xs)
 
-def likelihoodGE(xs, target):
+def likelihood_ge(xs, target):
   length(filter(lambda x: x >= target, xs)) / length(xs)
 
-def likelihoodMap(table, prob):
-  fromSome(find(lambda x: x.prob <= prob, table)).msg
+def likelihood_map(table, prob):
+  from_some(find(lambda x: x.prob <= prob, table)).msg
 
-def mkPercent(num):
-  numToStr(num * 100) ++ "%"
+def mk_percent(num):
+  num_to_str(num * 100) ++ "%"
 
-def leqP(n, m):
+def leq_p(n, m):
   if n <= m: "less"
   else: "more"
 
-def gradedLeqP(n, m):
+def graded_leq_p(n, m):
   def ratio: n / m
 
   if ratio <= 1.0: