Add plot to documentation

Migrate to Applicative Functors
Add simple plot test
2022-10-11 17:32:59 +11:00 · 2022-10-11 17:05:37 +11:00 · 2022-10-11 12:53:16 +11:00 · 2022-10-11 12:38:15 +11:00 · 2022-10-10 17:40:48 +11:00 · 2022-10-10 17:37:21 +11:00
87 changed files with 1668 additions and 1409 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -35,8 +35,6 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 2
      - name: Setup Node.js environment
        uses: actions/setup-node@v2
        with:
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1 +0,0 @@
-See the [Changelog.mdx page](./packages/website/docs/Changelog.mdx) for the changelog.
--- a/README.md
+++ b/README.md
@ -65,12 +65,6 @@ turbo run build --filter=@quri/squiggle-components

 You can also run specific npm scripts for the package you're working on. See `packages/*/README.md` for the details.

-# NixOS users
-
-This repository requires the use of bundled binaries from node_modules, which
-are not linked statically. The easiest way to get them working is to enable
-[nix-ld](https://github.com/Mic92/nix-ld).
-
 # Contributing

 See `CONTRIBUTING.md`.
--- a/nix/squiggle-lang.nix
+++ b/nix/squiggle-lang.nix
@ -30,6 +30,16 @@ rec {
          patchelf --replace-needed libstdc++.so.6 $THE_SO linux/ninja.exe && echo "- replaced needed for linux/ninja.exe"
        '';
      };
+      bisect_ppx = {
+        buildInputs = common.which;
+        postInstall = ''
+          echo "PATCHELF'ING BISECT_PPX EXECUTABLE"
+          THE_LD=$(patchelf --print-interpreter $(which mkdir))
+          patchelf --set-interpreter $THE_LD bin/linux/ppx
+          patchelf --set-interpreter $THE_LD bin/linux/bisect-ppx-report
+          cp bin/linux/ppx ppx
+        '';
+      };
      gentype = {
        postInstall = ''
          mv gentype.exe ELFLESS-gentype.exe
--- a/nixos.sh
+++ b/nixos.sh
@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+# This script is only relevant if you're rolling nixos.
+
+# Esy (a bisect_ppx dependency/build tool) is borked on nixos without using an FHS shell. https://github.com/esy/esy/issues/858
+# We need to patchelf rescript executables. https://github.com/NixOS/nixpkgs/issues/107375
+set -x
+
+fhsShellName="squiggle-fhs-development"
+fhsShellDotNix="{pkgs ? import <nixpkgs> {} }: (pkgs.buildFHSUserEnv { name = \"${fhsShellName}\"; targetPkgs = pkgs: [pkgs.yarn pkgs.glibc]; runScript = \"yarn\"; }).env"
+nix-shell - <<<"$fhsShellDotNix"
+
+theLd=$(patchelf --print-interpreter $(which mkdir))
+patchelf --set-interpreter $theLd ./node_modules/gentype/gentype.exe
+patchelf --set-interpreter $theLd ./node_modules/rescript/linux/*.exe
+patchelf --set-interpreter $theLd ./node_modules/bisect_ppx/ppx
+patchelf --set-interpreter $theLd ./node_modules/bisect_ppx/bisect-ppx-report
+theSo=$(find /nix/store/*$fhsShellName*/lib64 -name libstdc++.so.6 | head -n 1)
+patchelf --replace-needed libstdc++.so.6 $theSo ./node_modules/rescript/linux/ninja.exe
--- a/packages/cli/README.md
+++ b/packages/cli/README.md
@ -20,30 +20,3 @@ Runs compilation in the current directory and all of its subdirectories.
 ### `npx squiggle-cli-experimental watch`

 Watches `.squiggleU` files in the current directory (and subdirectories) and rebuilds them when they are saved. Note that this will _not_ rebuild files when their dependencies are changed, just when they are changed directly.
-
-## Further instructions
-
-The above requires having node, npm and npx. To install the first two, see [here](https://nodejs.org/en/), to install npx, run:
-
-```
-npm install -g npx
-```
-
-Alternatively, you can run the following without the need for npx:
-
-```
-npm install squiggle-cli-experimental
-node node_modules/squiggle-cli-experimental/index.js compile
-```
-
-or you can add a script to your `package.json`, like:
-
-```
- ...
- scripts: {
-  "compile": "squiggle-cli-experimental compile"
- }
- ...
-```
-
-This can be run with `npm run compile`. `npm` knows how to reach into the node_modules directly, so it's not necessary to specify that.
--- a/packages/cli/package.json
+++ b/packages/cli/package.json
@ -13,7 +13,7 @@
  },
  "license": "MIT",
  "dependencies": {
-    "chalk": "^5.1.0",
+    "chalk": "^5.0.1",
    "chokidar": "^3.5.3",
    "commander": "^9.4.1",
    "fs": "^0.0.1-security",
--- a/packages/components/package.json
+++ b/packages/components/package.json
@ -12,11 +12,11 @@
    "@react-hook/size": "^2.1.2",
    "@types/uuid": "^8.3.4",
    "clsx": "^1.2.1",
-    "framer-motion": "^7.5.3",
+    "framer-motion": "^7.5.1",
    "lodash": "^4.17.21",
    "react": "^18.1.0",
    "react-ace": "^10.1.0",
-    "react-hook-form": "^7.37.0",
+    "react-hook-form": "^7.36.1",
    "react-use": "^17.4.0",
    "react-vega": "^7.6.0",
    "uuid": "^9.0.0",
@ -41,7 +41,7 @@
    "@testing-library/user-event": "^14.4.3",
    "@types/jest": "^27.5.0",
    "@types/lodash": "^4.14.186",
-    "@types/node": "^18.8.3",
+    "@types/node": "^18.8.0",
    "@types/react": "^18.0.21",
    "@types/styled-components": "^5.1.26",
    "@types/uuid": "^8.3.4",
@ -49,8 +49,8 @@
    "canvas": "^2.10.1",
    "cross-env": "^7.0.3",
    "jest": "^29.0.3",
-    "jest-environment-jsdom": "^29.1.2",
-    "jsdom": "^20.0.1",
+    "jest-environment-jsdom": "^29.0.3",
+    "jsdom": "^20.0.0",
    "mini-css-extract-plugin": "^2.6.1",
    "postcss-cli": "^10.0.0",
    "postcss-import": "^15.0.0",
@ -60,11 +60,11 @@
    "react-scripts": "^5.0.1",
    "style-loader": "^3.3.1",
    "tailwindcss": "^3.1.8",
-    "ts-jest": "^29.0.3",
+    "ts-jest": "^29.0.2",
    "ts-loader": "^9.4.1",
    "tsconfig-paths-webpack-plugin": "^4.0.0",
    "typescript": "^4.8.4",
-    "web-vitals": "^3.0.3",
+    "web-vitals": "^3.0.2",
    "webpack": "^5.74.0",
    "webpack-cli": "^4.10.0",
    "webpack-dev-server": "^4.11.1"
--- a/packages/components/src/components/Alert.tsx
+++ b/packages/components/src/components/Alert.tsx
@ -24,7 +24,7 @@ export const Alert: React.FC<{
  children,
 }) => {
  return (
-    <div className={clsx("rounded-md p-4", backgroundColor)} role="status">
+    <div className={clsx("rounded-md p-4", backgroundColor)}>
      <div className="flex">
        <Icon
          className={clsx("h-5 w-5 flex-shrink-0", iconColor)}
--- a/packages/components/src/components/CodeEditor.tsx
+++ b/packages/components/src/components/CodeEditor.tsx
@ -55,7 +55,10 @@ export const CodeEditor: FC<CodeEditorProps> = ({
      editorProps={{
        $blockScrolling: true,
      }}
-      setOptions={{}}
+      setOptions={{
+        enableBasicAutocompletion: false,
+        enableLiveAutocompletion: false,
+      }}
      commands={[
        {
          name: "submit",
--- a/packages/components/src/components/DistributionChart.tsx
+++ b/packages/components/src/components/DistributionChart.tsx
@ -3,8 +3,9 @@ import {
  SqDistribution,
  result,
  SqDistributionError,
+  LabeledDistribution,
  resultMap,
-  SqRecord,
+  SqPlot,
  environment,
  SqDistributionTag,
 } from "@quri/squiggle-lang";
@ -17,7 +18,6 @@ import {
  DistributionChartSpecOptions,
 } from "../lib/distributionSpecBuilder";
 import { NumberShower } from "./NumberShower";
-import { Plot, parsePlot } from "../lib/plotParser";
 import { flattenResult } from "../lib/utility";
 import { hasMassBelowZero } from "../lib/distributionUtils";

@ -28,27 +28,15 @@ export type DistributionPlottingSettings = {
 } & DistributionChartSpecOptions;

 export type DistributionChartProps = {
-  plot: Plot;
  environment: environment;
  width?: number;
  height: number;
  xAxisType?: "number" | "dateTime";
-} & DistributionPlottingSettings;
-
-export function defaultPlot(distribution: SqDistribution): Plot {
-  return { distributions: [{ name: "default", distribution }] };
-}
-
-export function makePlot(record: SqRecord): Plot | void {
-  const plotResult = parsePlot(record);
-  if (plotResult.tag === "Ok") {
-    return plotResult.value;
-  }
-}
+} & DistributionPlottingSettings &
+  ({ plot: SqPlot } | { distribution: SqDistribution });

 export const DistributionChart: React.FC<DistributionChartProps> = (props) => {
  const {
-    plot,
    environment,
    height,
    showSummary,
@ -57,8 +45,14 @@ export const DistributionChart: React.FC<DistributionChartProps> = (props) => {
    actions = false,
  } = props;
  const [sized] = useSize((size) => {
-    const shapes = flattenResult(
-      plot.distributions.map((x) =>
+    let distributions: LabeledDistribution[];
+    if ("plot" in props) {
+      distributions = props.plot.getDistributions();
+    } else {
+      distributions = [{ name: "default", distribution: props.distribution }];
+    }
+    let shapes = flattenResult(
+      distributions.map((x) =>
        resultMap(x.distribution.pointSet(environment), (pointSet) => ({
          name: x.name,
          // color: x.color, // not supported yet
@ -77,7 +71,7 @@ export const DistributionChart: React.FC<DistributionChartProps> = (props) => {

    // if this is a sample set, include the samples
    const samples: number[] = [];
-    for (const { distribution } of plot?.distributions) {
+    for (const { distribution } of distributions) {
      if (distribution.tag === SqDistributionTag.SampleSet) {
        samples.push(...distribution.value());
      }
@ -126,9 +120,9 @@ export const DistributionChart: React.FC<DistributionChartProps> = (props) => {
          />
        )}
        <div className="flex justify-center">
-          {showSummary && plot.distributions.length === 1 && (
+          {showSummary && distributions.length === 1 && (
            <SummaryTable
-              distribution={plot.distributions[0].distribution}
+              distribution={distributions[0].distribution}
              environment={environment}
            />
          )}
--- a/packages/components/src/components/FunctionChart1Dist.tsx
+++ b/packages/components/src/components/FunctionChart1Dist.tsx
@ -15,7 +15,6 @@ import * as percentilesSpec from "../vega-specs/spec-percentiles.json";
 import {
  DistributionChart,
  DistributionPlottingSettings,
-  defaultPlot,
 } from "./DistributionChart";
 import { NumberShower } from "./NumberShower";
 import { ErrorAlert } from "./Alert";
@ -184,7 +183,7 @@ export const FunctionChart1Dist: React.FC<FunctionChart1DistProps> = ({
    mouseItem.tag === "Ok" &&
    mouseItem.value.tag === SqValueTag.Distribution ? (
      <DistributionChart
-        plot={defaultPlot(mouseItem.value.value)}
+        distribution={mouseItem.value.value}
        environment={environment}
        width={400}
        height={50}
@ -194,7 +193,7 @@ export const FunctionChart1Dist: React.FC<FunctionChart1DistProps> = ({

  let getPercentilesMemoized = React.useMemo(
    () => getPercentiles({ chartSettings, fn, environment }),
-    [environment, fn]
+    [chartSettings, environment, fn]
  );

  return (
--- a/packages/components/src/components/SquiggleChart.tsx
+++ b/packages/components/src/components/SquiggleChart.tsx
@ -1,10 +1,5 @@
 import * as React from "react";
-import {
-  SqValue,
-  environment,
-  SqProject,
-  defaultEnvironment,
-} from "@quri/squiggle-lang";
+import { SqValue, environment, SqProject } from "@quri/squiggle-lang";
 import { useSquiggle } from "../lib/hooks";
 import { SquiggleViewer } from "./SquiggleViewer";
 import { JsImports } from "../lib/jsImports";
@ -71,6 +66,7 @@ type ProjectExecutionProps = {
 };
 const defaultOnChange = () => {};
 const defaultImports: JsImports = {};
+const defaultContinues: string[] = [];

 export const splitSquiggleChartSettings = (props: SquiggleChartProps) => {
  const {
@ -124,15 +120,24 @@ export const SquiggleChart: React.FC<SquiggleChartProps> = React.memo(
      width,
      height = 200,
      enableLocalSettings = false,
-      continues,
-      project,
-      environment,
+      continues = defaultContinues,
    } = props;

+    const p = React.useMemo(() => {
+      if (props.project) {
+        return props.project;
+      } else {
+        const p = SqProject.create();
+        if (props.environment) {
+          p.setEnvironment(props.environment);
+        }
+        return p;
+      }
+    }, [props.project, props.environment]);
+
    const resultAndBindings = useSquiggle({
-      environment,
      continues,
-      project,
+      project: p,
      code,
      jsImports,
      onChange,
@ -148,9 +153,7 @@ export const SquiggleChart: React.FC<SquiggleChartProps> = React.memo(
        height={height}
        distributionPlotSettings={distributionPlotSettings}
        chartSettings={chartSettings}
-        environment={
-          project ? project.getEnvironment() : environment ?? defaultEnvironment
-        }
+        environment={p.getEnvironment()}
        enableLocalSettings={enableLocalSettings}
      />
    );
--- a/packages/components/src/components/SquiggleEditor.tsx
+++ b/packages/components/src/components/SquiggleEditor.tsx
@ -16,7 +16,7 @@ const WrappedCodeEditor: React.FC<{
  setCode: (code: string) => void;
  errorLocations?: SqLocation[];
 }> = ({ code, setCode, errorLocations }) => (
-  <div className="border border-grey-200 p-2 m-4" data-testid="squiggle-editor">
+  <div className="border border-grey-200 p-2 m-4">
    <CodeEditor
      value={code}
      onChange={setCode}
@ -54,13 +54,17 @@ export const SquiggleEditor: React.FC<SquiggleEditorProps> = (props) => {
    width,
    height = 200,
    enableLocalSettings = false,
-    continues,
-    project,
  } = props;

+  const project = React.useMemo(() => {
+    const p = SqProject.create();
+    if (environment) {
+      p.setEnvironment(environment);
+    }
+    return p;
+  }, [environment]);
+
  const resultAndBindings = useSquiggle({
-    environment,
-    continues,
    code,
    project,
    jsImports,
--- a/packages/components/src/components/SquigglePlayground.tsx
+++ b/packages/components/src/components/SquigglePlayground.tsx
@ -182,7 +182,7 @@ const RunControls: React.FC<{
  const CurrentPlayIcon = isRunning ? RefreshIcon : PlayIcon;

  return (
-    <div className="flex space-x-1 items-center" data-testid="autorun-controls">
+    <div className="flex space-x-1 items-center">
      {autorunMode ? null : (
        <button onClick={run}>
          <CurrentPlayIcon
@ -251,8 +251,6 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
  onSettingsChange,
  showEditor = true,
  showShareButton = false,
-  continues,
-  project,
 }) => {
  const [code, setCode] = useMaybeControlledValue({
    value: controlledCode,
@ -307,10 +305,16 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
    executionId,
  } = useRunnerState(code);

+  const project = React.useMemo(() => {
+    const p = SqProject.create();
+    if (environment) {
+      p.setEnvironment(environment);
+    }
+    return p;
+  }, [environment]);
+
  const resultAndBindings = useSquiggle({
-    environment,
-    continues,
-    code: renderedCode,
+    code,
    project,
    jsImports: imports,
    executionId,
@ -351,7 +355,7 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
  const errorLocations = getErrorLocations(resultAndBindings.result);

  const firstTab = vars.showEditor ? (
-    <div className="border border-slate-200" data-testid="squiggle-editor">
+    <div className="border border-slate-200">
      <CodeEditor
        errorLocations={errorLocations}
        value={code}
@ -403,9 +407,7 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
      >
        {tabs}
      </div>
-      <div className="w-1/2 p-2 pl-4" data-testid="playground-result">
-        {squiggleChart}
-      </div>
+      <div className="w-1/2 p-2 pl-4">{squiggleChart}</div>
    </div>
  );

--- a/packages/components/src/components/SquiggleViewer/ExpressionViewer.tsx
+++ b/packages/components/src/components/SquiggleViewer/ExpressionViewer.tsx
@ -1,7 +1,7 @@
 import React, { useContext } from "react";
 import { SqDistributionTag, SqValue, SqValueTag } from "@quri/squiggle-lang";
 import { NumberShower } from "../NumberShower";
-import { DistributionChart, defaultPlot, makePlot } from "../DistributionChart";
+import { DistributionChart } from "../DistributionChart";
 import { FunctionChart } from "../FunctionChart";
 import clsx from "clsx";
 import { VariableBox } from "./VariableBox";
@ -104,7 +104,7 @@ export const ExpressionViewer: React.FC<Props> = ({ value, width }) => {
          {(settings) => {
            return (
              <DistributionChart
-                plot={defaultPlot(value.value)}
+                distribution={value.value}
                environment={settings.environment}
                {...settings.distributionPlotSettings}
                height={settings.height}
@ -219,15 +219,14 @@ export const ExpressionViewer: React.FC<Props> = ({ value, width }) => {
        </VariableBox>
      );
    }
-    case SqValueTag.Record:
-      const plot = makePlot(value.value);
-      if (plot) {
+    case SqValueTag.Plot:
+      const plot = value.value;
      return (
        <VariableBox
          value={value}
          heading="Plot"
          renderSettingsMenu={({ onChange }) => {
-              let disableLogX = plot.distributions.some((x) => {
+            let disableLogX = plot.getDistributions().some((x) => {
              let pointSet = x.distribution.pointSet(
                getMergedSettings(value.location).environment
              );
@ -259,7 +258,7 @@ export const ExpressionViewer: React.FC<Props> = ({ value, width }) => {
          }}
        </VariableBox>
      );
-      } else {
+    case SqValueTag.Record:
      return (
        <VariableList value={value} heading="Record">
          {(_) =>
@ -275,7 +274,6 @@ export const ExpressionViewer: React.FC<Props> = ({ value, width }) => {
          }
        </VariableList>
      );
-      }
    case SqValueTag.Array:
      return (
        <VariableList value={value} heading="Array">
--- a/packages/components/src/components/SquiggleViewer/VariableBox.tsx
+++ b/packages/components/src/components/SquiggleViewer/VariableBox.tsx
@ -45,7 +45,7 @@ export const VariableBox: React.FC<VariableBoxProps> = ({
    : location.path.items[location.path.items.length - 1];

  return (
-    <div role={isTopLevel ? "status" : undefined}>
+    <div>
      <header className="inline-flex space-x-1">
        <Tooltip text={heading}>
          <span
--- a/packages/components/src/lib/hooks/useSquiggle.ts
+++ b/packages/components/src/lib/hooks/useSquiggle.ts
@ -4,18 +4,16 @@ import {
  SqProject,
  SqRecord,
  SqValue,
-  environment,
 } from "@quri/squiggle-lang";
 import { useEffect, useMemo } from "react";
 import { JsImports, jsImportsToSquiggleCode } from "../jsImports";
 import * as uuid from "uuid";

 type SquiggleArgs = {
-  environment?: environment;
  code: string;
  executionId?: number;
  jsImports?: JsImports;
-  project?: SqProject;
+  project: SqProject;
  continues?: string[];
  onChange?: (expr: SqValue | undefined, sourceName: string) => void;
 };
@ -29,25 +27,15 @@ const importSourceName = (sourceName: string) => "imports-" + sourceName;
 const defaultContinues = [];

 export const useSquiggle = (args: SquiggleArgs): ResultAndBindings => {
-  const project = useMemo(() => {
-    if (args.project) {
-      return args.project;
-    } else {
-      const p = SqProject.create();
-      if (args.environment) {
-        p.setEnvironment(args.environment);
-      }
-      return p;
-    }
-  }, [args.project, args.environment]);
-
  const sourceName = useMemo(() => uuid.v4(), []);

-  const env = project.getEnvironment();
+  const env = args.project.getEnvironment();
  const continues = args.continues || defaultContinues;

  const result = useMemo(
    () => {
+      const project = args.project;
+
      project.setSource(sourceName, args.code);
      let fullContinues = continues;
      if (args.jsImports && Object.keys(args.jsImports).length) {
@ -71,7 +59,7 @@ export const useSquiggle = (args: SquiggleArgs): ResultAndBindings => {
      args.executionId,
      sourceName,
      continues,
-      project,
+      args.project,
      env,
    ]
  );
@ -87,11 +75,11 @@ export const useSquiggle = (args: SquiggleArgs): ResultAndBindings => {

  useEffect(() => {
    return () => {
-      project.removeSource(sourceName);
-      if (project.getSource(importSourceName(sourceName)))
-        project.removeSource(importSourceName(sourceName));
+      args.project.removeSource(sourceName);
+      if (args.project.getSource(importSourceName(sourceName)))
+        args.project.removeSource(importSourceName(sourceName));
    };
-  }, [project, sourceName]);
+  }, [args.project, sourceName]);

  return result;
 };
--- a/packages/components/src/lib/plotParser.ts
+++ b/packages/components/src/lib/plotParser.ts
@ -1,83 +0,0 @@
-import * as yup from "yup";
-import {
-  SqValue,
-  SqValueTag,
-  SqDistribution,
-  result,
-  SqRecord,
-} from "@quri/squiggle-lang";
-
-export type LabeledDistribution = {
-  name: string;
-  distribution: SqDistribution;
-  color?: string;
-};
-
-export type Plot = {
-  distributions: LabeledDistribution[];
-};
-
-function error<a, b>(err: b): result<a, b> {
-  return { tag: "Error", value: err };
-}
-
-function ok<a, b>(x: a): result<a, b> {
-  return { tag: "Ok", value: x };
-}
-
-const schema = yup
-  .object()
-  .noUnknown()
-  .strict()
-  .shape({
-    distributions: yup
-      .array()
-      .required()
-      .of(
-        yup.object().required().shape({
-          name: yup.string().required(),
-          distribution: yup.mixed().required(),
-        })
-      ),
-  });
-
-type JsonObject =
-  | string
-  | { [key: string]: JsonObject }
-  | JsonObject[]
-  | SqDistribution;
-
-function toJson(val: SqValue): JsonObject {
-  if (val.tag === SqValueTag.String) {
-    return val.value;
-  } else if (val.tag === SqValueTag.Record) {
-    return toJsonRecord(val.value);
-  } else if (val.tag === SqValueTag.Array) {
-    return val.value.getValues().map(toJson);
-  } else if (val.tag === SqValueTag.Distribution) {
-    return val.value;
-  } else {
-    throw new Error("Could not parse object of type " + val.tag);
-  }
-}
-
-function toJsonRecord(val: SqRecord): JsonObject {
-  let recordObject: JsonObject = {};
-  val.entries().forEach(([key, value]) => (recordObject[key] = toJson(value)));
-  return recordObject;
-}
-
-export function parsePlot(record: SqRecord): result<Plot, string> {
-  try {
-    const plotRecord = schema.validateSync(toJsonRecord(record));
-    if (plotRecord.distributions) {
-      return ok({ distributions: plotRecord.distributions.map((x) => x) });
-    } else {
-      // I have no idea why yup's typings thinks this is possible
-      return error("no distributions field. Should never get here");
-    }
-  } catch (e) {
-    const message = e instanceof Error ? e.message : "Unknown error";
-    return error(message);
-  }
-}
--- a/packages/components/test/autorun.test.tsx
+++ b/packages/components/test/autorun.test.tsx
@ -1,55 +0,0 @@
-import { render, screen, waitFor, within } from "@testing-library/react";
-import userEvent from "@testing-library/user-event";
-import * as React from "react";
-import "@testing-library/jest-dom";
-import { SquigglePlayground } from "../src/index";
-
-test("Autorun is default", async () => {
-  render(<SquigglePlayground code="70*30" />);
-  await waitFor(() =>
-    expect(screen.getByTestId("playground-result")).toHaveTextContent("2100")
-  );
-});
-
-test("Autorun can be switched off", async () => {
-  const user = userEvent.setup();
-  render(<SquigglePlayground code="70*30" />);
-
-  expect(screen.getByTestId("autorun-controls")).toHaveTextContent("Autorun");
-
-  await waitFor(() =>
-    expect(screen.getByTestId("playground-result")).toHaveTextContent("2100")
-  );
-
-  await user.click(screen.getByText("Autorun")); // disable
-  expect(screen.getByTestId("autorun-controls")).toHaveTextContent("Paused");
-  expect(screen.getByTestId("autorun-controls")).not.toHaveTextContent(
-    "Autorun"
-  );
-
-  await user.click(screen.getByText("Paused")); // enable autorun again
-  expect(screen.getByTestId("autorun-controls")).toHaveTextContent("Autorun");
-
-  // we should replace the code here, but it's hard to update react-ace state via user events: https://github.com/securingsincity/react-ace/issues/923
-  // ...or replace react-ace with something else
-
-  // TODO:
-
-  /*
-  const editor = screen
-    .getByTestId("squiggle-editor")
-    .querySelector(".ace_editor") as HTMLElement;
-  editor.focus();
-  //   await user.clear(editor);
-  await userEvent.paste("40*40"); // https://github.com/securingsincity/react-ace/issues/923#issuecomment-755502696
-  screen.debug(editor);
-
-  // this makes the tests slower, but it's hard to test otherwise that the code _didn't_ execute
-  await new Promise((r) => setTimeout(r, 300));
-  expect(screen.getByTestId("playground-result")).toHaveTextContent("2100"); // still the old value
-
-  await waitFor(() =>
-    expect(screen.getByTestId("playground-result")).toHaveTextContent("1600")
-  );
-*/
-});
--- a/packages/components/test/basic.test.tsx
+++ b/packages/components/test/basic.test.tsx
@ -1,14 +1,9 @@
-import { render, screen } from "@testing-library/react";
+import { render } from "@testing-library/react";
 import React from "react";
 import "@testing-library/jest-dom";
-import {
-  SquiggleChart,
-  SquiggleEditor,
-  SquigglePlayground,
-} from "../src/index";
-import { SqProject } from "@quri/squiggle-lang";
+import { SquiggleChart } from "../src/index";

-test("Chart logs nothing on render", async () => {
+test("Logs nothing on render", async () => {
  const { unmount } = render(<SquiggleChart code={"normal(0, 1)"} />);
  unmount();

@ -16,38 +11,3 @@ test("Chart logs nothing on render", async () => {
  expect(console.warn).not.toBeCalled();
  expect(console.error).not.toBeCalled();
 });
-
-test("Editor logs nothing on render", async () => {
-  const { unmount } = render(<SquiggleEditor code={"normal(0, 1)"} />);
-  unmount();
-
-  expect(console.log).not.toBeCalled();
-  expect(console.warn).not.toBeCalled();
-  expect(console.error).not.toBeCalled();
-});
-
-test("Project dependencies work in editors", async () => {
-  const project = SqProject.create();
-
-  render(<SquiggleEditor code={"x = 1"} project={project} />);
-  const source = project.getSourceIds()[0];
-  const { container } = render(
-    <SquiggleEditor code={"x + 1"} project={project} continues={[source]} />
-  );
-  expect(container).toHaveTextContent("2");
-});
-
-test("Project dependencies work in playgrounds", async () => {
-  const project = SqProject.create();
-  project.setSource("depend", "x = 1");
-
-  render(
-    <SquigglePlayground
-      code={"x + 1"}
-      project={project}
-      continues={["depend"]}
-    />
-  );
-  // We must await here because SquigglePlayground loads results asynchronously
-  expect(await screen.findByRole("status")).toHaveTextContent("2");
-});
--- a/packages/squiggle-lang/.prettierignore
+++ b/packages/squiggle-lang/.prettierignore
@ -3,7 +3,7 @@ lib
 *.bs.js
 *.gen.tsx
 .nyc_output/
-coverage/
+_coverage/
 .cache/
 Reducer_Peggy_GeneratedParser.js
 ReducerProject_IncludeParser.js
--- a/packages/squiggle-lang/tests/Distributions/Dotwise_test.res
+++ b/packages/squiggle-lang/tests/Distributions/Dotwise_test.res
@ -32,10 +32,7 @@ describe("dotSubtract", () => {
 */
  Skip.test("mean of normal minus exponential (property)", () => {
    assert_(
-      property2(
-        float_(),
-        floatRange(1e-5, 1e5),
-        (mean, rate) => {
+      property2(float_(), floatRange(1e-5, 1e5), (mean, rate) => {
        // We limit ourselves to stdev=1 so that the integral is trivial
        let dotDifference = DistributionOperation.Constructors.pointwiseSubtract(
          ~env,
@ -53,8 +50,7 @@ describe("dotSubtract", () => {
        | Ok(meanValue) => abs_float(meanValue -. meanAnalytical) /. abs_float(meanValue) < 1e-2 // 1% relative error
        | Error(err) => err === DistributionTypes.OperationError(DivisionByZeroError)
        }
-        },
-      ),
+      }),
    )
    pass
  })
--- a/packages/squiggle-lang/tests/Distributions/Invariants/AlgebraicCombination_test.res
+++ b/packages/squiggle-lang/tests/Distributions/Invariants/AlgebraicCombination_test.res
@ -40,9 +40,7 @@ let algebraicPower = algebraicPower(~env)

 describe("(Algebraic) addition of distributions", () => {
  describe("mean", () => {
-    test(
-      "normal(mean=5) + normal(mean=20)",
-      () => {
+    test("normal(mean=5) + normal(mean=20)", () => {
      normalDist5
      ->algebraicAdd(normalDist20)
      ->E.R2.fmap(DistributionTypes.Constructors.UsingDists.mean)
@ -51,12 +49,9 @@ describe("(Algebraic) addition of distributions", () => {
      ->E.R.toExn("Expected float", _)
      ->expect
      ->toBe(Some(2.5e1))
-      },
-    )
+    })

-    test(
-      "uniform(low=9, high=10) + beta(alpha=2, beta=5)",
-      () => {
+    test("uniform(low=9, high=10) + beta(alpha=2, beta=5)", () => {
      // let uniformMean = (9.0 +. 10.0) /. 2.0
      // let betaMean = 1.0 /. (1.0 +. 5.0 /. 2.0)
      let received =
@ -72,11 +67,8 @@ describe("(Algebraic) addition of distributions", () => {
      // sometimes it works with ~digits=2.
      | Some(x) => x->expect->toBeSoCloseTo(9.786831807237022, ~digits=1) // (uniformMean +. betaMean)
      }
-      },
-    )
-    test(
-      "beta(alpha=2, beta=5) + uniform(low=9, high=10)",
-      () => {
+    })
+    test("beta(alpha=2, beta=5) + uniform(low=9, high=10)", () => {
      // let uniformMean = (9.0 +. 10.0) /. 2.0
      // let betaMean = 1.0 /. (1.0 +. 5.0 /. 2.0)
      let received =
@ -92,8 +84,7 @@ describe("(Algebraic) addition of distributions", () => {
      // sometimes it works with ~digits=2.
      | Some(x) => x->expect->toBeSoCloseTo(9.784290207736126, ~digits=1) // (uniformMean +. betaMean)
      }
-      },
-    )
+    })
  })
  describe("pdf", () => {
    // TEST IS WRONG. SEE STDEV ADDITION EXPRESSION.
@ -131,9 +122,7 @@ describe("(Algebraic) addition of distributions", () => {
        }
      },
    )
-    test(
-      "(normal(mean=10) + normal(mean=10)).pdf(1.9e1)",
-      () => {
+    test("(normal(mean=10) + normal(mean=10)).pdf(1.9e1)", () => {
      let received =
        normalDist20
        ->Ok
@ -161,11 +150,8 @@ describe("(Algebraic) addition of distributions", () => {
        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=1)
        }
      }
-      },
-    )
-    test(
-      "(uniform(low=9, high=10) + beta(alpha=2, beta=5)).pdf(10)",
-      () => {
+    })
+    test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).pdf(10)", () => {
      let received =
        uniformDist
        ->algebraicAdd(betaDist)
@ -180,11 +166,8 @@ describe("(Algebraic) addition of distributions", () => {
      // This value was calculated by a python script
      | Some(x) => x->expect->toBeSoCloseTo(0.979023, ~digits=0)
      }
-      },
-    )
-    test(
-      "(beta(alpha=2, beta=5) + uniform(low=9, high=10)).pdf(10)",
-      () => {
+    })
+    test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).pdf(10)", () => {
      let received =
        betaDist
        ->algebraicAdd(uniformDist)
@ -197,14 +180,10 @@ describe("(Algebraic) addition of distributions", () => {
      // This is nondeterministic.
      | Some(x) => x->expect->toBeSoCloseTo(0.979023, ~digits=0)
      }
-      },
-    )
+    })
  })
  describe("cdf", () => {
-    testAll(
-      "(normal(mean=5) + normal(mean=5)).cdf (imprecise)",
-      list{6e0, 8e0, 1e1, 1.2e1},
-      x => {
+    testAll("(normal(mean=5) + normal(mean=5)).cdf (imprecise)", list{6e0, 8e0, 1e1, 1.2e1}, x => {
      let received =
        normalDist10
        ->Ok
@ -233,11 +212,8 @@ describe("(Algebraic) addition of distributions", () => {
        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=0)
        }
      }
-      },
-    )
-    test(
-      "(normal(mean=10) + normal(mean=10)).cdf(1.25e1)",
-      () => {
+    })
+    test("(normal(mean=10) + normal(mean=10)).cdf(1.25e1)", () => {
      let received =
        normalDist20
        ->Ok
@ -265,11 +241,8 @@ describe("(Algebraic) addition of distributions", () => {
        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=2)
        }
      }
-      },
-    )
-    test(
-      "(uniform(low=9, high=10) + beta(alpha=2, beta=5)).cdf(10)",
-      () => {
+    })
+    test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).cdf(10)", () => {
      let received =
        uniformDist
        ->algebraicAdd(betaDist)
@ -283,11 +256,8 @@ describe("(Algebraic) addition of distributions", () => {
      // The value was calculated externally using a python script
      | Some(x) => x->expect->toBeSoCloseTo(0.71148, ~digits=1)
      }
-      },
-    )
-    test(
-      "(beta(alpha=2, beta=5) + uniform(low=9, high=10)).cdf(10)",
-      () => {
+    })
+    test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).cdf(10)", () => {
      let received =
        betaDist
        ->algebraicAdd(uniformDist)
@ -301,15 +271,11 @@ describe("(Algebraic) addition of distributions", () => {
      // The value was calculated externally using a python script
      | Some(x) => x->expect->toBeSoCloseTo(0.71148, ~digits=1)
      }
-      },
-    )
+    })
  })

  describe("inv", () => {
-    testAll(
-      "(normal(mean=5) + normal(mean=5)).inv (imprecise)",
-      list{5e-2, 4.2e-3, 9e-3},
-      x => {
+    testAll("(normal(mean=5) + normal(mean=5)).inv (imprecise)", list{5e-2, 4.2e-3, 9e-3}, x => {
      let received =
        normalDist10
        ->Ok
@ -338,11 +304,8 @@ describe("(Algebraic) addition of distributions", () => {
        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=-1)
        }
      }
-      },
-    )
-    test(
-      "(normal(mean=10) + normal(mean=10)).inv(1e-1)",
-      () => {
+    })
+    test("(normal(mean=10) + normal(mean=10)).inv(1e-1)", () => {
      let received =
        normalDist20
        ->Ok
@ -370,11 +333,8 @@ describe("(Algebraic) addition of distributions", () => {
        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=-1)
        }
      }
-      },
-    )
-    test(
-      "(uniform(low=9, high=10) + beta(alpha=2, beta=5)).inv(2e-2)",
-      () => {
+    })
+    test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).inv(2e-2)", () => {
      let received =
        uniformDist
        ->algebraicAdd(betaDist)
@ -388,11 +348,8 @@ describe("(Algebraic) addition of distributions", () => {
      // sometimes it works with ~digits=2.
      | Some(x) => x->expect->toBeSoCloseTo(9.179319623146968, ~digits=0)
      }
-      },
-    )
-    test(
-      "(beta(alpha=2, beta=5) + uniform(low=9, high=10)).inv(2e-2)",
-      () => {
+    })
+    test("(beta(alpha=2, beta=5) + uniform(low=9, high=10)).inv(2e-2)", () => {
      let received =
        betaDist
        ->algebraicAdd(uniformDist)
@ -406,7 +363,6 @@ describe("(Algebraic) addition of distributions", () => {
      // sometimes it works with ~digits=2.
      | Some(x) => x->expect->toBeSoCloseTo(9.190872365862756, ~digits=0)
      }
-      },
-    )
+    })
  })
 })
--- a/packages/squiggle-lang/tests/Distributions/Invariants/Means_test.res
+++ b/packages/squiggle-lang/tests/Distributions/Invariants/Means_test.res
@ -87,22 +87,14 @@ describe("Means are invariant", () => {
    let testAddInvariant = (t1, t2) =>
      E.R.liftM2(testAdditionMean, t1, t2)->E.R.toExn("Means were not invariant", _)

-    testAll(
-      "with two of the same distribution",
-      distributions,
-      dist => {
+    testAll("with two of the same distribution", distributions, dist => {
      testAddInvariant(dist, dist)
-      },
-    )
+    })

-    testAll(
-      "with two different distributions",
-      pairsOfDifferentDistributions,
-      dists => {
+    testAll("with two different distributions", pairsOfDifferentDistributions, dists => {
      let (dist1, dist2) = dists
      testAddInvariant(dist1, dist2)
-      },
-    )
+    })

    testAll(
      "with two different distributions in swapped order",
@ -124,22 +116,14 @@ describe("Means are invariant", () => {
    let testSubtractInvariant = (t1, t2) =>
      E.R.liftM2(testSubtractionMean, t1, t2)->E.R.toExn("Means were not invariant", _)

-    testAll(
-      "with two of the same distribution",
-      distributions,
-      dist => {
+    testAll("with two of the same distribution", distributions, dist => {
      testSubtractInvariant(dist, dist)
-      },
-    )
+    })

-    testAll(
-      "with two different distributions",
-      pairsOfDifferentDistributions,
-      dists => {
+    testAll("with two different distributions", pairsOfDifferentDistributions, dists => {
      let (dist1, dist2) = dists
      testSubtractInvariant(dist1, dist2)
-      },
-    )
+    })

    testAll(
      "with two different distributions in swapped order",
@ -161,22 +145,14 @@ describe("Means are invariant", () => {
    let testMultiplicationInvariant = (t1, t2) =>
      E.R.liftM2(testMultiplicationMean, t1, t2)->E.R.toExn("Means were not invariant", _)

-    testAll(
-      "with two of the same distribution",
-      distributions,
-      dist => {
+    testAll("with two of the same distribution", distributions, dist => {
      testMultiplicationInvariant(dist, dist)
-      },
-    )
+    })

-    testAll(
-      "with two different distributions",
-      pairsOfDifferentDistributions,
-      dists => {
+    testAll("with two different distributions", pairsOfDifferentDistributions, dists => {
      let (dist1, dist2) = dists
      testMultiplicationInvariant(dist1, dist2)
-      },
-    )
+    })

    testAll(
      "with two different distributions in swapped order",
--- a/packages/squiggle-lang/tests/Distributions/Scoring/KlDivergence_test.res
+++ b/packages/squiggle-lang/tests/Distributions/Scoring/KlDivergence_test.res
@ -17,9 +17,10 @@ describe("klDivergence: continuous -> continuous -> float", () => {
      let answer =
        uniformMakeR(lowAnswer, highAnswer)->E.R2.errMap(s => DistributionTypes.ArgumentError(s))
      let prediction =
-        uniformMakeR(lowPrediction, highPrediction)->E.R2.errMap(
-          s => DistributionTypes.ArgumentError(s),
-        )
+        uniformMakeR(
+          lowPrediction,
+          highPrediction,
+        )->E.R2.errMap(s => DistributionTypes.ArgumentError(s))
      // integral along the support of the answer of answer.pdf(x) times log of prediction.pdf(x) divided by answer.pdf(x) dx
      let analyticalKl = Js.Math.log((highPrediction -. lowPrediction) /. (highAnswer -. lowAnswer))
      let kl = E.R.liftJoin2(klDivergence, prediction, answer)
@ -182,9 +183,9 @@ describe("combineAlongSupportOfSecondArgument0", () => {
    let answer =
      uniformMakeR(lowAnswer, highAnswer)->E.R2.errMap(s => DistributionTypes.ArgumentError(s))
    let prediction =
-      uniformMakeR(lowPrediction, highPrediction)->E.R2.errMap(
-        s => DistributionTypes.ArgumentError(s),
-      )
+      uniformMakeR(lowPrediction, highPrediction)->E.R2.errMap(s => DistributionTypes.ArgumentError(
+        s,
+      ))
    let answerWrapped = E.R.fmap(a => run(FromDist(#ToDist(ToPointSet), a)), answer)
    let predictionWrapped = E.R.fmap(a => run(FromDist(#ToDist(ToPointSet), a)), prediction)

--- a/packages/squiggle-lang/tests/Distributions/Symbolic_test.res
+++ b/packages/squiggle-lang/tests/Distributions/Symbolic_test.res
@ -3,7 +3,7 @@ open Expect
 open TestHelpers

 // TODO: use Normal.make (but preferably after teh new validation dispatch is in)
-let mkNormal = (mean, stdev) => DistributionTypes.Symbolic(#Normal({mean, stdev}))
+let mkNormal = (mean, stdev) => DistributionTypes.Symbolic(#Normal({mean: mean, stdev: stdev}))

 describe("(Symbolic) normalize", () => {
  testAll("has no impact on normal distributions", list{-1e8, -1e-2, 0.0, 1e-4, 1e16}, mean => {
@ -47,7 +47,10 @@ describe("(Symbolic) mean", () => {
    tup => {
      let (low, medium, high) = tup
      let meanValue = run(
-        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Triangular({low, medium, high}))),
+        FromDist(
+          #ToFloat(#Mean),
+          DistributionTypes.Symbolic(#Triangular({low: low, medium: medium, high: high})),
+        ),
      )
      meanValue->unpackFloat->expect->toBeCloseTo((low +. medium +. high) /. 3.0) // https://www.statology.org/triangular-distribution/
    },
@ -60,7 +63,7 @@ describe("(Symbolic) mean", () => {
    tup => {
      let (alpha, beta) = tup
      let meanValue = run(
-        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Beta({alpha, beta}))),
+        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Beta({alpha: alpha, beta: beta}))),
      )
      meanValue->unpackFloat->expect->toBeCloseTo(1.0 /. (1.0 +. beta /. alpha)) // https://en.wikipedia.org/wiki/Beta_distribution#Mean
    },
@ -81,8 +84,8 @@ describe("(Symbolic) mean", () => {
      let (mean, stdev) = tup
      let betaDistribution = SymbolicDist.Beta.fromMeanAndStdev(mean, stdev)
      let meanValue =
-        betaDistribution->E.R2.fmap(
-          d => run(FromDist(#ToFloat(#Mean), d->DistributionTypes.Symbolic)),
+        betaDistribution->E.R2.fmap(d =>
+          run(FromDist(#ToFloat(#Mean), d->DistributionTypes.Symbolic))
        )
      switch meanValue {
      | Ok(value) => value->unpackFloat->expect->toBeCloseTo(mean)
@ -97,7 +100,7 @@ describe("(Symbolic) mean", () => {
    tup => {
      let (mu, sigma) = tup
      let meanValue = run(
-        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Lognormal({mu, sigma}))),
+        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Lognormal({mu: mu, sigma: sigma}))),
      )
      meanValue->unpackFloat->expect->toBeCloseTo(Js.Math.exp(mu +. sigma ** 2.0 /. 2.0)) // https://brilliant.org/wiki/log-normal-distribution/
    },
@ -109,7 +112,7 @@ describe("(Symbolic) mean", () => {
    tup => {
      let (low, high) = tup
      let meanValue = run(
-        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Uniform({low, high}))),
+        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Uniform({low: low, high: high}))),
      )
      meanValue->unpackFloat->expect->toBeCloseTo((low +. high) /. 2.0) // https://en.wikipedia.org/wiki/Continuous_uniform_distribution#Moments
    },
--- a/packages/squiggle-lang/tests/Reducer/Reducer_Bindings/Reducer_Bindings_test.res
+++ b/packages/squiggle-lang/tests/Reducer/Reducer_Bindings/Reducer_Bindings_test.res
@ -33,18 +33,12 @@ describe("Bindings", () => {
    let value2 = Reducer_T.IEvNumber(5.)
    let extendedBindings = bindings->Bindings.extend->Bindings.set("value", value2)

-    test(
-      "get on extended",
-      () => {
+    test("get on extended", () => {
      expect(extendedBindings->Bindings.get("value")) == Some(value2)
-      },
-    )
+    })

-    test(
-      "get on original",
-      () => {
+    test("get on original", () => {
      expect(bindings->Bindings.get("value")) == Some(value)
-      },
-    )
+    })
  })
 })
--- a/packages/squiggle-lang/tests/Reducer/Reducer_Namespace_test.res
+++ b/packages/squiggle-lang/tests/Reducer/Reducer_Namespace_test.res
@ -40,23 +40,14 @@ describe("Namespace", () => {

    let nsMerged = Namespace.mergeMany([ns, ns1, ns2])

-    test(
-      "merge many 1",
-      () => {
+    test("merge many 1", () => {
      expect(nsMerged->Namespace.get("x1")) == Some(x1)
-      },
-    )
-    test(
-      "merge many 2",
-      () => {
+    })
+    test("merge many 2", () => {
      expect(nsMerged->Namespace.get("x4")) == Some(x4)
-      },
-    )
-    test(
-      "merge many 3",
-      () => {
+    })
+    test("merge many 3", () => {
      expect(nsMerged->Namespace.get("value")) == Some(value)
-      },
-    )
+    })
  })
 })
--- a/packages/squiggle-lang/tests/Reducer/Reducer_Peggy/Reducer_Peggy_ToExpression_test.res
+++ b/packages/squiggle-lang/tests/Reducer/Reducer_Peggy/Reducer_Peggy_ToExpression_test.res
@ -75,9 +75,7 @@ describe("Peggy to Expression", () => {
    testToExpression("false ? 1 : 0", "false ? (1) : (0)", ~v="0", ())
    testToExpression("true ? 1 : false ? 2 : 0", "true ? (1) : (false ? (2) : (0))", ~v="1", ()) // nested ternary
    testToExpression("false ? 1 : false ? 2 : 0", "false ? (1) : (false ? (2) : (0))", ~v="0", ()) // nested ternary
-    describe(
-      "ternary bindings",
-      () => {
+    describe("ternary bindings", () => {
      testToExpression(
        // expression binding
        "f(a) = a > 5 ? 1 : 0; f(6)",
@ -99,8 +97,7 @@ describe("Peggy to Expression", () => {
        ~v="6",
        (),
      )
-      },
-    )
+    })
  })

  describe("if then else", () => {
--- a/packages/squiggle-lang/tests/Reducer/Reducer_TestHelpers.res
+++ b/packages/squiggle-lang/tests/Reducer/Reducer_TestHelpers.res
@ -22,7 +22,7 @@ let expectEvalError = (code: string) =>
  Expression.BackCompatible.evaluateString(code)
  ->Reducer_Value.toStringResult
  ->expect
-  ->toMatch("Error\\(")
+  ->toMatch("Error\(")

 let testParseToBe = (expr, answer) => test(expr, () => expectParseToBe(expr, answer))
 let testDescriptionParseToBe = (desc, expr, answer) =>
--- a/packages/squiggle-lang/tests/Reducer/Reducer_test.res
+++ b/packages/squiggle-lang/tests/Reducer/Reducer_test.res
@ -37,16 +37,14 @@ describe("eval", () => {
    test("index", () => expectEvalToBe("r = {a: 1}; r.a", "Ok(1)"))
    test("index", () => expectEvalToBe("r = {a: 1}; r.b", "Error(Record property not found: b)"))
    testEvalError("{a: 1}.b") // invalid syntax
-    test(
-      "always the same property ending",
-      () =>
+    test("always the same property ending", () =>
      expectEvalToBe(
        `{
      a: 1, 
      b: 2,
    }`,
        "Ok({a: 1,b: 2})",
-        ),
+      )
    )
  })

@ -101,7 +99,7 @@ describe("stacktraces", () => {

    expect(
      error,
-    )->toBe(`Error: There are function matches for add(), but with different arguments: [add(number, number)]; [add(distribution, number)]; [add(number, distribution)]; [add(distribution, distribution)]; [add(date, duration)]; [add(duration, duration)]
+    )->toBe(`Error: There are function matches for add(), but with different arguments: [add(number, number)]; [add(date, duration)]; [add(duration, duration)]; [add(distribution, number)]; [add(number, distribution)]; [add(distribution, distribution)]
 Stack trace:
  f at line 4, column 5
  g at line 6, column 12
--- a/packages/squiggle-lang/tests/ReducerProject/ReducerProject_tutorial_1_test.res
+++ b/packages/squiggle-lang/tests/ReducerProject/ReducerProject_tutorial_1_test.res
@ -11,9 +11,7 @@ describe("ReducerProject Tutorial", () => {
    /*
 Case "Running a single source". 
 */
-    test(
-      "run",
-      () => {
+    test("run", () => {
      /* Let's start with running a single source and getting Result as well as the Bindings 
       First you need to create a project. A project is a collection of sources. 
       Project takes care of the dependencies between the sources, correct compilation and run order. 
@ -53,12 +51,9 @@ Case "Running a single source".
      (result->Reducer_Value.toStringResult, bindings->Reducer_Value.toStringRecord)->expect ==
        ("Ok(3)", "{}")
      /* You've got 3 with empty bindings. */
-      },
-    )
+    })

-    test(
-      "run summary",
-      () => {
+    test("run summary", () => {
      let project = Project.createProject()
      project->Project.setSource("main", "1 + 2")
      project->Project.runAll
@ -69,12 +64,9 @@ Case "Running a single source".
        result->Reducer_Value.toStringResult,
        bindings->Reducer_T.IEvRecord->Reducer_Value.toString,
      )->expect == ("Ok(3)", "{}")
-      },
-    )
+    })

-    test(
-      "run with an environment",
-      () => {
+    test("run with an environment", () => {
      /* Running the source code like above allows you to set a custom environment */
      let project = Project.createProject()

@ -86,19 +78,15 @@ Case "Running a single source".
      let result = project->Project.getResult("main")
      let _bindings = project->Project.getBindings("main")
      result->Reducer_Value.toStringResult->expect == "Ok(3)"
-      },
-    )
+    })

-    test(
-      "shortcut",
-      () => {
+    test("shortcut", () => {
      /* If you are running single source without includes and you don't need a custom environment, you can use the shortcut. */
      /* Examples above was to prepare you for the multi source tutorial. */
      let (result, bindings) = Project.evaluate("1+2")
      (result->Reducer_Value.toStringResult, bindings->Reducer_Value.toStringRecord)->expect ==
        ("Ok(3)", "{}")
-      },
-    )
+    })
  })
 })

--- a/packages/squiggle-lang/tests/ReducerProject/ReducerProject_tutorial_2_multisource_test.res
+++ b/packages/squiggle-lang/tests/ReducerProject/ReducerProject_tutorial_2_multisource_test.res
@ -10,9 +10,7 @@ describe("ReducerProject Tutorial", () => {
  describe("Multi source", () => {
    /*
     Case "Running multiple sources" */
-    test(
-      "Chaining",
-      () => {
+    test("Chaining", () => {
      let project = Project.createProject()
      /* This time let's add 3 sources and chain them together */
      project->Project.setSource("source1", "x=1")
@ -34,12 +32,9 @@ describe("ReducerProject Tutorial", () => {

      (result3->Reducer_Value.toStringResult, bindings3->Reducer_Value.toStringRecord)->expect ==
        ("Ok(())", "{z: 3}")
-      },
-    )
+    })

-    test(
-      "Depending",
-      () => {
+    test("Depending", () => {
      /* Instead of chaining the sources, we could have a dependency tree */
      /* The point here is that any source can depend on multiple sources */
      let project = Project.createProject()
@ -61,12 +56,9 @@ describe("ReducerProject Tutorial", () => {

      (result3->Reducer_Value.toStringResult, bindings3->Reducer_Value.toStringRecord)->expect ==
        ("Ok(())", "{z: 3}")
-      },
-    )
+    })

-    test(
-      "Intro to including",
-      () => {
+    test("Intro to including", () => {
      /* Though it would not be practical for a storybook, 
        let's write the same project above with includes.
        You will see that parsing includes is setting the dependencies the same way as before. */
@ -107,7 +99,6 @@ describe("ReducerProject Tutorial", () => {
         - And the depended source1 and source2 is not already there in the project
         - If you knew the includes before hand there would not be point of the include directive.
         More on those on the next section. */
-      },
-    )
+    })
  })
 })
--- a/packages/squiggle-lang/tests/ReducerProject/ReducerProject_tutorial_3_includes_test.res
+++ b/packages/squiggle-lang/tests/ReducerProject/ReducerProject_tutorial_3_includes_test.res
@ -24,20 +24,15 @@ Here we will finally proceed to a real life scenario. */
    )
    /* We need to parse includes after changing the source */
    project->Project.parseIncludes("main")
-    test(
-      "getDependencies",
-      () => {
+    test("getDependencies", () => {
      /* Parse includes has set the dependencies */
      project->Project.getDependencies("main")->expect == ["common"]
      /* If there were no includes than there would be no dependencies */
      /* However if there was a syntax error at includes then would be no dependencies also */
      /* Therefore looking at dependencies is not the right way to load includes */
      /* getDependencies does not distinguish between setContinues or parseIncludes */
-      },
-    )
-    test(
-      "getIncludes",
-      () => {
+    })
+    test("getIncludes", () => {
      /* Parse includes has set the includes */
      switch project->Project.getIncludes("main") {
      | Ok(includes) => includes->expect == ["common"]
@ -47,23 +42,17 @@ Here we will finally proceed to a real life scenario. */
      Otherwise you get the includes.
      If there is no syntax error then you can load that file and use setSource to add it to the project.
      And so on recursively... */
-      },
-    )
-    test(
-      "getDependents",
-      () => {
+    })
+    test("getDependents", () => {
      /* For any reason, you are able to query what other sources
        include or depend on the current source.
        But you don't need to use this to execute the projects.
        It is provided for completeness of information. */
      project->Project.getDependents("main")->expect == []
      /* Nothing is depending on or including main */
-      },
-    )
+    })

-    describe(
-      "Real Like",
-      () => {
+    describe("Real Like", () => {
      /* Now let's look at recursive and possibly cyclic includes */
      /* There is no function provided to load the include files.
    Because we have no idea if will it be an ordinary function or will it use promises.
@ -99,8 +88,7 @@ Here we will finally proceed to a real life scenario. */
          | Error(err) => err->SqError.toString->Js.Exn.raiseError

          | Ok(includes) =>
-              includes->Belt.Array.forEach(
-                newIncludeName => {
+            includes->Belt.Array.forEach(newIncludeName => {
              /* We have got one of the new includes.
               Let's load it and add it to the project */
              let newSource = loadSource(newIncludeName)
@ -109,8 +97,7 @@ Here we will finally proceed to a real life scenario. */
              /* Of course the new source might have includes too. */
              /* Let's recursively load them */
              project->loadIncludesRecursively(newIncludeName, newVisited)
-                },
-              )
+            })
          }
        }
      }
@ -156,18 +143,12 @@ Here we will finally proceed to a real life scenario. */
      let result = project->Project.getResult("main")
      let bindings = project->Project.getBindings("main")
      /* And see the result and bindings.. */
-        test(
-          "recursive includes",
-          () => {
-            (
-              result->Reducer_Value.toStringResult,
-              bindings->Reducer_Value.toStringRecord,
-            )->expect == ("Ok(6)", "{a: 6,b: 2}")
+      test("recursive includes", () => {
+        (result->Reducer_Value.toStringResult, bindings->Reducer_Value.toStringRecord)->expect ==
+          ("Ok(6)", "{a: 6,b: 2}")
        /* Everything as expected */
-          },
-        )
-      },
-    )
+      })
+    })
  })

  describe("Includes myFile as myVariable", () => {
@ -182,20 +163,14 @@ Here we will finally proceed to a real life scenario. */
    `,
    )
    Project.parseIncludes(project, "main")
-    test(
-      "getDependencies",
-      () => {
+    test("getDependencies", () => {
      Project.getDependencies(project, "main")->expect == ["common"]
-      },
-    )
-    test(
-      "getIncludes",
-      () => {
+    })
+    test("getIncludes", () => {
      switch Project.getIncludes(project, "main") {
      | Ok(includes) => includes->expect == ["common"]
      | Error(err) => err->SqError.toString->fail
      }
-      },
-    )
+    })
  })
 })
--- a/packages/squiggle-lang/tests/ReducerProject/ReducerProject_tutorial_5_calling_functions.res
+++ b/packages/squiggle-lang/tests/ReducerProject/ReducerProject_tutorial_5_calling_functions.res
@ -30,9 +30,8 @@ describe("ReducerProject Tutorial", () => {
  })

  test("userResults", () => {
-    let userResultsAsString = Belt.Array.map(
-      userResults,
-      aResult => aResult->Reducer_Value.toStringResult,
+    let userResultsAsString = Belt.Array.map(userResults, aResult =>
+      aResult->Reducer_Value.toStringResult
    )
    userResultsAsString->expect == ["Ok(2)", "Ok(4)", "Ok(6)", "Ok(8)", "Ok(10)"]
  })
--- a/packages/squiggle-lang/tests/SquiggleLibrary/SquiggleLibrary_FunctionRegistryLibrary_test.res
+++ b/packages/squiggle-lang/tests/SquiggleLibrary/SquiggleLibrary_FunctionRegistryLibrary_test.res
@ -99,19 +99,15 @@ describe("FunctionRegistry Library", () => {
  })

  describe("Fn auto-testing", () => {
-    testAll(
-      "tests of validity",
-      examples,
-      r => {
+    testAll("tests of validity", examples, r => {
      expectEvalToBeOk(r)
-      },
-    )
+    })

    testAll(
      "tests of type",
      E.A.to_list(
-        FunctionRegistry_Core.Registry.allExamplesWithFns(registry)->E.A2.filter(
-          ((fn, _)) => E.O.isSome(fn.output),
+        FunctionRegistry_Core.Registry.allExamplesWithFns(registry)->E.A2.filter(((fn, _)) =>
+          E.O.isSome(fn.output)
        ),
      ),
      ((fn, example)) => {
--- a/packages/squiggle-lang/tests/SquiggleLibrary/SquiggleLibrary_Plot_test.res
+++ b/packages/squiggle-lang/tests/SquiggleLibrary/SquiggleLibrary_Plot_test.res
@ -0,0 +1,20 @@
+open Jest
+open Reducer_TestHelpers
+
+describe("Plot Library", () => {
+  testEvalToBe(
+    `Plot.dist({
+    show: [{
+      name: "normal",
+      value: normal(0, 1)
+    }, {
+      name: "lognormal", 
+      value: 1 to 2
+    }, {
+      name: "constant", 
+      value: 3
+    }]
+})`,
+    "Ok(Plot showing normal,lognormal,constant)",
+  )
+})
--- a/packages/squiggle-lang/tests/TestHelpers.res
+++ b/packages/squiggle-lang/tests/TestHelpers.res
@ -45,12 +45,12 @@ let toExtDist: option<DistributionTypes.genericDist> => DistributionTypes.generi
 let unpackFloat = x => x->toFloat->toExtFloat
 let unpackDist = y => y->toDist->toExtDist

-let mkNormal = (mean, stdev) => DistributionTypes.Symbolic(#Normal({mean, stdev}))
-let mkBeta = (alpha, beta) => DistributionTypes.Symbolic(#Beta({alpha, beta}))
+let mkNormal = (mean, stdev) => DistributionTypes.Symbolic(#Normal({mean: mean, stdev: stdev}))
+let mkBeta = (alpha, beta) => DistributionTypes.Symbolic(#Beta({alpha: alpha, beta: beta}))
 let mkExponential = rate => DistributionTypes.Symbolic(#Exponential({rate: rate}))
-let mkUniform = (low, high) => DistributionTypes.Symbolic(#Uniform({low, high}))
-let mkCauchy = (local, scale) => DistributionTypes.Symbolic(#Cauchy({local, scale}))
-let mkLognormal = (mu, sigma) => DistributionTypes.Symbolic(#Lognormal({mu, sigma}))
+let mkUniform = (low, high) => DistributionTypes.Symbolic(#Uniform({low: low, high: high}))
+let mkCauchy = (local, scale) => DistributionTypes.Symbolic(#Cauchy({local: local, scale: scale}))
+let mkLognormal = (mu, sigma) => DistributionTypes.Symbolic(#Lognormal({mu: mu, sigma: sigma}))
 let mkDelta = x => DistributionTypes.Symbolic(#Float(x))

 let normalMake = SymbolicDist.Normal.make
--- a/packages/squiggle-lang/bsconfig.json
+++ b/packages/squiggle-lang/bsconfig.json
@ -25,6 +25,7 @@
  ],
  "suffix": ".bs.js",
  "namespace": true,
+  "bs-dependencies": ["bisect_ppx"],
  "bs-dev-dependencies": [
    "@glennsl/rescript-jest",
    "rescript-fast-check",
@ -44,5 +45,8 @@
  "refmt": 3,
  "warnings": {
    "number": "+A-42-48-9-30-4"
-  }
+  },
+  "ppx-flags": [
+    ["../../node_modules/bisect_ppx/ppx", "--exclude-files", ".*_test\\.res$$"]
+  ]
 }
--- a/packages/squiggle-lang/jest.config.js
+++ b/packages/squiggle-lang/jest.config.js
@ -2,6 +2,9 @@
 module.exports = {
  preset: "ts-jest",
  testEnvironment: "node",
+  setupFilesAfterEnv: [
+    "<rootdir>/../../node_modules/bisect_ppx/src/runtime/js/jest.bs.js",
+  ],
  testPathIgnorePatterns: [
    ".*Fixtures.bs.js",
    "/node_modules/",
--- a/packages/squiggle-lang/package.json
+++ b/packages/squiggle-lang/package.json
@ -22,8 +22,12 @@
    "test:rescript": "jest --modulePathIgnorePatterns=__tests__/TS/*",
    "test:watch": "jest --watchAll",
    "test:fnRegistry": "jest __tests__/SquiggleLibrary/SquiggleLibrary_FunctionRegistryLibrary_test.bs.js",
-    "coverage:local": "jest --coverage && echo && echo 'Open ./coverage/lcov-report/index.html to see the detailed report.'",
-    "coverage": "jest --coverage && codecov",
+    "coverage:rescript:local": "rm -f *.coverage && yarn clean && BISECT_ENABLE=yes yarn build && yarn test:rescript && bisect-ppx-report html",
+    "coverage:ts:local": "yarn clean && yarn build && nyc --reporter=lcov yarn test:ts",
+    "coverage:rescript": "yarn clean && BISECT_ENABLE=yes yarn build:rescript && yarn test:rescript && bisect-ppx-report send-to Codecov",
+    "coverage:ts": "yarn coverage:ts:local && codecov",
+    "coverage": "yarn coverage:ts && yarn coverage:rescript",
+    "coverage:local": "yarn coverage:ts:local && yarn coverage:rescript:local",
    "lint:rescript": "./lint.sh",
    "lint:prettier": "prettier --check .",
    "lint": "yarn lint:rescript && yarn lint:prettier",
@ -39,7 +43,7 @@
  ],
  "author": "Quantified Uncertainty Research Institute",
  "dependencies": {
-    "@rescript/std": "^10.0.0",
+    "@rescript/std": "^9.1.4",
    "@stdlib/stats": "^0.0.13",
    "jstat": "^1.9.5",
    "lodash": "^4.17.21",
@ -48,20 +52,24 @@
  },
  "devDependencies": {
    "@glennsl/rescript-jest": "^0.9.2",
+    "@istanbuljs/nyc-config-typescript": "^1.0.2",
    "@types/jest": "^27.5.0",
-    "chalk": "^5.1.0",
+    "babel-plugin-transform-es2015-modules-commonjs": "^6.26.2",
+    "bisect_ppx": "^2.7.1",
+    "chalk": "^5.0.1",
    "codecov": "^3.8.3",
    "fast-check": "^3.1.4",
    "gentype": "^4.5.0",
    "jest": "^27.5.1",
    "moduleserve": "^0.9.1",
+    "nyc": "^15.1.0",
    "peggy": "^2.0.1",
    "prettier": "^2.7.1",
    "reanalyze": "^2.23.0",
-    "rescript": "^10.0.0",
+    "rescript": "^9.1.4",
    "rescript-fast-check": "^1.1.1",
    "rescript-js-map": "^1.1.0",
-    "ts-jest": "^29.0.3",
+    "ts-jest": "^27.1.4",
    "ts-loader": "^9.4.1",
    "ts-node": "^10.9.1",
    "typescript": "^4.8.4",
--- a/packages/squiggle-lang/src/js/SqPlot.ts
+++ b/packages/squiggle-lang/src/js/SqPlot.ts
@ -0,0 +1,25 @@
+import * as RSPlot from "../rescript/ForTS/ForTS_SquiggleValue/ForTS_SquiggleValue_Plot.gen";
+import { SqDistribution, wrapDistribution } from "./SqDistribution";
+import { SqValueLocation } from "./SqValueLocation";
+
+type T = RSPlot.squiggleValue_Plot;
+
+export type LabeledDistribution = {
+  name: string;
+  distribution: SqDistribution;
+};
+
+export class SqPlot {
+  constructor(private _value: T, public location: SqValueLocation) {}
+
+  getDistributions(): LabeledDistribution[] {
+    return this._value.distributions.map((v: RSPlot.labeledDistribution) => ({
+      ...v,
+      distribution: wrapDistribution(v.distribution),
+    }));
+  }
+
+  toString() {
+    return RSPlot.toString(this._value);
+  }
+}
--- a/packages/squiggle-lang/src/js/SqValue.ts
+++ b/packages/squiggle-lang/src/js/SqValue.ts
@ -4,6 +4,7 @@ import { wrapDistribution } from "./SqDistribution";
 import { SqLambda } from "./SqLambda";
 import { SqLambdaDeclaration } from "./SqLambdaDeclaration";
 import { SqRecord } from "./SqRecord";
+import { SqPlot } from "./SqPlot";
 import { SqArray } from "./SqArray";
 import { SqValueLocation } from "./SqValueLocation";

@ -91,6 +92,14 @@ export class SqNumberValue extends SqAbstractValue {
  }
 }

+export class SqPlotValue extends SqAbstractValue {
+  tag = Tag.Plot as const;
+
+  get value() {
+    return new SqPlot(this.valueMethod(RSValue.getPlot), this.location);
+  }
+}
+
 export class SqRecordValue extends SqAbstractValue {
  tag = Tag.Record as const;

@ -131,6 +140,7 @@ const tagToClass = {
  [Tag.Distribution]: SqDistributionValue,
  [Tag.Lambda]: SqLambdaValue,
  [Tag.Number]: SqNumberValue,
+  [Tag.Plot]: SqPlotValue,
  [Tag.Record]: SqRecordValue,
  [Tag.String]: SqStringValue,
  [Tag.TimeDuration]: SqTimeDurationValue,
@ -148,6 +158,7 @@ export type SqValue =
  | SqLambdaValue
  | SqNumberValue
  | SqRecordValue
+  | SqPlotValue
  | SqStringValue
  | SqTimeDurationValue
  | SqVoidValue;
--- a/packages/squiggle-lang/src/js/index.ts
+++ b/packages/squiggle-lang/src/js/index.ts
@ -6,6 +6,7 @@ export { result } from "../rescript/ForTS/ForTS_Result_tag";
 export { SqDistribution, SqDistributionTag } from "./SqDistribution";
 export { SqDistributionError } from "./SqDistributionError";
 export { SqRecord } from "./SqRecord";
+export { SqPlot, LabeledDistribution } from "./SqPlot";
 export { SqLambda } from "./SqLambda";
 export { SqProject };
 export { SqValue, SqValueTag };
@ -14,7 +15,7 @@ export {
  defaultEnvironment,
 } from "../rescript/ForTS/ForTS_Distribution/ForTS_Distribution.gen";
 export { SqError, SqFrame, SqLocation } from "./SqError";
-export { SqShape } from "./SqPointSetDist";
+export { SqShape, SqPoint } from "./SqPointSetDist";

 export { resultMap } from "./types";

--- a/packages/squiggle-lang/src/rescript/Distributions/DistributionOperation.res
+++ b/packages/squiggle-lang/src/rescript/Distributions/DistributionOperation.res
@ -141,7 +141,6 @@ let rec run = (~env: env, functionCallInfo: functionCallInfo): outputType => {
        Js.log2("Console log requested: ", dist)
        Dist(dist)
      }
-
    | #ToDist(Normalize) => dist->GenericDist.normalize->Dist
    | #ToScore(LogScore(answer, prior)) =>
      GenericDist.Score.logScore(~estimate=dist, ~answer, ~prior, ~env)
--- a/packages/squiggle-lang/src/rescript/Distributions/GenericDist.res
+++ b/packages/squiggle-lang/src/rescript/Distributions/GenericDist.res
@ -99,7 +99,6 @@ let toFloatOperation = (
        }
      }
    }
-
  | (#Stdev | #Variance | #Mode) as op =>
    switch t {
    | SampleSet(s) =>
@ -130,7 +129,7 @@ let toPointSet = (
    SampleSetDist.toPointSetDist(
      ~samples=r,
      ~samplingInputs={
-        sampleCount,
+        sampleCount: sampleCount,
        outputXYPoints: xyPointLength,
        pointSetDistLength: xyPointLength,
        kernelWidth: None,
@ -428,7 +427,6 @@ module AlgebraicCombination = {
          ~toSampleSetFn,
        )
      }
-
    | (None, AsMonteCarlo) =>
      StrategyCallOnValidatedInputs.monteCarlo(toSampleSetFn, arithmeticOperation, t1, t2)
    | (None, AsSymbolic) =>
@ -445,7 +443,6 @@ module AlgebraicCombination = {
            )}`
          Error(RequestedStrategyInvalidError(errString))
        }
-
      | Some(convOp) => StrategyCallOnValidatedInputs.convolution(toPointSetFn, convOp, t1, t2)
      }
    }
--- a/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/AlgebraicShapeCombination.res
+++ b/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/AlgebraicShapeCombination.res
@ -69,7 +69,7 @@ let toDiscretePointMassesFromTriangulars = (
      ()
    }

-    {n: n - 2, masses, means, variances}
+    {n: n - 2, masses: masses, means: means, variances: variances}
  } else {
    for i in 1 to n - 2 {
      // area of triangle = width * height / 2
@ -91,7 +91,7 @@ let toDiscretePointMassesFromTriangulars = (
      ) |> ignore
      ()
    }
-    {n: n - 2, masses, means, variances}
+    {n: n - 2, masses: masses, means: means, variances: variances}
  }
 }

@ -184,7 +184,7 @@ let toDiscretePointMassesFromDiscrete = (s: PointSetTypes.xyShape): pointMassesW
  let means: array<float> = Belt.Array.makeBy(n, i => xs[i])
  let variances: array<float> = Belt.Array.makeBy(n, _ => 0.0)

-  {n, masses, means, variances}
+  {n: n, masses: masses, means: means, variances: variances}
 }

 type argumentPosition = First | Second
--- a/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/Continuous.res
+++ b/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/Continuous.res
@ -45,16 +45,16 @@ module Analysis = {
 let getShape = (t: t) => t.xyShape
 let interpolation = (t: t) => t.interpolation
 let make = (~interpolation=#Linear, ~integralSumCache=None, ~integralCache=None, xyShape): t => {
-  xyShape,
-  interpolation,
-  integralSumCache,
-  integralCache,
+  xyShape: xyShape,
+  interpolation: interpolation,
+  integralSumCache: integralSumCache,
+  integralCache: integralCache,
 }
 let shapeMap = (fn, {xyShape, interpolation, integralSumCache, integralCache}: t): t => {
  xyShape: fn(xyShape),
-  interpolation,
-  integralSumCache,
-  integralCache,
+  interpolation: interpolation,
+  integralSumCache: integralSumCache,
+  integralCache: integralCache,
 }
 let lastY = (t: t) => t |> getShape |> XYShape.T.lastY
 let oShapeMap = (fn, {xyShape, interpolation, integralSumCache, integralCache}: t): option<
@ -135,10 +135,10 @@ let shapeFn = (fn, t: t) => t |> getShape |> fn

 let updateIntegralSumCache = (integralSumCache, t: t): t => {
  ...t,
-  integralSumCache,
+  integralSumCache: integralSumCache,
 }

-let updateIntegralCache = (integralCache, t: t): t => {...t, integralCache}
+let updateIntegralCache = (integralCache, t: t): t => {...t, integralCache: integralCache}

 let sum = (
  ~integralSumCachesFn: (float, float) => option<float>=(_, _) => None,
--- a/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/Discrete.res
+++ b/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/Discrete.res
@ -4,14 +4,14 @@ open Distributions
 type t = PointSetTypes.discreteShape

 let make = (~integralSumCache=None, ~integralCache=None, xyShape): t => {
-  xyShape,
-  integralSumCache,
-  integralCache,
+  xyShape: xyShape,
+  integralSumCache: integralSumCache,
+  integralCache: integralCache,
 }
 let shapeMap = (fn, {xyShape, integralSumCache, integralCache}: t): t => {
  xyShape: fn(xyShape),
-  integralSumCache,
-  integralCache,
+  integralSumCache: integralSumCache,
+  integralCache: integralCache,
 }
 let getShape = (t: t) => t.xyShape
 let oShapeMap = (fn, {xyShape, integralSumCache, integralCache}: t): option<t> =>
@ -63,12 +63,12 @@ let reduce = (

 let updateIntegralSumCache = (integralSumCache, t: t): t => {
  ...t,
-  integralSumCache,
+  integralSumCache: integralSumCache,
 }

 let updateIntegralCache = (integralCache, t: t): t => {
  ...t,
-  integralCache,
+  integralCache: integralCache,
 }

 /* This multiples all of the data points together and creates a new discrete distribution from the results.
--- a/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/Mixed.res
+++ b/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/Mixed.res
@ -4,10 +4,10 @@ open Distributions

 type t = PointSetTypes.mixedShape
 let make = (~integralSumCache=None, ~integralCache=None, ~continuous, ~discrete): t => {
-  continuous,
-  discrete,
-  integralSumCache,
-  integralCache,
+  continuous: continuous,
+  discrete: discrete,
+  integralSumCache: integralSumCache,
+  integralCache: integralCache,
 }

 let totalLength = (t: t): int => {
@ -35,7 +35,7 @@ let toDiscrete = ({discrete}: t) => Some(discrete)

 let updateIntegralCache = (integralCache, t: t): t => {
  ...t,
-  integralCache,
+  integralCache: integralCache,
 }

 let combinePointwise = (
--- a/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/PointSetTypes.res
+++ b/packages/squiggle-lang/src/rescript/Distributions/PointSetDist/PointSetTypes.res
@ -79,8 +79,8 @@ module MixedPoint = {
  type t = mixedPoint
  let toContinuousValue = (t: t) => t.continuous
  let toDiscreteValue = (t: t) => t.discrete
-  let makeContinuous = (continuous: float): t => {continuous, discrete: 0.0}
-  let makeDiscrete = (discrete: float): t => {continuous: 0.0, discrete}
+  let makeContinuous = (continuous: float): t => {continuous: continuous, discrete: 0.0}
+  let makeDiscrete = (discrete: float): t => {continuous: 0.0, discrete: discrete}

  let fmap = (fn: float => float, t: t) => {
    continuous: fn(t.continuous),
--- a/packages/squiggle-lang/src/rescript/Distributions/SymbolicDist/SymbolicDist.res
+++ b/packages/squiggle-lang/src/rescript/Distributions/SymbolicDist/SymbolicDist.res
@ -7,7 +7,7 @@ module Normal = {
  type t = normal
  let make = (mean: float, stdev: float): result<symbolicDist, string> =>
    stdev > 0.0
-      ? Ok(#Normal({mean, stdev}))
+      ? Ok(#Normal({mean: mean, stdev: stdev}))
      : Error("Standard deviation of normal distribution must be larger than 0")
  let pdf = (x, t: t) => Jstat.Normal.pdf(x, t.mean, t.stdev)
  let cdf = (x, t: t) => Jstat.Normal.cdf(x, t.mean, t.stdev)
@ -15,7 +15,7 @@ module Normal = {
  let from90PercentCI = (low, high) => {
    let mean = E.A.Floats.mean([low, high])
    let stdev = (high -. low) /. (2. *. normal95confidencePoint)
-    #Normal({mean, stdev})
+    #Normal({mean: mean, stdev: stdev})
  }
  let inv = (p, t: t) => Jstat.Normal.inv(p, t.mean, t.stdev)
  let sample = (t: t) => Jstat.Normal.sample(t.mean, t.stdev)
@ -25,12 +25,12 @@ module Normal = {
  let add = (n1: t, n2: t) => {
    let mean = n1.mean +. n2.mean
    let stdev = Js.Math.sqrt(n1.stdev ** 2. +. n2.stdev ** 2.)
-    #Normal({mean, stdev})
+    #Normal({mean: mean, stdev: stdev})
  }
  let subtract = (n1: t, n2: t) => {
    let mean = n1.mean -. n2.mean
    let stdev = Js.Math.sqrt(n1.stdev ** 2. +. n2.stdev ** 2.)
-    #Normal({mean, stdev})
+    #Normal({mean: mean, stdev: stdev})
  }

  // TODO: is this useful here at all? would need the integral as well ...
@ -38,7 +38,7 @@ module Normal = {
    let mean =
      (n1.mean *. n2.stdev ** 2. +. n2.mean *. n1.stdev ** 2.) /. (n1.stdev ** 2. +. n2.stdev ** 2.)
    let stdev = 1. /. (1. /. n1.stdev ** 2. +. 1. /. n2.stdev ** 2.)
-    #Normal({mean, stdev})
+    #Normal({mean: mean, stdev: stdev})
  }

  let operate = (operation: Operation.Algebraic.t, n1: t, n2: t) =>
@ -88,7 +88,7 @@ module Cauchy = {
  type t = cauchy
  let make = (local, scale): result<symbolicDist, string> =>
    scale > 0.0
-      ? Ok(#Cauchy({local, scale}))
+      ? Ok(#Cauchy({local: local, scale: scale}))
      : Error("Cauchy distribution scale parameter must larger than 0.")
  let pdf = (x, t: t) => Jstat.Cauchy.pdf(x, t.local, t.scale)
  let cdf = (x, t: t) => Jstat.Cauchy.cdf(x, t.local, t.scale)
@ -102,7 +102,7 @@ module Triangular = {
  type t = triangular
  let make = (low, medium, high): result<symbolicDist, string> =>
    low < medium && medium < high
-      ? Ok(#Triangular({low, medium, high}))
+      ? Ok(#Triangular({low: low, medium: medium, high: high}))
      : Error("Triangular values must be increasing order.")
  let pdf = (x, t: t) => Jstat.Triangular.pdf(x, t.low, t.high, t.medium) // not obvious in jstat docs that high comes before medium?
  let cdf = (x, t: t) => Jstat.Triangular.cdf(x, t.low, t.high, t.medium)
@ -116,7 +116,7 @@ module Beta = {
  type t = beta
  let make = (alpha, beta) =>
    alpha > 0.0 && beta > 0.0
-      ? Ok(#Beta({alpha, beta}))
+      ? Ok(#Beta({alpha: alpha, beta: beta}))
      : Error("Beta distribution parameters must be positive")
  let pdf = (x, t: t) => Jstat.Beta.pdf(x, t.alpha, t.beta)
  let cdf = (x, t: t) => Jstat.Beta.cdf(x, t.alpha, t.beta)
@ -150,7 +150,7 @@ module Lognormal = {
  type t = lognormal
  let make = (mu, sigma) =>
    sigma > 0.0
-      ? Ok(#Lognormal({mu, sigma}))
+      ? Ok(#Lognormal({mu: mu, sigma: sigma}))
      : Error("Lognormal standard deviation must be larger than 0")
  let pdf = (x, t: t) => Jstat.Lognormal.pdf(x, t.mu, t.sigma)
  let cdf = (x, t: t) => Jstat.Lognormal.cdf(x, t.mu, t.sigma)
@ -164,7 +164,7 @@ module Lognormal = {
    let logHigh = Js.Math.log(high)
    let mu = E.A.Floats.mean([logLow, logHigh])
    let sigma = (logHigh -. logLow) /. (2.0 *. normal95confidencePoint)
-    #Lognormal({mu, sigma})
+    #Lognormal({mu: mu, sigma: sigma})
  }
  let fromMeanAndStdev = (mean, stdev) => {
    // https://math.stackexchange.com/questions/2501783/parameters-of-a-lognormal-distribution
@ -174,7 +174,7 @@ module Lognormal = {
      let meanSquared = mean ** 2.
      let mu = 2. *. Js.Math.log(mean) -. 0.5 *. Js.Math.log(variance +. meanSquared)
      let sigma = Js.Math.sqrt(Js.Math.log(variance /. meanSquared +. 1.))
-      Ok(#Lognormal({mu, sigma}))
+      Ok(#Lognormal({mu: mu, sigma: sigma}))
    } else {
      Error("Lognormal standard deviation must be larger than 0")
    }
@ -184,14 +184,14 @@ module Lognormal = {
    // https://wikiless.org/wiki/Log-normal_distribution?lang=en#Multiplication_and_division_of_independent,_log-normal_random_variables
    let mu = l1.mu +. l2.mu
    let sigma = Js.Math.sqrt(l1.sigma ** 2. +. l2.sigma ** 2.)
-    #Lognormal({mu, sigma})
+    #Lognormal({mu: mu, sigma: sigma})
  }
  let divide = (l1, l2) => {
    let mu = l1.mu -. l2.mu
    // We believe the ratiands will have covariance zero.
    // See here https://stats.stackexchange.com/questions/21735/what-are-the-mean-and-variance-of-the-ratio-of-two-lognormal-variables for details
    let sigma = Js.Math.sqrt(l1.sigma ** 2. +. l2.sigma ** 2.)
-    #Lognormal({mu, sigma})
+    #Lognormal({mu: mu, sigma: sigma})
  }
  let operate = (operation: Operation.Algebraic.t, n1: t, n2: t) =>
    switch operation {
@ -220,7 +220,7 @@ module Lognormal = {
 module Uniform = {
  type t = uniform
  let make = (low, high) =>
-    high > low ? Ok(#Uniform({low, high})) : Error("High must be larger than low")
+    high > low ? Ok(#Uniform({low: low, high: high})) : Error("High must be larger than low")

  let pdf = (x, t: t) => Jstat.Uniform.pdf(x, t.low, t.high)
  let cdf = (x, t: t) => Jstat.Uniform.cdf(x, t.low, t.high)
@ -239,7 +239,9 @@ module Uniform = {
 module Logistic = {
  type t = logistic
  let make = (location, scale) =>
-    scale > 0.0 ? Ok(#Logistic({location, scale})) : Error("Scale must be positive")
+    scale > 0.0
+      ? Ok(#Logistic({location: location, scale: scale}))
+      : Error("Scale must be positive")

  let pdf = (x, t: t) => Stdlib.Logistic.pdf(x, t.location, t.scale)
  let cdf = (x, t: t) => Stdlib.Logistic.cdf(x, t.location, t.scale)
@ -283,7 +285,7 @@ module Gamma = {
  let make = (shape: float, scale: float) => {
    if shape > 0. {
      if scale > 0. {
-        Ok(#Gamma({shape, scale}))
+        Ok(#Gamma({shape: shape, scale: scale}))
      } else {
        Error("scale must be larger than 0")
      }
@ -541,6 +543,6 @@ module T = {
    | _ =>
      let xs = interpolateXs(~xSelection, d, sampleCount)
      let ys = xs |> E.A.fmap(x => pdf(x, d))
-      Continuous(Continuous.make(~integralSumCache=Some(1.0), {xs, ys}))
+      Continuous(Continuous.make(~integralSumCache=Some(1.0), {xs: xs, ys: ys}))
    }
 }
--- a/packages/squiggle-lang/src/rescript/FR/FR_Builtin.res
+++ b/packages/squiggle-lang/src/rescript/FR/FR_Builtin.res
@ -23,7 +23,7 @@ let makeFn = (
  name: string,
  inputs: array<frType>,
  fn: array<Reducer_T.value> => result<Reducer_T.value, errorMessage>,
-) => makeFnMany(name, [{inputs, fn}])
+) => makeFnMany(name, [{inputs: inputs, fn: fn}])

 let library = [
  Make.ff2f(~name="add", ~fn=(x, y) => x +. y, ()), // infix + (see Reducer/Reducer_Peggy/helpers.ts)
@ -62,7 +62,6 @@ let library = [
        let answer = Js.String2.concat(a, b)
        answer->Reducer_T.IEvString->Ok
      }
-
    | _ => Error(impossibleError)
    }
  }),
@ -73,7 +72,6 @@ let library = [
        let _ = Js.Array2.pushMany(a, b)
        a->Reducer_T.IEvArray->Ok
      }
-
    | _ => Error(impossibleError)
    }
  }),
@ -83,7 +81,6 @@ let library = [
        Js.log(value->Reducer_Value.toString)
        value->Ok
      }
-
    | _ => Error(impossibleError)
    }
  }),
@ -93,7 +90,6 @@ let library = [
        Js.log(`${label}: ${value->Reducer_Value.toString}`)
        value->Ok
      }
-
    | _ => Error(impossibleError)
    }
  }),
--- a/packages/squiggle-lang/src/rescript/FR/FR_Danger.res
+++ b/packages/squiggle-lang/src/rescript/FR/FR_Danger.res
@ -135,13 +135,11 @@ module Integration = {
              let wrappedResult = result->Reducer_T.IEvNumber->Ok
              wrappedResult
            }
-
          | (Error(b), _) => Error(b)
          | (_, Error(b)) => Error(b)
          }
          resultWithOuterPoints
        }
-
      | Error(b) =>
        ("Integration error 2 in Danger.integrate. It's possible that your function doesn't return a number, try definining auxiliaryFunction(x) = mean(yourFunction(x)) and integrate auxiliaryFunction instead." ++
        "Original error: " ++
@ -364,7 +362,6 @@ module DiminishingReturns = {
                        result[indexOfBiggestDMR] = value
                        Ok(result)
                      }
-
                    | Error(b) => Error(b)
                    }

@ -374,12 +371,10 @@ module DiminishingReturns = {
                    }
                    Ok(newAcc)
                  }
-
                | Error(b) => Error(b)
                }
                newAccWrapped
              }
-
            | Error(b) => Error(b)
            }
          })
@ -432,12 +427,10 @@ module DiminishingReturns = {
                    )
                    result
                  }
-
                | Error(b) => Error(b)
                }
                result
              }
-
            | _ =>
              "Error in Danger.diminishingMarginalReturnsForTwoFunctions"
              ->SqError.Message.REOther
--- a/packages/squiggle-lang/src/rescript/FR/FR_Fn.res
+++ b/packages/squiggle-lang/src/rescript/FR/FR_Fn.res
@ -20,7 +20,6 @@ module Declaration = {
        ->E.A.R.firstErrorOrOpen
        ->E.R2.fmap(args => Reducer_T.IEvDeclaration(Declaration.make(lambda, args)))
      }
-
    | Error(r) => Error(r)
    | Ok(_) => Error(impossibleErrorString)
    }
--- a/packages/squiggle-lang/src/rescript/FR/FR_GenericDist.res
+++ b/packages/squiggle-lang/src/rescript/FR/FR_GenericDist.res
@ -140,7 +140,6 @@ module Old = {
            | Error(err) => error(err)
            }
          }
-
        | Some(IEvNumber(_))
        | Some(IEvDistribution(_)) =>
          switch parseDistributionArray(args) {
@ -193,7 +192,6 @@ module Old = {
        }
        Helpers.toFloatFn(fn, dist, ~env)
      }
-
    | ("integralSum", [IEvDistribution(dist)]) => Helpers.toFloatFn(#IntegralSum, dist, ~env)
    | ("toString", [IEvDistribution(dist)]) => Helpers.toStringFn(ToString, dist, ~env)
    | ("sparkline", [IEvDistribution(dist)]) =>
--- a/packages/squiggle-lang/src/rescript/FR/FR_Plot.res
+++ b/packages/squiggle-lang/src/rescript/FR/FR_Plot.res
@ -0,0 +1,146 @@
+open FunctionRegistry_Core
+open FunctionRegistry_Helpers
+
+let nameSpace = "Plot"
+
+module FnApp = {
+  type fnApp<'a> = {
+    result: Reducer_T.value => result<'a, SqError.Message.t>,
+    typeRequired: frType,
+  }
+
+  let fmap = (f: 'a => 'b, m: fnApp<'a>): fnApp<'b> => {
+    {
+      result: (a: Reducer_T.value) => E.R.fmap(f, m.result(a)),
+      typeRequired: m.typeRequired,
+    }
+  }
+
+  module Record = {
+    type t<'a> = {
+      result: Reducer_T.map => result<'a, SqError.Message.t>,
+      typesRequired: array<(string, frType)>,
+    }
+
+    let getField = (key: string, parser: fnApp<'a>): t<'a> => {
+      let func = (a: Reducer_T.map) =>
+        switch Belt.Map.String.get(a, key) {
+        | Some(x) => parser.result(x)
+        | None => Error(impossibleError)
+        }
+      {result: func, typesRequired: [(key, parser.typeRequired)]}
+    }
+
+    let merge = (m1: t<'a>, m2: t<'b>): t<('a, 'b)> => {
+      {
+        result: (a: Reducer_T.map) => E.R.merge(m1.result(a), m2.result(a)),
+        typesRequired: Belt.Array.concat(m1.typesRequired, m2.typesRequired),
+      }
+    }
+
+    let fmap = (f: 'a => 'b, m: t<'a>): t<'b> => {
+      {
+        result: (a: Reducer_T.map) => E.R.fmap(f, m.result(a)),
+        typesRequired: m.typesRequired,
+      }
+    }
+
+    let app = (m1: t<'a => 'b>, m2: t<'a>): t<'b> => {
+      {
+        result: (a: Reducer_T.map) =>
+          E.R.merge(m1.result(a), m2.result(a))->E.R2.fmap(((f, x)) => f(x)),
+        typesRequired: Belt.Array.concat(m1.typesRequired, m2.typesRequired),
+      }
+    }
+  }
+
+  let getString: fnApp<string> = {
+    let func = (a: Reducer_T.value) =>
+      switch a {
+      | IEvString(s) => Ok(s)
+      | _ => Error(impossibleError)
+      }
+    {result: func, typeRequired: FRTypeString}
+  }
+
+  let getArray = (child: fnApp<'a>): fnApp<array<'a>> => {
+    let func = (a: Reducer_T.value) =>
+      switch a {
+      | IEvArray(x) => x->E.A2.fmap(child.result)->E.A.R.firstErrorOrOpen
+      | _ => Error(impossibleError)
+      }
+    {result: func, typeRequired: FRTypeArray(child.typeRequired)}
+  }
+  let getRecord = (recMonad: Record.t<'a>): fnApp<'a> => {
+    let func = (a: Reducer_T.value) =>
+      switch a {
+      | IEvRecord(s) => recMonad.result(s)
+      | _ => Error(impossibleError)
+      }
+    {result: func, typeRequired: FRTypeRecord(recMonad.typesRequired)}
+  }
+
+  let getDistOrNumber: fnApp<GenericDist.t> = {
+    let func = (a: Reducer_T.value) =>
+      switch a {
+      | IEvDistribution(s) => Ok(s)
+      | IEvNumber(s) => Ok(GenericDist.fromFloat(s))
+      | _ => Error(impossibleError)
+      }
+    {result: func, typeRequired: FRTypeDistOrNumber}
+  }
+
+  let oneArgDef = (
+    name: string,
+    arg1: fnApp<'a>,
+    def: 'a => result<Reducer_T.value, SqError.Message.t>,
+  ): FnDefinition.t =>
+    FnDefinition.make(
+      ~name,
+      ~inputs=[arg1.typeRequired],
+      ~run=(inputs, _, _) => {
+        E.R.bind(arg1.result(inputs[0]), def)
+      },
+      (),
+    )
+}
+
+module Internals = {
+  let makeLabeledDistribution = (
+    name: string,
+    distribution: GenericDist.t,
+  ): Reducer_T.labeledDistribution => {name: name, distribution: distribution}
+
+  let getLabeledDistribution: FnApp.fnApp<Reducer_T.labeledDistribution> = {
+    makeLabeledDistribution
+    ->FnApp.Record.fmap(FnApp.Record.getField("name", FnApp.getString))
+    ->FnApp.Record.app(FnApp.Record.getField("value", FnApp.getDistOrNumber))
+    ->FnApp.getRecord
+  }
+
+  let makePlot = (show: array<Reducer_T.labeledDistribution>): Reducer_T.plotValue => {
+    distributions: show,
+  }
+
+  let parsePlotValue: FnApp.fnApp<Reducer_T.plotValue> = {
+    makePlot
+    ->FnApp.Record.fmap(FnApp.Record.getField("show", FnApp.getArray(getLabeledDistribution)))
+    ->FnApp.getRecord
+  }
+}
+
+let library = [
+  Function.make(
+    ~name="dist",
+    ~nameSpace,
+    ~requiresNamespace=true,
+    ~output=EvtPlot,
+    ~examples=[
+      `Plot.dist({show: [{name: "Control", value: 1 to 2}, {name: "Treatment", value: 1.5 to 2.5}]}) `,
+    ],
+    ~definitions=[
+      FnApp.oneArgDef("dist", Internals.parsePlotValue, (a: Reducer_T.plotValue) => Ok(IEvPlot(a))),
+    ],
+    (),
+  ),
+]
--- a/packages/squiggle-lang/src/rescript/FR/FR_Pointset.res
+++ b/packages/squiggle-lang/src/rescript/FR/FR_Pointset.res
@ -19,7 +19,6 @@ let inputsToDist = (inputs: array<Reducer_T.value>, xyShapeToPointSetDist) => {
          | _ => impossibleError->SqError.Message.throw
          }
        }
-
      | _ => impossibleError->SqError.Message.throw
      }
    )
--- a/packages/squiggle-lang/src/rescript/ForTS/ForTS_SquiggleValue/ForTS_SquiggleValue.res
+++ b/packages/squiggle-lang/src/rescript/ForTS/ForTS_SquiggleValue/ForTS_SquiggleValue.res
@ -6,6 +6,7 @@ type error = SqError.t //use
 type squiggleValue_Declaration = ForTS_SquiggleValue_Declaration.squiggleValue_Declaration //use
 type squiggleValue_Distribution = ForTS_SquiggleValue_Distribution.squiggleValue_Distribution //use
 type squiggleValue_Lambda = ForTS_SquiggleValue_Lambda.squiggleValue_Lambda //use
+@genType type squiggleValue_Plot = Reducer_T.plotValue //use

 // Return values are kept as they are if they are JavaScript types.

@ -30,6 +31,9 @@ external svtLambda_: string = "Lambda"
@module("./ForTS_SquiggleValue_tag") @scope("squiggleValueTag")
 external svtNumber_: string = "Number"

+@module("./ForTS_SquiggleValue_tag") @scope("squiggleValueTag")
+external svtPlot_: string = "Plot"
+
@module("./ForTS_SquiggleValue_tag") @scope("squiggleValueTag")
 external svtRecord_: string = "Record"

@ -57,6 +61,7 @@ let getTag = (variant: squiggleValue): squiggleValueTag =>
  | IEvDistribution(_) => svtDistribution_->castEnum
  | IEvLambda(_) => svtLambda_->castEnum
  | IEvNumber(_) => svtNumber_->castEnum
+  | IEvPlot(_) => svtPlot_->castEnum
  | IEvRecord(_) => svtRecord_->castEnum
  | IEvString(_) => svtString_->castEnum
  | IEvTimeDuration(_) => svtTimeDuration_->castEnum
@ -122,6 +127,13 @@ let getNumber = (variant: squiggleValue): option<float> =>
  | _ => None
  }

+@genType
+let getPlot = (variant: squiggleValue): option<squiggleValue_Plot> =>
+  switch variant {
+  | IEvPlot(value) => value->Some
+  | _ => None
+  }
+
@genType
 let getRecord = (variant: squiggleValue): option<squiggleValue_Record> =>
  switch variant {
--- a/packages/squiggle-lang/src/rescript/ForTS/ForTS_SquiggleValue/ForTS_SquiggleValue_Plot.res
+++ b/packages/squiggle-lang/src/rescript/ForTS/ForTS_SquiggleValue/ForTS_SquiggleValue_Plot.res
@ -0,0 +1,6 @@
+type squiggleValue = ForTS_SquiggleValue.squiggleValue //use
+@genType type squiggleValue_Plot = ForTS_SquiggleValue.squiggleValue_Plot //re-export recursive type
+@genType type labeledDistribution = Reducer_T.labeledDistribution // use
+
+@genType
+let toString = (v: squiggleValue_Plot) => Reducer_Value.toStringPlot(v)
--- a/packages/squiggle-lang/src/rescript/ForTS/ForTS_SquiggleValue/ForTS_SquiggleValue_tag.ts
+++ b/packages/squiggle-lang/src/rescript/ForTS/ForTS_SquiggleValue/ForTS_SquiggleValue_tag.ts
@ -6,6 +6,7 @@ export enum squiggleValueTag {
  Distribution = "Distribution",
  Lambda = "Lambda",
  Number = "Number",
+  Plot = "Plot",
  Record = "Record",
  String = "String",
  TimeDuration = "TimeDuration",
--- a/packages/squiggle-lang/src/rescript/FunctionRegistry/FunctionRegistry_Core.res
+++ b/packages/squiggle-lang/src/rescript/FunctionRegistry/FunctionRegistry_Core.res
@ -1,4 +1,5 @@
 type internalExpressionValueType = Reducer_Value.internalExpressionValueType
+let valueTypeToString = Reducer_Value.valueTypeToString
 type errorMessage = SqError.Message.t

 /*
@ -61,7 +62,6 @@ module FRType = {
        let input = ((name, frType): frTypeRecordParam) => `${name}: ${toString(frType)}`
        `{${r->E.A2.fmap(input)->E.A2.joinWith(", ")}}`
      }
-
    | FRTypeArray(r) => `list(${toString(r)})`
    | FRTypeLambda => `lambda`
    | FRTypeString => `string`
@ -133,9 +133,9 @@ module FnDefinition = {
  }

  let make = (~name, ~inputs, ~run, ()): t => {
-    name,
-    inputs,
-    run,
+    name: name,
+    inputs: inputs,
+    run: run,
  }
 }

@ -161,14 +161,14 @@ module Function = {
    ~isExperimental=false,
    (),
  ): t => {
-    name,
-    nameSpace,
-    definitions,
-    output,
+    name: name,
+    nameSpace: nameSpace,
+    definitions: definitions,
+    output: output,
    examples: examples->E.O2.default([]),
-    isExperimental,
-    requiresNamespace,
-    description,
+    isExperimental: isExperimental,
+    requiresNamespace: requiresNamespace,
+    description: description,
  }

  let toJson = (t: t): functionJson => {
@ -204,19 +204,15 @@ module Registry = {
            fn.requiresNamespace ? [] : [def.name],
          ]->E.A.concatMany

-        names->Belt.Array.reduce(
-          acc,
-          (acc, name) => {
+        names->Belt.Array.reduce(acc, (acc, name) => {
          switch acc->Belt.Map.String.get(name) {
          | Some(fns) => {
              let _ = fns->Js.Array2.push(def) // mutates the array, no need to update acc
              acc
            }
-
          | None => acc->Belt.Map.String.set(name, [def])
          }
-          },
-        )
+        })
      })
    )
  }
@ -250,7 +246,6 @@ module Registry = {
        | None => REOther(showNameMatchDefinitions())->Error
        }
      }
-
    | None => RESymbolNotFound(fnName)->Error
    }
  }
--- a/packages/squiggle-lang/src/rescript/FunctionRegistry/FunctionRegistry_Helpers.res
+++ b/packages/squiggle-lang/src/rescript/FunctionRegistry/FunctionRegistry_Helpers.res
@ -34,7 +34,6 @@ module Prepare = {
            let n2 = map->Belt.Map.String.getExn(arg2)
            Ok([n1, n2])
          }
-
        | _ => Error(impossibleErrorString)
        }

@ -46,7 +45,6 @@ module Prepare = {
            let n3 = map->Belt.Map.String.getExn(arg3)
            Ok([n1, n2, n3])
          }
-
        | _ => Error(impossibleErrorString)
        }
    }
--- a/packages/squiggle-lang/src/rescript/FunctionRegistry/FunctionRegistry_Library.res
+++ b/packages/squiggle-lang/src/rescript/FunctionRegistry/FunctionRegistry_Library.res
@ -1,18 +1,19 @@
 let fnList = Belt.Array.concatMany([
  FR_Builtin.library,
+  FR_Danger.library,
+  FR_Date.library,
  FR_Dict.library,
  FR_Dist.library,
-  FR_Danger.library,
  FR_Fn.library,
-  FR_Sampleset.library,
-  FR_List.library,
-  FR_Number.library,
-  FR_Pointset.library,
-  FR_Scoring.library,
  FR_GenericDist.library,
-  FR_Units.library,
-  FR_Date.library,
+  FR_List.library,
  FR_Math.library,
+  FR_Number.library,
+  FR_Plot.library,
+  FR_Pointset.library,
+  FR_Sampleset.library,
+  FR_Scoring.library,
+  FR_Units.library,
 ])

 let registry = FunctionRegistry_Core.Registry.make(fnList)
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Bindings.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Bindings.res
@ -44,4 +44,4 @@ let removeResult = ({namespace} as bindings: t): t => {

 let locals = ({namespace}: t): Reducer_T.namespace => namespace

-let fromNamespace = (namespace: Reducer_Namespace.t): t => {namespace, parent: None}
+let fromNamespace = (namespace: Reducer_Namespace.t): t => {namespace: namespace, parent: None}
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Context.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Context.res
@ -6,7 +6,7 @@ let createContext = (stdLib: Reducer_Namespace.t, environment: Reducer_T.environ
  {
    frameStack: list{},
    bindings: stdLib->Reducer_Bindings.fromNamespace->Reducer_Bindings.extend,
-    environment,
+    environment: environment,
    inFunction: None,
  }
 }
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Expression/Reducer_Expression.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Expression/Reducer_Expression.res
@ -123,7 +123,6 @@ let rec evaluate: T.reducerFn = (expression, context): (T.value, T.context) => {
          )
          (result, context)
        }
-
      | _ => RENotAFunction(lambda->Reducer_Value.toString)->throwFrom(expression, context)
      }
    }
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_FrameStack.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_FrameStack.res
@ -23,8 +23,8 @@ let make = (): t => list{}

 let extend = (t: t, name: string, location: option<Reducer_Peggy_Parse.location>) =>
  t->Belt.List.add({
-    name,
-    location,
+    name: name,
+    location: location,
  })

 // this is useful for SyntaxErrors
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Lambda.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Lambda.res
@ -43,10 +43,10 @@ let makeLambda = (

  FnLambda({
    // context: bindings,
-    name,
+    name: name,
    body: lambda,
-    parameters,
-    location,
+    parameters: parameters,
+    location: location,
  })
 }

@ -54,8 +54,8 @@ let makeLambda = (
 let makeFFILambda = (name: string, body: Reducer_T.lambdaBody): t => FnBuiltin({
  // Note: current bindings could be accidentally exposed here through context (compare with native lambda implementation above, where we override them with local bindings).
  // But FunctionRegistry API is too limited for that to matter. Please take care not to violate that in the future by accident.
-  body,
-  name,
+  body: body,
+  name: name,
 })

 // this function doesn't scale to FunctionRegistry's polymorphic functions
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Peggy/Reducer_Peggy_Parse.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Peggy/Reducer_Peggy_Parse.res
@ -113,7 +113,7 @@ let nodeToAST = (node: node) => {
  | _ => raise(UnsupportedPeggyNodeType(node["type"]))
  }

-  {location: node["location"], content}
+  {location: node["location"], content: content}
 }

 let nodeIdentifierToAST = (node: nodeIdentifier) => {
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Peggy/Reducer_Peggy_ToExpression.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Peggy/Reducer_Peggy_ToExpression.res
@ -68,7 +68,7 @@ let rec fromNode = (node: Parse.node): expression => {
  }

  {
-    ast,
-    content,
+    ast: ast,
+    content: content,
  }
 }
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_T.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_T.res
@ -9,10 +9,12 @@ type rec value =
  | IEvDistribution(DistributionTypes.genericDist)
  | IEvLambda(lambdaValue)
  | IEvNumber(float)
+  | IEvPlot(plotValue)
  | IEvRecord(map)
  | IEvString(string)
  | IEvTimeDuration(float)
  | IEvVoid
+
@genType.opaque and arrayValue = array<value>
@genType.opaque and map = Belt.Map.String.t<value>
 and lambdaBody = (array<value>, context, reducerFn) => value
@ -66,4 +68,12 @@ and context = {

 and reducerFn = (expression, context) => (value, context)

+@genType and plotValue = {distributions: array<labeledDistribution>}
+
+@genType
+and labeledDistribution = {
+  name: string,
+  distribution: DistributionTypes.genericDist,
+}
+
 let topFrameName = "<top>"
--- a/packages/squiggle-lang/src/rescript/Reducer/Reducer_Value.res
+++ b/packages/squiggle-lang/src/rescript/Reducer/Reducer_Value.res
@ -14,6 +14,7 @@ let rec toString = (aValue: T.value) =>
  | IEvDistribution(dist) => toStringDistribution(dist)
  | IEvLambda(lambdaValue) => toStringLambda(lambdaValue)
  | IEvNumber(aNumber) => toStringNumber(aNumber)
+  | IEvPlot(aPlot) => toStringPlot(aPlot)
  | IEvRecord(aMap) => aMap->toStringRecord
  | IEvString(aString) => toStringString(aString)
  | IEvTimeDuration(t) => toStringTimeDuration(t)
@ -35,6 +36,10 @@ and toStringLambda = (lambdaValue: T.lambdaValue) => {
  }
 }
 and toStringNumber = aNumber => Js.String.make(aNumber)
+and toStringPlot = aPlot => {
+  let chartNames = E.A.fmap((x: Reducer_T.labeledDistribution) => x.name, aPlot.distributions)
+  `Plot showing ${Js.Array2.toString(chartNames)}`
+}
 and toStringRecord = aMap => aMap->toStringMap
 and toStringString = aString => `'${aString}'`
 and toStringSymbol = aString => `:${aString}`
@ -59,6 +64,7 @@ let toStringWithType = (aValue: T.value) =>
  | IEvDistribution(_) => `Distribution::${toString(aValue)}`
  | IEvLambda(_) => `Lambda::${toString(aValue)}`
  | IEvNumber(_) => `Number::${toString(aValue)}`
+  | IEvPlot(_) => `Plot::${toString(aValue)}`
  | IEvRecord(_) => `Record::${toString(aValue)}`
  | IEvString(_) => `String::${toString(aValue)}`
  | IEvTimeDuration(_) => `Date::${toString(aValue)}`
@ -91,6 +97,7 @@ type internalExpressionValueType =
  | EvtDistribution
  | EvtLambda
  | EvtNumber
+  | EvtPlot
  | EvtRecord
  | EvtString
  | EvtTimeDuration
@ -109,6 +116,7 @@ let valueToValueType = (value: T.value) =>
  | IEvDistribution(_) => EvtDistribution
  | IEvLambda(_) => EvtLambda
  | IEvNumber(_) => EvtNumber
+  | IEvPlot(_) => EvtPlot
  | IEvRecord(_) => EvtRecord
  | IEvString(_) => EvtString
  | IEvTimeDuration(_) => EvtTimeDuration
@ -129,6 +137,7 @@ let valueTypeToString = (valueType: internalExpressionValueType): string =>
  | EvtDistribution => `Distribution`
  | EvtLambda => `Lambda`
  | EvtNumber => `Number`
+  | EvtPlot => `Plot`
  | EvtRecord => `Record`
  | EvtString => `String`
  | EvtTimeDuration => `Duration`
--- a/packages/squiggle-lang/src/rescript/ReducerProject/ReducerProject.res
+++ b/packages/squiggle-lang/src/rescript/ReducerProject/ReducerProject.res
@ -216,7 +216,6 @@ let tryRunWithResult = (
        project->setResult(sourceId, Error(error))
        Error(error)
      }
-
    | Ok(_prevResult) => {
        project->doLinkAndRun(sourceId)
        project->getResultOption(sourceId)->Belt.Option.getWithDefault(rPrevResult)
--- a/packages/squiggle-lang/src/rescript/ReducerProject/ReducerProject_ProjectItem.res
+++ b/packages/squiggle-lang/src/rescript/ReducerProject/ReducerProject_ProjectItem.res
@ -6,7 +6,7 @@ type t = T.t

 let emptyItem = (sourceId: string): projectItem => {
  source: "",
-  sourceId,
+  sourceId: sourceId,
  rawParse: None,
  expression: None,
  continuation: Reducer_Namespace.make(),
@ -76,7 +76,7 @@ let resetIncludes = (r: t): t => {
 }

 let setSource = (r: t, source: T.sourceArgumentType): t =>
-  {...r, source}->resetIncludes->touchSource
+  {...r, source: source}->resetIncludes->touchSource

 let setRawParse = (r: t, rawParse: T.rawParseArgumentType): t =>
  {...r, rawParse: Some(rawParse)}->touchRawParse
@ -86,7 +86,7 @@ let setExpression = (r: t, expression: T.expressionArgumentType): t =>

 let setContinuation = (r: t, continuation: T.continuationArgumentType): t => {
  ...r,
-  continuation,
+  continuation: continuation,
 }

 let setResult = (r: t, result: T.resultArgumentType): t => {
@ -110,23 +110,24 @@ let getPastChain = (this: t): array<string> => {
  Js.Array2.concat(getDirectIncludes(this), getContinues(this))
 }

-let setContinues = (this: t, continues: array<string>): t => {...this, continues}->touchSource
+let setContinues = (this: t, continues: array<string>): t =>
+  {...this, continues: continues}->touchSource

 let removeContinues = (this: t): t => {...this, continues: []}->touchSource

 let setIncludes = (this: t, includes: T.includesType): t => {
  ...this,
-  includes,
+  includes: includes,
 }

 let setImportAsVariables = (this: t, includeAsVariables: T.importAsVariablesType): t => {
  ...this,
-  includeAsVariables,
+  includeAsVariables: includeAsVariables,
 }

 let setDirectImports = (this: t, directIncludes: array<string>): t => {
  ...this,
-  directIncludes,
+  directIncludes: directIncludes,
 }

 let parseIncludes = (this: t): t => {
@ -143,9 +144,9 @@ let parseIncludes = (this: t): t => {
        ->Belt.Array.map(((_variable, file)) => file)
      {
        ...this,
-        includes,
-        includeAsVariables,
-        directIncludes,
+        includes: includes,
+        includeAsVariables: includeAsVariables,
+        directIncludes: directIncludes,
      }
    }
  }
--- a/packages/squiggle-lang/src/rescript/SqError.res
+++ b/packages/squiggle-lang/src/rescript/SqError.res
@ -54,7 +54,6 @@ module Message = {
        }
        answer
      }
-
    | REMacroNotFound(macro) => `Macro not found: ${macro}`
    | RENotAFunction(valueString) => `${valueString} is not a function`
    | RERecordPropertyNotFound(msg, index) => `${msg}: ${index}`
@ -94,8 +93,8 @@ type t = {
 exception SqException(t)

 let fromMessageWithFrameStack = (message: Message.t, frameStack: Reducer_FrameStack.t): t => {
-  message,
-  frameStack,
+  message: message,
+  frameStack: frameStack,
 }

 // this shouldn't be used much, since frame stack will be empty
--- a/packages/squiggle-lang/src/rescript/SquiggleLibrary/SquiggleLibrary_StdLib.res
+++ b/packages/squiggle-lang/src/rescript/SquiggleLibrary/SquiggleLibrary_StdLib.res
@ -18,7 +18,6 @@ let stdLib: Reducer_T.namespace = {
          | None => REArrayIndexNotFound("Array index not found", index)->SqError.Message.throw
          }
        }
-
      | [IEvRecord(dict), IEvString(sIndex)] =>
        switch Belt.Map.String.get(dict, sIndex) {
        | Some(value) => value
--- a/packages/squiggle-lang/src/rescript/Utility/Declaration.res
+++ b/packages/squiggle-lang/src/rescript/Utility/Declaration.res
@ -9,13 +9,13 @@ type declaration<'a> = {

 module ContinuousFloatArg = {
  let make = (min: float, max: float): arg => {
-    Float({min, max})
+    Float({min: min, max: max})
  }
 }

 module ContinuousTimeArg = {
  let make = (min: Js.Date.t, max: Js.Date.t): arg => {
-    Date({min, max})
+    Date({min: min, max: max})
  }
 }

@ -33,7 +33,7 @@ module Arg = {
 }

 let make = (fn: 'a, args: array<arg>): declaration<'a> => {
-  {fn, args}
+  {fn: fn, args: args}
 }

 let toString = (r: declaration<'a>, fnToString): string => {
--- a/packages/squiggle-lang/src/rescript/Utility/XYShape.res
+++ b/packages/squiggle-lang/src/rescript/Utility/XYShape.res
@ -85,8 +85,8 @@ module T = {
  }
  let square = mapX(x => x ** 2.0)
  let zip = ({xs, ys}: t) => Belt.Array.zip(xs, ys)
-  let fromArray = ((xs, ys)): t => {xs, ys}
-  let fromArrays = (xs, ys): t => {xs, ys}
+  let fromArray = ((xs, ys)): t => {xs: xs, ys: ys}
+  let fromArrays = (xs, ys): t => {xs: xs, ys: ys}
  let accumulateYs = (fn, p: t) => fromArray((p.xs, E.A.accumulate(fn, p.ys)))
  let concat = (t1: t, t2: t) => {
    let cxs = Array.concat(list{t1.xs, t2.xs})
@ -142,7 +142,7 @@ module T = {
  }

  let make = (~xs: array<float>, ~ys: array<float>) => {
-    let attempt: t = {xs, ys}
+    let attempt: t = {xs: xs, ys: ys}
    switch Validator.validate(attempt) {
    | Some(error) => Error(error)
    | None => Ok(attempt)
@ -452,7 +452,6 @@ module PointwiseCombination = {
          let _ = Js.Array.push(fn(y1, y2), newYs)
          let _ = Js.Array.push(x, newXs)
        }
-
      | None => ()
      }
    }
@ -559,7 +558,7 @@ module Range = {
        (xs[x + 1] -. xs[x]) *. ((ys[x] +. ys[x + 1]) /. 2.) +. cumulativeY[x], // dx // (1/2) * (avgY)
      )
    }
-    Some({xs, ys: cumulativeY})
+    Some({xs: xs, ys: cumulativeY})
  }

  let derivative = mapYsBasedOnRanges(delta_y_over_delta_x)
--- a/packages/website/docs/Api/Dist.mdx
+++ b/packages/website/docs/Api/Dist.mdx
@ -332,7 +332,7 @@ truncateRight: (distribution, right: number) => distribution
 **Examples**

 ```javascript
-truncateRight(normal(5, 2), 6);
+truncateLeft(normal(5, 2), 6);
 ```

 ### klDivergence
--- a/packages/website/docs/Api/Plot.md
+++ b/packages/website/docs/Api/Plot.md
@ -0,0 +1,19 @@
+---
+sidebar_position: 8
+title: Plot
+---
+
+Plot objects can be created to make plots of different kinds. If you wish to plot
+multiple distributions simultaneously, you can use `Plot.dist`.
+
+**Example**
+
+### dist
+
+```
+Plot.dist({show: list({name: string, value: distribution|number})})
+```
+
+```js
+Plot.dist({show: [{name: "normal", value: normal(0, 1)}, {name: "lognormal", value: 2 to 3}]})
+```
--- a/packages/website/docs/Changelog.mdx
+++ b/packages/website/docs/Changelog.mdx
@ -1,20 +0,0 @@
---
-title: Changelog
---
-
-## 0.5.0
-
- Performance improvements:
-  - Interpreter is now 5x-20x faster on code written in Squiggle
-  - SampleSet to PointSet conversions are 2x faster
-  - cdf function on SampleSets is 30x faster
-  - overall speedup is about 2x on average on real code written in Squiggle
- 50% smaller bundle size for [@quri/squiggle-lang](https://www.npmjs.com/package/@quri/squiggle-lang); 20% smaller bundle size for [@quri/squiggle-components](https://www.npmjs.com/package/@quri/squiggle-components).
-
-### Breaking changes
-
-Some rarely used math functions got removed or moved to the `Math` namespace.
-
-For example, `cos(x)` is now `Math.cos(x)`, and `atanh(x)` doesn't exist.
-
-If your code is now failing with `<function> is not defined` for anything from [this list](https://mathjs.org/docs/reference/functions.html), try adding `Math.` prefix first, and then complain on [Github issues](https://github.com/quantified-uncertainty/squiggle/issues).
--- a/packages/website/docs/Internal/ImportIntoMdx.mdx
+++ b/packages/website/docs/Internal/ImportIntoMdx.mdx
@ -3,11 +3,9 @@ title: How to import squiggle files into `.mdx` documents
 sidebar_position: 5
 ---

-:::caution Proof of concept
+import { SquiggleEditorWithImportedBindings } from "../../src/components/SquiggleEditor";

-The following usage pattern is currently broken. We expect to bring it back in some form in 0.5.1 or 0.5.2 release.
-
-:::
+_Proof of concept_

 ## Consider the following squiggle file

@ -32,3 +30,10 @@ import { SquiggleEditorWithImportedBindings } from "../../src/components/Squiggl
 ```

 Notice, you need to wrap the export of `@quri/squiggle-components` in custom code for dynamicism, please view `packages/website/src/components/` in github for details.
+
+Which would then look exactly like
+
+<SquiggleEditorWithImportedBindings
+  defaultCode={"f(z)"}
+  bindingsImportUrl={"/estimates/demo.squiggle"}
+/>
--- a/packages/website/sidebars.js
+++ b/packages/website/sidebars.js
@ -61,11 +61,6 @@ const sidebars = {
        },
      ],
    },
-    {
-      type: "doc",
-      id: "Changelog",
-      label: "Changelog",
-    },
  ],

  // But you can create a sidebar manually
--- a/turbo.json
+++ b/turbo.json
@ -22,6 +22,7 @@
        "benchmark/**/*.bs.js",
        "src/rescript/**/*.js",
        "src/rescript/**/*.gen.tsx",
+        "../../node_modules/bisect_ppx/**/*.bs.js",
        "dist/**"
      ]
    },
@ -30,10 +31,10 @@
      "outputs": []
    },
    "bundle": {
-      "dependsOn": ["build"]
+      "dependsOn": ["^build", "build"]
    },
    "coverage": {
-      "dependsOn": ["build"]
+      "cache": false
    }
  }
 }
--- a/yarn.lock
+++ b/yarn.lock
Author	SHA1	Message	Date
Sam Nolan	76fe461363	Add plot to documentation	2022-10-11 17:32:59 +11:00
Sam Nolan	8d612f75f0	Migrate to Applicative Functors	2022-10-11 17:05:37 +11:00
Sam Nolan	c060304161	Add simple plot test	2022-10-11 12:53:16 +11:00
Sam Nolan	56913bc95e	Fix failing test	2022-10-11 12:38:15 +11:00
Sam Nolan	2dfb57240e	Merge branch 'develop' into plot-function	2022-10-10 17:40:48 +11:00
Sam Nolan	62f735efcb	Add plot function	2022-10-10 17:37:21 +11:00
				`@ -1 +0,0 @@`
				`See the [Changelog.mdx page](./packages/website/docs/Changelog.mdx) for the changelog.`