@explorable-viz/fluid 0.12.2 → 0.12.4

package/website/article/static/fluid/lib/prelude.fld

@@ -0,0 +1,348 @@
+# "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, True): True
+def and(True, False): False
+
+# Bool -> Bool
+def or(True, y): True
+def or(False, True): True
+def or(False, False): False
+
+# 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
+
+# (b -> b -> c) -> (a -> b) -> a -> a -> c
+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 log_base(x, y): log(y) / log(x)
+
+# Float -> Float -> Float
+def ceiling_to_nearest(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, []): None
+def find(p, x :| xs):
+  if p(x): Some(x)
+  else: find(p, xs)
+
+# String -> String -> List Dict -> Option Dict
+def find_with_key(k, v, rs):
+  find(lambda y: y[k] == v, rs)
+
+# Option a -> a
+def from_some(None): error("Expected Some!")
+def from_some(Some(x)): x
+
+# Option a -> a -> a
+def from_option(None, y): y
+def from_option(Some(x), _): x
+
+# (a -> Bool) -> List a -> List a
+def filter(p, []): []
+def filter(p, x :| xs):
+  def ys: filter(p, xs)
+
+  if p(x): x :| ys
+  else: ys
+
+# (a -> Option b) -> List a -> List b
+def filter_map(p, []): []
+def filter_map(p, x :| xs):
+  match p(x):
+    case None: filter_map(f, xs)
+    case Some(y):
+      y :| filter_map(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 group_by(eq, Nil): Nil
+def group_by(eq, x :| xs):
+  def { init: ys, rest: zs }: span(eq(x), xs)
+  (x :| ys) :| group_by(eq, zs)
+
+# (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)
+    next :| continue(next)
+  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: foldr(concat2, [])
+
+# (a -> List b) -> List a -> List b
+def concat_map(f, xs): concat(map(f, xs))
+
+# List String -> String
+def join: foldr((++), "")
+
+# 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 Num -> Num
+def sum: foldr((+), 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
+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:
+    match xs:
+      case []: []
+      case x :| xs:
+        x :| take(n - 1, xs)
+
+# Int -> List a -> List a
+def drop(n, xs):
+  if n <= 0: xs
+  else:
+    match xs:
+      case []: []
+      case _ :| xs: drop(n - 1, xs)
+
+# Int -> List a -> List a
+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.
+# Int -> List a -> a
+def nth(n, x :| xs):
+  if n == 0: x
+  else: nth(n - 1, xs)
+
+# Int -> Int -> List (List Int) -> Int
+def nth2(i, j, xss):
+  nth(j, nth(i, 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 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: zip_with(curry(id))
+
+# Int -> Int -> List Int
+def range(n, m):
+  if n < m: n :| range(n + 1, m)
+  else: []
+
+# (Int, Int) -> (Int, Int) -> List (Int, Int)
+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):
+  if x - y < 0: negate(x - y)
+  else: x - y
+
+# Eq a => [a] -> [a]
+def nub(xs):
+  def nub_([], _): []
+  def nub_(x :| xs, ys):
+    if x |elem| ys:
+      nub_(xs, ys)
+    else:
+      x :| nub_(xs, x :| ys)
+
+  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 split_on(p, data):
+  def go(fls, trs, []):
+    (reverse(fls), reverse(trs))
+  def go(fls, trs, x :| xs):
+    if p(x):
+      go(fls, x :| trs, xs)
+    else:
+      go(x :| fls, trs, xs)
+
+  go([], [], data)

package/website/article/static/fluid/lib/stats.fld

@@ -0,0 +1,83 @@
+def split([]): ([], [])
+def split(x :| xs):
+  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_)
+
+def mergesort(xs):
+  if length(xs) < 2: xs
+  else:
+    def (ys, zs): split(xs)
+    merge(mergesort(ys), mergesort(zs))
+
+def find_quantile(q, p, xs):
+  def rank:
+    (p / q) * (length(xs) - 1)
+
+  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 find_percentile: find_quantile(100)
+
+def accum_bins(data, Nil): []
+def accum_bins(data, [l]): []
+def accum_bins(data, l :| r :| es):
+  def (ge, le):
+    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 [0 .. nbins]]
+
+  accum_bins(xs, edges)
+
+def qcut(xs, qs):
+  def (low, high):
+    (minimum(xs), maximum(xs))
+  def edges:
+    append((low :| [find_percentile(x, xs) for x in qs], [high]))
+
+  accum_bins(xs, edges)
+
+def likelihood_le(xs, target):
+  length(filter(lambda x: x <= target, xs)) / length(xs)
+
+def likelihood_ge(xs, target):
+  length(filter(lambda x: x >= target, xs)) / length(xs)
+
+def likelihood_map(table, prob):
+  from_some(find(lambda x: x.prob <= prob, table)).msg
+
+def mk_percent(num):
+  num_to_str(num * 100) ++ "%"
+
+def leq_p(n, m):
+  if n <= m: "less"
+  else: "more"
+
+def graded_leq_p(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"

package/website/article/svelte.config.js

@@ -0,0 +1,13 @@
+import adapter from '@sveltejs/adapter-static';
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+	preprocess: vitePreprocess(),
+
+	kit: {
+		adapter: adapter()
+	}
+};
+
+export default config;

package/website/article/test.mjs

@@ -1,14 +1,69 @@
-import { runTests, testURL, waitFor } from "./shared/webtest-lib.js"
+import {
+   checkAttribute, checkAttributeContains, checkComputedStyle, checkTextContent,
+   click, clickToggle, testURL, waitFor
+} from "../../script/webtest-lib.mjs"
 
 export const main = async () => {
-   await runTests(testURL("convolution")([ page => waitFor("svg#fig-output")(page) ]))()
-   const point = "div#fig .scatterplot-point"
-   await runTests(testURL("methane")([ page => waitFor("#fig svg:nth-of-type(1)")(page) ]))()
-   await runTests(testURL("moving-average")([ page => waitFor("svg")(page) ]))()
-   await runTests(testURL("non-renewables")([
-      page => waitFor("#fig-output > svg:nth-of-type(1)")(page),
-      page => waitFor("#fig-output > svg:nth-of-type(2)")(page),
-   ]))()
-   await runTests(testURL("renewables-linked")([page => waitFor("#fig-output > svg:nth-of-type(1)")(page)]))()
-   await runTests(testURL("scigen-1805.02474v1-10")([ page => waitFor("div#fig-output")(page) ]))()
+   await testURL("convolution", [
+      async page => await waitFor(page, "svg#fig-output")
+   ])
+
+   await testURL("energy-scatter", [
+      async page => {
+         await waitFor(page, "svg")
+         await clickToggle(page)
+
+         const point = "div#fig .scatterplot-point"
+         await waitFor(page, point)
+         await click(page, point)
+         await checkAttributeContains(page, point, "class", "selected-primary-persistent")
+         await checkAttribute(page, point, "r", "3.2")
+
+         const caption = "div#fig-input-renewables > div.table-caption"
+         await checkTextContent(page, caption, "renewables (40 of 240 × 5 of 5)")
+      }
+   ])
+
+   await testURL("methane", [
+      async page => await waitFor(page, "#fig svg:nth-of-type(1)")
+   ])
+
+   await testURL("moving-average", [
+      async page => await waitFor(page, "svg")
+   ])
+
+   await testURL("non-renewables", [
+      async page => await waitFor(page, "#fig-output > svg:nth-of-type(1)"),
+      async page => await waitFor(page, "#fig-output > svg:nth-of-type(2)"),
+   ])
+
+   await testURL("renewables-linked", [
+      async page => {
+         const barChart = "#fig-output > :nth-child(1)"
+         const lineChart = "#fig-output > :nth-child(2)"
+
+         await waitFor(page, barChart)
+         await waitFor(page, lineChart)
+         await waitFor(page, `${lineChart} g.x-axis`)
+
+         const point = `${lineChart} circle.linechart-point`
+         await waitFor(page, point)
+         await checkAttribute(page, point, "r", "2.0")
+
+         await clickToggle(page)
+
+         const bar = `${barChart} rect.bar`
+         await waitFor(page, bar)
+         await click(page, bar)
+         await checkAttribute(page, bar, "fill", "#57a157")
+
+         const selectedCell = "#fig-input .table-cell.selected-primary-persistent"
+         await waitFor(page, selectedCell)
+         await checkComputedStyle(page, selectedCell, "backgroundColor", "rgb(147, 233, 190)")
+      }
+   ])
+
+   await testURL("scigen-1805.02474v1-10", [
+      async page => await waitFor(page, "div#fig-output")
+   ])
 }

package/website/article/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"extends": "./.svelte-kit/tsconfig.json",
+	"compilerOptions": {
+		"rewriteRelativeImportExtensions": true,
+		"allowJs": true,
+		"checkJs": false, // Purescript output doesn't have types
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
+		"sourceMap": true,
+		"strict": true,
+		"moduleResolution": "bundler"
+	}
+	// Path aliases are handled by https://svelte.dev/docs/kit/configuration#alias
+	// except $lib which is handled by https://svelte.dev/docs/kit/configuration#files
+	//
+	// To make changes to top-level options such as include and exclude, we recommend extending
+	// the generated config; see https://svelte.dev/docs/kit/configuration#typescript
+}

package/website/article/vite.config.ts

@@ -0,0 +1,6 @@
+import { sveltekit } from '@sveltejs/kit/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+	plugins: [sveltekit()]
+});

package/.spago/aff/v7.1.0/.editorconfig

@@ -1,13 +0,0 @@
-# https://editorconfig.org
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false

package/.spago/aff/v7.1.0/.eslintrc.json

@@ -1,28 +0,0 @@
-{
-  "extends": "eslint:recommended",
-  "parserOptions": { "ecmaVersion": 6, "sourceType": "module" },
-  "rules": {
-    "block-scoped-var": "error",
-    "consistent-return": "error",
-    "eqeqeq": "error",
-    "guard-for-in": "error",
-    "no-bitwise": "error",
-    "no-caller": "error",
-    "no-constant-condition": ["error", { "checkLoops": false }],
-    "no-extra-parens": "off",
-    "no-extend-native": "error",
-    "no-new": "error",
-    "no-param-reassign": "error",
-    "no-return-assign": "error",
-    "no-sequences": "error",
-    "no-unused-expressions": "error",
-    "no-use-before-define": "error",
-    "no-undef": "error",
-    "no-eq-null": "error",
-    "radix": ["error", "always"],
-    "indent": ["error", 2, { "SwitchCase": 0 }],
-    "quotes": ["error", "double"],
-    "semi": ["error", "always"],
-    "strict": ["error", "global"]
-  }
-}

package/.spago/aff/v7.1.0/.gitignore

@@ -1,14 +0,0 @@
-.*
-!.gitignore
-!.github
-!.editorconfig
-!.tidyrc.json
-!.eslintrc.json
-
-output
-generated-docs
-bower_components
-
-node_modules
-package-lock.json
-*.lock

package/.spago/aff/v7.1.0/.tidyrc.json

@@ -1,10 +0,0 @@
-{
-  "importSort": "source",
-  "importWrap": "source",
-  "indent": 2,
-  "operatorsFile": null,
-  "ribbon": 1,
-  "typeArrowPlacement": "first",
-  "unicode": "never",
-  "width": null
-}

package/.spago/affjax/v13.0.0/.editorconfig

@@ -1,13 +0,0 @@
-# https://editorconfig.org
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = true
-insert_final_newline = true
-
-[*.md]
-trim_trailing_whitespace = false

package/.spago/affjax/v13.0.0/.eslintrc.json

@@ -1,28 +0,0 @@
-{
-  "extends": "eslint:recommended",
-  "parserOptions": { "ecmaVersion": 6, "sourceType": "module" },
-  "rules": {
-    "block-scoped-var": "error",
-    "consistent-return": "error",
-    "eqeqeq": "error",
-    "guard-for-in": "error",
-    "no-bitwise": "error",
-    "no-caller": "error",
-    "no-extra-parens": "off",
-    "no-extend-native": "error",
-    "no-loop-func": "error",
-    "no-new": "error",
-    "no-param-reassign": "error",
-    "no-return-assign": "error",
-    "no-sequences": "error",
-    "no-unused-expressions": "error",
-    "no-use-before-define": "error",
-    "no-undef": "error",
-    "no-eq-null": "error",
-    "radix": ["error", "always"],
-    "indent": ["error", 2, { "SwitchCase": 1 }],
-    "quotes": ["error", "double"],
-    "semi": ["error", "always"],
-    "strict": ["error", "global"]
-  }
-}

package/.spago/affjax/v13.0.0/.gitignore

@@ -1,14 +0,0 @@
-.*
-!.gitignore
-!.github
-!.editorconfig
-!.tidyrc.json
-!.eslintrc.json
-
-output
-generated-docs
-bower_components
-
-node_modules
-package-lock.json
-*.lock

package/.spago/affjax/v13.0.0/.tidyrc.json

@@ -1,10 +0,0 @@
-{
-  "importSort": "source",
-  "importWrap": "source",
-  "indent": 2,
-  "operatorsFile": null,
-  "ribbon": 1,
-  "typeArrowPlacement": "first",
-  "unicode": "never",
-  "width": null
-}