Merge pull request #1231 from quantified-uncertainty/project-in-editors

Project in editors and remove warnings

.github/CODEOWNERS

@@ -9,22 +9,22 @@
 # This also holds true for GitHub teams.
 
 # Rescript 
-*.res @OAGr
+*.res @berekuk @OAGr
-*.resi @OAGr
+*.resi @berekuk @OAGr
 
 # Typescript 
-*.tsx @Hazelfire @OAGr
+*.tsx @Hazelfire @berekuk @OAGr 
-*.ts @Hazelfire @OAGr
+*.ts @Hazelfire @berekuk @OAGr
 
 # Javascript
-*.js @Hazelfire @OAGr
+*.js @Hazelfire @berekuk @OAGr
 
 # Any opsy files
-.github/** @quinn-dougherty @OAGr
+.github/** @quinn-dougherty @berekuk @OAGr
-*.json @quinn-dougherty @Hazelfire @OAGr
+*.json @quinn-dougherty @Hazelfire @berekuk @OAGr
-*.y*ml @quinn-dougherty @OAGr
+*.y*ml @quinn-dougherty @berekuk @OAGr
-*.config.js @Hazelfire @OAGr
+*.config.js @Hazelfire @berekuk @OAGr
-netlify.toml @quinn-dougherty @OAGr @Hazelfire 
+vercel.json @OAGr @berekuk @Hazelfire
 
 # Documentation
 *.md @quinn-dougherty @OAGr @Hazelfire

.github/dependabot.yml

@@ -12,9 +12,13 @@ updates:
     commit-message:
       prefix: "⬆️"
     open-pull-requests-limit: 100
+    labels:
+      - "dependencies"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
       interval: "weekly"
     commit-message:
       prefix: "⬆️"
+    labels:
+      - "dependencies"

.github/workflows/ci.yml

@@ -1,4 +1,4 @@
-name: Squiggle packages check
+name: Squiggle packages checks
 
 on:
   push:
@@ -9,214 +9,40 @@ on:
     branches:
       - master
       - develop
-      - reducer-dev
+
-      - epic-reducer-project
+env:
+  TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
+  TURBO_TEAM: quantified-uncertainty
 
 jobs:
-  pre_check:
+  build-test-lint:
-    name: Precheck for skipping redundant jobs
+    name: Build, test, lint
     runs-on: ubuntu-latest
-    outputs:
-      should_skip_lang: ${{ steps.skip_lang_check.outputs.should_skip }}
-      should_skip_components: ${{ steps.skip_components_check.outputs.should_skip }}
-      should_skip_website: ${{ steps.skip_website_check.outputs.should_skip }}
-      should_skip_vscodeext: ${{ steps.skip_vscodeext_check.outputs.should_skip }}
-      should_skip_cli: ${{ steps.skip_cli_check.outputs.should_skip }}
     steps:
-      - id: skip_lang_check
+      - uses: actions/checkout@v3
-        name: Check if the changes are about squiggle-lang src files
+      - name: Setup Node.js environment
-        uses: fkirc/skip-duplicate-actions@v4.0.0
+        uses: actions/setup-node@v3
         with:
-          paths: '["packages/squiggle-lang/**"]'
+          node-version: 16
-      - id: skip_components_check
+          cache: 'yarn'
-        name: Check if the changes are about components src files
+      - name: Install dependencies
-        uses: fkirc/skip-duplicate-actions@v4.0.0
+        run: yarn --frozen-lockfile
-        with:
+      - name: Turbo run
-          paths: '["packages/components/**"]'
+        run: npx turbo run build test lint bundle
-      - id: skip_website_check
-        name: Check if the changes are about website src files
-        uses: fkirc/skip-duplicate-actions@v4.0.0
-        with:
-          paths: '["packages/website/**"]'
-      - id: skip_vscodeext_check
-        name: Check if the changes are about vscode extension src files
-        uses: fkirc/skip-duplicate-actions@v4.0.0
-        with:
-          paths: '["packages/vscode-ext/**"]'
-      - id: skip_cli_check
-        name: Check if the changes are about cli src files
-        uses: fkirc/skip-duplicate-actions@v4.0.0
-        with:
-          paths: '["packages/cli/**"]'
 
-  #  lang-lint:
+  coverage:
-  #    name: Language lint
+    name: Coverage
-  #    runs-on: ubuntu-latest
-  #    needs: pre_check
-  #    if: ${{ needs.pre_check.outputs.should_skip_lang != 'true' }}
-  #    defaults:
-  #      run:
-  #        shell: bash
-  #        working-directory: packages/squiggle-lang
-  #    steps:
-  #      - uses: actions/checkout@v3
-  #      - name: Install Dependencies
-  #        run: cd ../../ && yarn
-  #      - name: Check rescript lint
-  #        run: yarn lint:rescript
-  #      - name: Check javascript, typescript, and markdown lint
-  #        uses: creyD/prettier_action@v4.2
-  #        with:
-  #          dry: true
-  #          prettier_options: --check packages/squiggle-lang
-
-  lang-build-test-bundle:
-    name: Language build, test, and bundle
     runs-on: ubuntu-latest
-    needs: pre_check
-    if: ${{ needs.pre_check.outputs.should_skip_lang != 'true' }}
-    defaults:
-      run:
-        shell: bash
-        working-directory: packages/squiggle-lang
     steps:
       - uses: actions/checkout@v3
         with:
           fetch-depth: 2
-      - name: Install dependencies from monorepo level
+      - name: Setup Node.js environment
-        run: cd ../../ && yarn
+        uses: actions/setup-node@v2
-      - name: Build rescript codebase
+        with:
-        run: yarn build
+          node-version: 16
-      - name: Run rescript tests
+          cache: 'yarn'
-        run: yarn test:rescript
+      - name: Install dependencies
-      - name: Run typescript tests
+        run: yarn
-        run: yarn test:ts
+      - name: Coverage
-      - name: Run webpack
+        run: npx turbo run coverage
-        run: yarn bundle
-      - name: Upload rescript coverage report
-        run: yarn coverage:rescript:ci
-      - name: Upload typescript coverage report
-        run: yarn coverage:ts:ci
-
-  #  components-lint:
-  #    name: Components lint
-  #    runs-on: ubuntu-latest
-  #    needs: pre_check
-  #    if: ${{ needs.pre_check.outputs.should_skip_components != 'true' }}
-  #    defaults:
-  #      run:
-  #        shell: bash
-  #        working-directory: packages/components
-  #    steps:
-  #      - uses: actions/checkout@v3
-  #      - name: Check javascript, typescript, and markdown lint
-  #        uses: creyD/prettier_action@v4.2
-  #        with:
-  #          dry: true
-  #          prettier_options: --check packages/components --ignore-path packages/components/.prettierignore
-  #
-  #  components-bundle-build:
-  #    name: Components bundle and build
-  #    runs-on: ubuntu-latest
-  #    needs: pre_check
-  #    if: ${{ (needs.pre_check.outputs.should_skip_components != 'true') || (needs.pre_check.outputs.should_skip_lang != 'true') }}
-  #    defaults:
-  #      run:
-  #        shell: bash
-  #        working-directory: packages/components
-  #    steps:
-  #      - uses: actions/checkout@v3
-  #      - name: Install dependencies from monorepo level
-  #        run: cd ../../ && yarn
-  #      - name: Build rescript codebase in squiggle-lang
-  #        run: cd ../squiggle-lang && yarn build
-  #      - name: Run webpack
-  #        run: yarn bundle
-  #      - name: Build storybook
-  #        run: yarn build
-
-  #  website-lint:
-  #    name: Website lint
-  #    runs-on: ubuntu-latest
-  #    needs: pre_check
-  #    if: ${{ needs.pre_check.outputs.should_skip_website != 'true' }}
-  #    defaults:
-  #      run:
-  #        shell: bash
-  #        working-directory: packages/website
-  #    steps:
-  #      - uses: actions/checkout@v3
-  #      - name: Check javascript, typescript, and markdown lint
-  #        uses: creyD/prettier_action@v4.2
-  #        with:
-  #          dry: true
-  #          prettier_options: --check packages/website
-  #
-  #  website-build:
-  #    name: Website build
-  #    runs-on: ubuntu-latest
-  #    needs: pre_check
-  #    if: ${{ (needs.pre_check.outputs.should_skip_website != 'true') || (needs.pre_check.outputs.should_skip_lang != 'true')  || (needs.pre_check.outputs.should_skip_components != 'true') }}
-  #    defaults:
-  #      run:
-  #        shell: bash
-  #        working-directory: packages/website
-  #    steps:
-  #      - uses: actions/checkout@v3
-  #      - name: Install dependencies from monorepo level
-  #        run: cd ../../ && yarn
-  #      - name: Build rescript in squiggle-lang
-  #        run: cd ../squiggle-lang && yarn build
-  #      - name: Build components
-  #        run: cd ../components && yarn build
-  #      - name: Build website assets
-  #        run: yarn build
-  #
-  #  vscode-ext-lint:
-  #    name: VS Code extension lint
-  #    runs-on: ubuntu-latest
-  #    needs: pre_check
-  #    if: ${{ needs.pre_check.outputs.should_skip_vscodeext != 'true' }}
-  #    defaults:
-  #      run:
-  #        shell: bash
-  #        working-directory: packages/vscode-ext
-  #    steps:
-  #      - uses: actions/checkout@v3
-  #      - name: Check javascript, typescript, and markdown lint
-  #        uses: creyD/prettier_action@v4.2
-  #        with:
-  #          dry: true
-  #          prettier_options: --check packages/vscode-ext
-
-  vscode-ext-build:
-    name: VS Code extension build
-    runs-on: ubuntu-latest
-    needs: pre_check
-    if: ${{ (needs.pre_check.outputs.should_skip_components != 'true') || (needs.pre_check.outputs.should_skip_lang != 'true') }} || (needs.pre_check.outputs.should_skip_vscodeext != 'true') }}
-    defaults:
-      run:
-        shell: bash
-        working-directory: packages/vscode-ext
-    steps:
-      - uses: actions/checkout@v3
-      - name: Install dependencies from monorepo level
-        run: cd ../../ && yarn
-      - name: Build
-        run: yarn compile
-#  cli-lint:
-#    name: CLI lint
-#    runs-on: ubuntu-latest
-#    needs: pre_check
-#    if: ${{ needs.pre_check.outputs.should_skip_cli != 'true' }}
-#    defaults:
-#      run:
-#        shell: bash
-#        working-directory: packages/cli
-#    steps:
-#      - uses: actions/checkout@v3
-#      - name: Check javascript, typescript, and markdown lint
-#        uses: creyD/prettier_action@v4.2
-#        with:
-#          dry: true
-#          prettier_options: --check packages/cli

.github/workflows/release-please.yml

@@ -18,27 +18,27 @@ jobs:
     steps:
       - id: skip_lang_check
         name: Check if the changes are about squiggle-lang src files
-        uses: fkirc/skip-duplicate-actions@v4.0.0
+        uses: fkirc/skip-duplicate-actions@v5.2.0
         with:
           paths: '["packages/squiggle-lang/**"]'
       - id: skip_components_check
         name: Check if the changes are about components src files
-        uses: fkirc/skip-duplicate-actions@v4.0.0
+        uses: fkirc/skip-duplicate-actions@v5.2.0
         with:
           paths: '["packages/components/**"]'
       - id: skip_website_check
         name: Check if the changes are about website src files
-        uses: fkirc/skip-duplicate-actions@v4.0.0
+        uses: fkirc/skip-duplicate-actions@v5.2.0
         with:
           paths: '["packages/website/**"]'
       - id: skip_vscodeext_check
         name: Check if the changes are about vscode extension src files
-        uses: fkirc/skip-duplicate-actions@v4.0.0
+        uses: fkirc/skip-duplicate-actions@v5.2.0
         with:
           paths: '["packages/vscode-ext/**"]'
       - id: skip_cli_check
         name: Check if the changes are about cli src files
-        uses: fkirc/skip-duplicate-actions@v4.0.0
+        uses: fkirc/skip-duplicate-actions@v5.2.0
         with:
           paths: '["packages/cli/**"]'
 

.gitignore

@@ -7,4 +7,9 @@ yarn-error.log
 **/.sync.ffs_db
 .direnv
 .log
+
+.vscode
+todo.txt
 result
+shell.nix
+.turbo

.release-please-manifest.json

@@ -1,7 +1,7 @@
 {
   "packages/cli": "0.0.3",
-  "packages/components": "0.3.1",
+  "packages/components": "0.4.1",
-  "packages/squiggle-lang": "0.3.0",
+  "packages/squiggle-lang": "0.4.1",
-  "packages/vscode-ext": "0.3.1",
+  "packages/vscode-ext": "0.4.1",
-  "packages/website": "0.3.0"
+  "packages/website": "0.0.0"
 }

CHANGELOG.md

@@ -0,0 +1 @@
+See the [Changelog.mdx page](./packages/website/docs/Changelog.mdx) for the changelog.

CONTRIBUTING.md

@@ -16,7 +16,7 @@ Squiggle is currently pre-alpha.
 
 # Bug reports
 
-Anyone (with a github account) can file an issue at any time. Please allow Quinn, Sam, and Ozzie to triage, but otherwise just follow the suggestions in the issue templates.
+Anyone (with a github account) can file an issue at any time. Please allow Slava, Sam, and Ozzie to triage, but otherwise just follow the suggestions in the issue templates.
 
 # Project structure
 
@@ -28,7 +28,7 @@ Squiggle is a **monorepo** with three **packages**.
 
 # Deployment ops
 
-We use netlify, and it should only concern Quinn, Sam, and Ozzie.
+We use Vercel, and it should only concern Slava, Sam, and Ozzie.
 
 # Development environment, building, testing, dev server
 
@@ -56,9 +56,9 @@ If you absolutely must, please prefix your commit message with `hotfix: `.
 
 Please work against `develop` branch. **Do not** work against `master`.
 
-- For rescript code: Quinn and Ozzie are reviewers
+- For rescript code: Slava and Ozzie are reviewers
 - For js or typescript code: Sam and Ozzie are reviewers
-- For ops code (i.e. yaml, package.json): Quinn and Sam are reviewers
+- For ops code (i.e. yaml, package.json): Slava and Sam are reviewers
 
 Autopings are set up: if you are not autopinged, you are welcome to comment, but please do not use the formal review feature, send approvals, rejections, or merges.
 

README.md

@@ -21,10 +21,10 @@ _An estimation language_.
 
 ## Our deployments
 
-- **website/docs prod**: https://squiggle-language.com [![Netlify Status](https://api.netlify.com/api/v1/badges/2139af5c-671d-473d-a9f6-66c96077d8a1/deploy-status)](https://app.netlify.com/sites/squiggle-documentation/deploys)
+- **website/docs prod**: https://squiggle-language.com
-- **website/docs staging**: https://develop--squiggle-documentation.netlify.app/
+- **website/docs staging**: https://preview.squiggle-language.com
-- **components storybook prod**: https://squiggle-components.netlify.app/ [![Netlify Status](https://api.netlify.com/api/v1/badges/b7f724aa-6b20-4d0e-bf86-3fcd1a3e9a70/deploy-status)](https://app.netlify.com/sites/squiggle-components/deploys)
+- **components storybook prod**: https://components.squiggle-language.com
-- **components storybook staging**: https://develop--squiggle-components.netlify.app/
+- **components storybook staging**: https://preview-components.squiggle-language.com
 - **legacy (2020) playground**: https://playground.squiggle-language.com
 
 ## Packages
@@ -51,7 +51,25 @@ For any project in the repo, begin by running `yarn` in the top level
 yarn
 ```
 
-See `packages/*/README.md` to work with whatever project you're interested in.
+Then use `turbo` to build the specific packages or the entire monorepo:
+
+```sh
+turbo run build
+```
+
+Or:
+
+```sh
+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
 

nix/squiggle-lang.nix

@@ -30,16 +30,6 @@ 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
@@ -75,6 +65,7 @@ rec {
       # custom gitignore so that the flake keeps build artefacts
       mv .gitignore GITIGNORE
       sed -i /Reducer_Peggy_GeneratedParser.js/d GITIGNORE
+      sed -i /ReducerProject_IncludeParser.js/d GITIGNORE
       sed -i /\*.bs.js/d GITIGNORE
       sed -i /\*.gen.ts/d GITIGNORE
       sed -i /\*.gen.tsx/d GITIGNORE

nixos.sh

@@ -1,18 +0,0 @@
-#!/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

package.json

@@ -2,12 +2,11 @@
   "private": true,
   "name": "squiggle",
   "scripts": {
-    "nodeclean": "rm -r node_modules && rm -r packages/*/node_modules",
+    "nodeclean": "rm -r node_modules && rm -r packages/*/node_modules"
-    "format:all": "prettier --write . && cd packages/squiggle-lang && yarn format",
-    "lint:all": "prettier --check . && cd packages/squiggle-lang && yarn lint:rescript"
   },
   "devDependencies": {
-    "prettier": "^2.7.1"
+    "prettier": "^2.7.1",
+    "turbo": "^1.5.5"
   },
   "workspaces": [
     "packages/*"

packages/cli/README.md

@@ -20,3 +20,30 @@ 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.

packages/cli/package.json

@@ -7,13 +7,15 @@
   "bin": "index.js",
   "type": "module",
   "scripts": {
-    "start": "node ."
+    "start": "node .",
+    "lint": "prettier --check .",
+    "format": "prettier --write ."
   },
   "license": "MIT",
   "dependencies": {
-    "chalk": "^5.0.1",
+    "chalk": "^5.1.0",
     "chokidar": "^3.5.3",
-    "commander": "^9.4.0",
+    "commander": "^9.4.1",
     "fs": "^0.0.1-security",
     "glob": "^8.0.3",
     "indent-string": "^5.0.0"

packages/components/jest.config.js

@@ -0,0 +1,6 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  setupFilesAfterEnv: ["<rootDir>/test/setup.js"],
+  testEnvironment: "jsdom",
+};

packages/components/netlify.toml

@@ -1,8 +0,0 @@
-[build]
-    base = "packages/components/"
-    command = "cd ../squiggle-lang && yarn build && cd ../components && yarn build"
-    publish = "storybook-static/"
-    ignore = "node -e 'process.exitCode = process.env.BRANCH.includes(\"dependabot\") ? 0 : 1' && git diff --quiet $CACHED_COMMIT_REF $COMMIT_REF . ../squiggle-lang"
-
-[build.environment]
-    NETLIFY_USE_YARN = "true"

packages/components/package.json

@@ -1,64 +1,73 @@
 {
   "name": "@quri/squiggle-components",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "license": "MIT",
   "dependencies": {
     "@floating-ui/react-dom": "^1.0.0",
-    "@floating-ui/react-dom-interactions": "^0.9.3",
+    "@floating-ui/react-dom-interactions": "^0.10.1",
-    "@headlessui/react": "^1.6.6",
+    "@headlessui/react": "^1.7.3",
     "@heroicons/react": "^1.0.6",
-    "@hookform/resolvers": "^2.9.7",
+    "@hookform/resolvers": "^2.9.8",
-    "@quri/squiggle-lang": "^0.3.0",
+    "@quri/squiggle-lang": "^0.5.0",
     "@react-hook/size": "^2.1.2",
+    "@types/uuid": "^8.3.4",
     "clsx": "^1.2.1",
-    "framer-motion": "^7.2.1",
+    "framer-motion": "^7.5.3",
     "lodash": "^4.17.21",
     "react": "^18.1.0",
     "react-ace": "^10.1.0",
-    "react-hook-form": "^7.34.2",
+    "react-hook-form": "^7.37.0",
     "react-use": "^17.4.0",
     "react-vega": "^7.6.0",
+    "uuid": "^9.0.0",
     "vega": "^5.22.1",
     "vega-embed": "^6.21.0",
     "vega-lite": "^5.5.0",
-    "vscode-uri": "^3.0.3",
+    "vscode-uri": "^3.0.6",
     "yup": "^0.32.11"
   },
   "devDependencies": {
     "@babel/plugin-proposal-private-property-in-object": "^7.18.6",
-    "@storybook/addon-actions": "^6.5.9",
+    "@storybook/addon-actions": "^6.5.12",
-    "@storybook/addon-essentials": "^6.5.10",
+    "@storybook/addon-essentials": "^6.5.12",
-    "@storybook/addon-links": "^6.5.10",
+    "@storybook/addon-links": "^6.5.12",
-    "@storybook/builder-webpack5": "^6.5.10",
+    "@storybook/builder-webpack5": "^6.5.12",
-    "@storybook/manager-webpack5": "^6.5.10",
+    "@storybook/manager-webpack5": "^6.5.12",
     "@storybook/node-logger": "^6.5.9",
     "@storybook/preset-create-react-app": "^4.1.2",
-    "@storybook/react": "^6.5.10",
+    "@storybook/react": "^6.5.12",
     "@testing-library/jest-dom": "^5.16.5",
-    "@testing-library/react": "^13.3.0",
+    "@testing-library/react": "^13.4.0",
     "@testing-library/user-event": "^14.4.3",
     "@types/jest": "^27.5.0",
-    "@types/lodash": "^4.14.184",
+    "@types/lodash": "^4.14.186",
-    "@types/node": "^18.7.13",
+    "@types/node": "^18.8.3",
-    "@types/react": "^18.0.9",
+    "@types/react": "^18.0.21",
     "@types/styled-components": "^5.1.26",
+    "@types/uuid": "^8.3.4",
     "@types/webpack": "^5.28.0",
+    "canvas": "^2.10.1",
     "cross-env": "^7.0.3",
+    "jest": "^29.0.3",
+    "jest-environment-jsdom": "^29.1.2",
+    "jsdom": "^20.0.1",
     "mini-css-extract-plugin": "^2.6.1",
     "postcss-cli": "^10.0.0",
-    "postcss-import": "^14.1.0",
+    "postcss-import": "^15.0.0",
     "postcss-loader": "^7.0.1",
+    "postcss-nesting": "^10.2.0",
     "react": "^18.1.0",
     "react-scripts": "^5.0.1",
     "style-loader": "^3.3.1",
     "tailwindcss": "^3.1.8",
-    "ts-loader": "^9.3.0",
+    "ts-jest": "^29.0.3",
+    "ts-loader": "^9.4.1",
     "tsconfig-paths-webpack-plugin": "^4.0.0",
-    "typescript": "^4.8.2",
+    "typescript": "^4.8.4",
-    "web-vitals": "^3.0.0",
+    "web-vitals": "^3.0.3",
     "webpack": "^5.74.0",
     "webpack-cli": "^4.10.0",
-    "webpack-dev-server": "^4.10.0"
+    "webpack-dev-server": "^4.11.1"
   },
   "peerDependencies": {
     "react": "^16.8.0 || ^17 || ^18",
@@ -66,7 +75,7 @@
   },
   "scripts": {
     "start": "cross-env REACT_APP_FAST_REFRESH=false && start-storybook -p 6006 -s public",
-    "build:cjs": "tsc -b",
+    "build:cjs": "rm -rf dist/src && rm -f dist/tsconfig.tsbuildinfo && tsc -b",
     "build:css": "postcss ./src/styles/main.css -o ./dist/main.css",
     "build:storybook": "build-storybook -s public",
     "build": "yarn run build:cjs && yarn run build:css && yarn run build:storybook",
@@ -74,7 +83,10 @@
     "all": "yarn bundle && yarn build",
     "lint": "prettier --check .",
     "format": "prettier --write .",
-    "prepack": "yarn bundle && tsc -b"
+    "prepack": "yarn run build:cjs && yarn run bundle",
+    "test": "jest",
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand",
+    "test:profile": "node --cpu-prof node_modules/.bin/jest --runInBand"
   },
   "eslintConfig": {
     "extends": [

packages/components/src/components/Alert.tsx

@@ -24,13 +24,13 @@ export const Alert: React.FC<{
   children,
 }) => {
   return (
-    <div className={clsx("rounded-md p-4", backgroundColor)}>
+    <div className={clsx("rounded-md p-4", backgroundColor)} role="status">
       <div className="flex">
         <Icon
           className={clsx("h-5 w-5 flex-shrink-0", iconColor)}
           aria-hidden="true"
         />
-        <div className="ml-3">
+        <div className="ml-3 grow">
           <header className={clsx("text-sm font-medium", headingColor)}>
             {heading}
           </header>

packages/components/src/components/CodeEditor.tsx

@@ -5,6 +5,8 @@ import AceEditor from "react-ace";
 import "ace-builds/src-noconflict/mode-golang";
 import "ace-builds/src-noconflict/theme-github";
 
+import { SqLocation } from "@quri/squiggle-lang";
+
 interface CodeEditorProps {
   value: string;
   onChange: (value: string) => void;
@@ -13,15 +15,17 @@ interface CodeEditorProps {
   width?: number;
   height: number;
   showGutter?: boolean;
+  errorLocations?: SqLocation[];
 }
 
 export const CodeEditor: FC<CodeEditorProps> = ({
   value,
   onChange,
   onSubmit,
+  height,
   oneLine = false,
   showGutter = false,
-  height,
+  errorLocations = [],
 }) => {
   const lineCount = value.split("\n").length;
   const id = useMemo(() => _.uniqueId(), []);
@@ -30,8 +34,11 @@ export const CodeEditor: FC<CodeEditorProps> = ({
   const onSubmitRef = useRef<typeof onSubmit | null>(null);
   onSubmitRef.current = onSubmit;
 
+  const editorEl = useRef<AceEditor | null>(null);
+
   return (
     <AceEditor
+      ref={editorEl}
       value={value}
       mode="golang"
       theme="github"
@@ -48,10 +55,7 @@ export const CodeEditor: FC<CodeEditorProps> = ({
       editorProps={{
         $blockScrolling: true,
       }}
-      setOptions={{
+      setOptions={{}}
-        enableBasicAutocompletion: false,
-        enableLiveAutocompletion: false,
-      }}
       commands={[
         {
           name: "submit",
@@ -59,6 +63,14 @@ export const CodeEditor: FC<CodeEditorProps> = ({
           exec: () => onSubmitRef.current?.(),
         },
       ]}
+      markers={errorLocations?.map((location) => ({
+        startRow: location.start.line - 1,
+        startCol: location.start.column - 1,
+        endRow: location.end.line - 1,
+        endCol: location.end.column - 1,
+        className: "ace-error-marker",
+        type: "text",
+      }))}
     />
   );
 };

packages/components/src/components/DistributionChart.tsx

@@ -1,11 +1,12 @@
 import * as React from "react";
 import {
-  Distribution,
+  SqDistribution,
   result,
-  distributionError,
+  SqDistributionError,
-  distributionErrorToString,
-  squiggleExpression,
   resultMap,
+  SqRecord,
+  environment,
+  SqDistributionTag,
 } from "@quri/squiggle-lang";
 import { Vega } from "react-vega";
 import { ErrorAlert } from "./Alert";
@@ -28,17 +29,17 @@ export type DistributionPlottingSettings = {
 
 export type DistributionChartProps = {
   plot: Plot;
+  environment: environment;
   width?: number;
   height: number;
+  xAxisType?: "number" | "dateTime";
 } & DistributionPlottingSettings;
 
-export function defaultPlot(distribution: Distribution): Plot {
+export function defaultPlot(distribution: SqDistribution): Plot {
   return { distributions: [{ name: "default", distribution }] };
 }
 
-export function makePlot(record: {
+export function makePlot(record: SqRecord): Plot | void {
-  [key: string]: squiggleExpression;
-}): Plot | void {
   const plotResult = parsePlot(record);
   if (plotResult.tag === "Ok") {
     return plotResult.value;
@@ -46,38 +47,68 @@ export function makePlot(record: {
 }
 
 export const DistributionChart: React.FC<DistributionChartProps> = (props) => {
-  const { plot, height, showSummary, width, logX, actions = false } = props;
+  const {
+    plot,
+    environment,
+    height,
+    showSummary,
+    width,
+    logX,
+    actions = false,
+  } = props;
   const [sized] = useSize((size) => {
-    let shapes = flattenResult(
+    const shapes = flattenResult(
       plot.distributions.map((x) =>
-        resultMap(x.distribution.pointSet(), (shape) => ({
+        resultMap(x.distribution.pointSet(environment), (pointSet) => ({
           name: x.name,
           // color: x.color, // not supported yet
-          continuous: shape.continuous,
+          ...pointSet.asShape(),
-          discrete: shape.discrete,
         }))
       )
     );
+
     if (shapes.tag === "Error") {
       return (
         <ErrorAlert heading="Distribution Error">
-          {distributionErrorToString(shapes.value)}
+          {shapes.value.toString()}
         </ErrorAlert>
       );
     }
 
-    const spec = buildVegaSpec(props);
+    // if this is a sample set, include the samples
+    const samples: number[] = [];
+    for (const { distribution } of plot?.distributions) {
+      if (distribution.tag === SqDistributionTag.SampleSet) {
+        samples.push(...distribution.value());
+      }
+    }
 
-    let widthProp = width ? width : size.width;
+    const domain = shapes.value.flatMap((shape) =>
+      shape.discrete.concat(shape.continuous)
+    );
+
+    const spec = buildVegaSpec({
+      ...props,
+      minX: props.minX ?? Math.min(...domain.map((x) => x.x)),
+      maxX: props.minX ?? Math.max(...domain.map((x) => x.x)),
+      maxY: Math.max(...domain.map((x) => x.y)),
+    });
+
+    // I think size.width is sometimes not finite due to the component not being in a visible context
+    // This occurs during testing
+    let widthProp = width
+      ? width
+      : Number.isFinite(size.width)
+      ? size.width
+      : 400;
     if (widthProp < 20) {
       console.warn(
         `Width of Distribution is set to ${widthProp}, which is too small`
       );
       widthProp = 20;
     }
-    const domain = shapes.value.flatMap((shape) =>
+
-      shape.discrete.concat(shape.continuous)
+    const vegaData = { data: shapes.value, samples };
-    );
 
     return (
       <div style={{ width: widthProp }}>
@@ -88,7 +119,7 @@ export const DistributionChart: React.FC<DistributionChartProps> = (props) => {
         ) : (
           <Vega
             spec={spec}
-            data={{ data: shapes.value, domain }}
+            data={vegaData}
             width={widthProp - 10}
             height={height}
             actions={actions}
@@ -96,7 +127,10 @@ export const DistributionChart: React.FC<DistributionChartProps> = (props) => {
         )}
         <div className="flex justify-center">
           {showSummary && plot.distributions.length === 1 && (
-            <SummaryTable distribution={plot.distributions[0].distribution} />
+            <SummaryTable
+              distribution={plot.distributions[0].distribution}
+              environment={environment}
+            />
           )}
         </div>
       </div>
@@ -120,32 +154,36 @@ const Cell: React.FC<{ children: React.ReactNode }> = ({ children }) => (
 );
 
 type SummaryTableProps = {
-  distribution: Distribution;
+  distribution: SqDistribution;
+  environment: environment;
 };
 
-const SummaryTable: React.FC<SummaryTableProps> = ({ distribution }) => {
+const SummaryTable: React.FC<SummaryTableProps> = ({
-  const mean = distribution.mean();
+  distribution,
-  const stdev = distribution.stdev();
+  environment,
-  const p5 = distribution.inv(0.05);
+}) => {
-  const p10 = distribution.inv(0.1);
+  const mean = distribution.mean(environment);
-  const p25 = distribution.inv(0.25);
+  const stdev = distribution.stdev(environment);
-  const p50 = distribution.inv(0.5);
+  const p5 = distribution.inv(environment, 0.05);
-  const p75 = distribution.inv(0.75);
+  const p10 = distribution.inv(environment, 0.1);
-  const p90 = distribution.inv(0.9);
+  const p25 = distribution.inv(environment, 0.25);
-  const p95 = distribution.inv(0.95);
+  const p50 = distribution.inv(environment, 0.5);
+  const p75 = distribution.inv(environment, 0.75);
+  const p90 = distribution.inv(environment, 0.9);
+  const p95 = distribution.inv(environment, 0.95);
 
-  const hasResult = (x: result<number, distributionError>): boolean =>
+  const hasResult = (x: result<number, SqDistributionError>): boolean =>
     x.tag === "Ok";
 
   const unwrapResult = (
-    x: result<number, distributionError>
+    x: result<number, SqDistributionError>
   ): React.ReactNode => {
     if (x.tag === "Ok") {
       return <NumberShower number={x.value} />;
     } else {
       return (
         <ErrorAlert heading="Distribution Error">
-          {distributionErrorToString(x.value)}
+          {x.value.toString()}
         </ErrorAlert>
       );
     }

packages/components/src/components/FunctionChart.tsx

@@ -1,14 +1,15 @@
 import * as React from "react";
 import {
-  lambdaValue,
+  SqLambda,
   environment,
-  runForeign,
+  SqValueTag,
-  errorValueToString,
+  SqError,
 } from "@quri/squiggle-lang";
 import { FunctionChart1Dist } from "./FunctionChart1Dist";
 import { FunctionChart1Number } from "./FunctionChart1Number";
 import { DistributionPlottingSettings } from "./DistributionChart";
-import { ErrorAlert, MessageAlert } from "./Alert";
+import { MessageAlert } from "./Alert";
+import { SquiggleErrorAlert } from "./SquiggleErrorAlert";
 
 export type FunctionChartSettings = {
   start: number;
@@ -17,13 +18,32 @@ export type FunctionChartSettings = {
 };
 
 interface FunctionChartProps {
-  fn: lambdaValue;
+  fn: SqLambda;
   chartSettings: FunctionChartSettings;
   distributionPlotSettings: DistributionPlottingSettings;
   environment: environment;
   height: number;
 }
 
+const FunctionCallErrorAlert = ({ error }: { error: SqError }) => {
+  const [expanded, setExpanded] = React.useState(false);
+  if (expanded) {
+  }
+  return (
+    <MessageAlert heading="Function Display Failed">
+      <div className="space-y-2">
+        <span
+          className="underline decoration-dashed cursor-pointer"
+          onClick={() => setExpanded(!expanded)}
+        >
+          {expanded ? "Hide" : "Show"} error details
+        </span>
+        {expanded ? <SquiggleErrorAlert error={error} /> : null}
+      </div>
+    </MessageAlert>
+  );
+};
+
 export const FunctionChart: React.FC<FunctionChartProps> = ({
   fn,
   chartSettings,
@@ -31,15 +51,16 @@ export const FunctionChart: React.FC<FunctionChartProps> = ({
   distributionPlotSettings,
   height,
 }) => {
-  if (fn.parameters.length > 1) {
+  console.log(fn.parameters().length);
+  if (fn.parameters().length !== 1) {
     return (
       <MessageAlert heading="Function Display Not Supported">
         Only functions with one parameter are displayed.
       </MessageAlert>
     );
   }
-  const result1 = runForeign(fn, [chartSettings.start], environment);
+  const result1 = fn.call([chartSettings.start]);
-  const result2 = runForeign(fn, [chartSettings.stop], environment);
+  const result2 = fn.call([chartSettings.stop]);
   const getValidResult = () => {
     if (result1.tag === "Ok") {
       return result1;
@@ -52,15 +73,11 @@ export const FunctionChart: React.FC<FunctionChartProps> = ({
   const validResult = getValidResult();
 
   if (validResult.tag === "Error") {
-    return (
+    return <FunctionCallErrorAlert error={validResult.value} />;
-      <ErrorAlert heading="Error">
-        {errorValueToString(validResult.value)}
-      </ErrorAlert>
-    );
   }
 
   switch (validResult.value.tag) {
-    case "distribution":
+    case SqValueTag.Distribution:
       return (
         <FunctionChart1Dist
           fn={fn}
@@ -70,7 +87,7 @@ export const FunctionChart: React.FC<FunctionChartProps> = ({
           distributionPlotSettings={distributionPlotSettings}
         />
       );
-    case "number":
+    case SqValueTag.Number:
       return (
         <FunctionChart1Number
           fn={fn}

packages/components/src/components/FunctionChart1Dist.tsx

@@ -2,14 +2,13 @@ import * as React from "react";
 import _ from "lodash";
 import type { Spec } from "vega";
 import {
-  Distribution,
+  SqDistribution,
   result,
-  lambdaValue,
+  SqLambda,
   environment,
-  runForeign,
+  SqError,
-  squiggleExpression,
+  SqValue,
-  errorValue,
+  SqValueTag,
-  errorValueToString,
 } from "@quri/squiggle-lang";
 import { createClassFromSpec } from "react-vega";
 import * as percentilesSpec from "../vega-specs/spec-percentiles.json";
@@ -46,7 +45,7 @@ export type FunctionChartSettings = {
 };
 
 interface FunctionChart1DistProps {
-  fn: lambdaValue;
+  fn: SqLambda;
   chartSettings: FunctionChartSettings;
   distributionPlotSettings: DistributionPlottingSettings;
   environment: environment;
@@ -77,9 +76,17 @@ type errors = _.Dictionary<
   }[]
 >;
 
-type point = { x: number; value: result<Distribution, string> };
+type point = { x: number; value: result<SqDistribution, string> };
 
-let getPercentiles = ({ chartSettings, fn, environment }) => {
+let getPercentiles = ({
+  chartSettings,
+  fn,
+  environment,
+}: {
+  chartSettings: FunctionChartSettings;
+  fn: SqLambda;
+  environment: environment;
+}) => {
   let chartPointsToRender = _rangeByCount(
     chartSettings.start,
     chartSettings.stop,
@@ -87,9 +94,9 @@ let getPercentiles = ({ chartSettings, fn, environment }) => {
   );
 
   let chartPointsData: point[] = chartPointsToRender.map((x) => {
-    let result = runForeign(fn, [x], environment);
+    let result = fn.call([x]);
     if (result.tag === "Ok") {
-      if (result.value.tag === "distribution") {
+      if (result.value.tag === SqValueTag.Distribution) {
         return { x, value: { tag: "Ok", value: result.value.value } };
       } else {
         return {
@@ -104,13 +111,13 @@ let getPercentiles = ({ chartSettings, fn, environment }) => {
     } else {
       return {
         x,
-        value: { tag: "Error", value: errorValueToString(result.value) },
+        value: { tag: "Error", value: result.value.toString() },
       };
     }
   });
 
   let initialPartition: [
-    { x: number; value: Distribution }[],
+    { x: number; value: SqDistribution }[],
     { x: number; value: string }[]
   ] = [[], []];
 
@@ -126,26 +133,23 @@ let getPercentiles = ({ chartSettings, fn, environment }) => {
   let groupedErrors: errors = _.groupBy(errors, (x) => x.value);
 
   let percentiles: percentiles = functionImage.map(({ x, value }) => {
-    // We convert it to to a pointSet distribution first, so that in case its a sample set
+    const res = {
-    // distribution, it doesn't internally convert it to a pointSet distribution for every
-    // single inv() call.
-    let toPointSet: Distribution = unwrap(value.toPointSet());
-    return {
       x: x,
-      p1: unwrap(toPointSet.inv(0.01)),
+      p1: unwrap(value.inv(environment, 0.01)),
-      p5: unwrap(toPointSet.inv(0.05)),
+      p5: unwrap(value.inv(environment, 0.05)),
-      p10: unwrap(toPointSet.inv(0.1)),
+      p10: unwrap(value.inv(environment, 0.1)),
-      p20: unwrap(toPointSet.inv(0.2)),
+      p20: unwrap(value.inv(environment, 0.2)),
-      p30: unwrap(toPointSet.inv(0.3)),
+      p30: unwrap(value.inv(environment, 0.3)),
-      p40: unwrap(toPointSet.inv(0.4)),
+      p40: unwrap(value.inv(environment, 0.4)),
-      p50: unwrap(toPointSet.inv(0.5)),
+      p50: unwrap(value.inv(environment, 0.5)),
-      p60: unwrap(toPointSet.inv(0.6)),
+      p60: unwrap(value.inv(environment, 0.6)),
-      p70: unwrap(toPointSet.inv(0.7)),
+      p70: unwrap(value.inv(environment, 0.7)),
-      p80: unwrap(toPointSet.inv(0.8)),
+      p80: unwrap(value.inv(environment, 0.8)),
-      p90: unwrap(toPointSet.inv(0.9)),
+      p90: unwrap(value.inv(environment, 0.9)),
-      p95: unwrap(toPointSet.inv(0.95)),
+      p95: unwrap(value.inv(environment, 0.95)),
-      p99: unwrap(toPointSet.inv(0.99)),
+      p99: unwrap(value.inv(environment, 0.99)),
     };
+    return res;
   });
 
   return { percentiles, errors: groupedErrors };
@@ -168,19 +172,20 @@ export const FunctionChart1Dist: React.FC<FunctionChart1DistProps> = ({
   const signalListeners = { mousemove: handleHover, mouseout: handleOut };
 
   //TODO: This custom error handling is a bit hacky and should be improved.
-  let mouseItem: result<squiggleExpression, errorValue> = !!mouseOverlay
+  let mouseItem: result<SqValue, SqError> = !!mouseOverlay
-    ? runForeign(fn, [mouseOverlay], environment)
+    ? fn.call([mouseOverlay])
     : {
         tag: "Error",
-        value: {
+        value: SqError.createOtherError(
-          tag: "RETodo",
+          "Hover x-coordinate returned NaN. Expected a number."
-          value: "Hover x-coordinate returned NaN. Expected a number.",
+        ),
-        },
       };
   let showChart =
-    mouseItem.tag === "Ok" && mouseItem.value.tag === "distribution" ? (
+    mouseItem.tag === "Ok" &&
+    mouseItem.value.tag === SqValueTag.Distribution ? (
       <DistributionChart
         plot={defaultPlot(mouseItem.value.value)}
+        environment={environment}
         width={400}
         height={50}
         {...distributionPlotSettings}

packages/components/src/components/FunctionChart1Number.tsx

@@ -1,16 +1,11 @@
 import * as React from "react";
 import _ from "lodash";
 import type { Spec } from "vega";
-import {
+import { result, SqLambda, environment, SqValueTag } from "@quri/squiggle-lang";
-  result,
-  lambdaValue,
-  environment,
-  runForeign,
-  errorValueToString,
-} from "@quri/squiggle-lang";
 import { createClassFromSpec } from "react-vega";
 import * as lineChartSpec from "../vega-specs/spec-line-chart.json";
 import { ErrorAlert } from "./Alert";
+import { squiggleValueTag } from "@quri/squiggle-lang/src/rescript/ForTS/ForTS_SquiggleValue/ForTS_SquiggleValue_tag";
 
 let SquiggleLineChart = createClassFromSpec({
   spec: lineChartSpec as Spec,
@@ -30,7 +25,7 @@ export type FunctionChartSettings = {
 };
 
 interface FunctionChart1NumberProps {
-  fn: lambdaValue;
+  fn: SqLambda;
   chartSettings: FunctionChartSettings;
   environment: environment;
   height: number;
@@ -38,7 +33,15 @@ interface FunctionChart1NumberProps {
 
 type point = { x: number; value: result<number, string> };
 
-let getFunctionImage = ({ chartSettings, fn, environment }) => {
+let getFunctionImage = ({
+  chartSettings,
+  fn,
+  environment,
+}: {
+  chartSettings: FunctionChartSettings;
+  fn: SqLambda;
+  environment: environment;
+}) => {
   let chartPointsToRender = _rangeByCount(
     chartSettings.start,
     chartSettings.stop,
@@ -46,9 +49,9 @@ let getFunctionImage = ({ chartSettings, fn, environment }) => {
   );
 
   let chartPointsData: point[] = chartPointsToRender.map((x) => {
-    let result = runForeign(fn, [x], environment);
+    let result = fn.call([x]);
     if (result.tag === "Ok") {
-      if (result.value.tag == "number") {
+      if (result.value.tag === SqValueTag.Number) {
         return { x, value: { tag: "Ok", value: result.value.value } };
       } else {
         return {
@@ -62,7 +65,7 @@ let getFunctionImage = ({ chartSettings, fn, environment }) => {
     } else {
       return {
         x,
-        value: { tag: "Error", value: errorValueToString(result.value) },
+        value: { tag: "Error", value: result.value.toString() },
       };
     }
   });

packages/components/src/components/SquiggleChart.tsx

@@ -1,25 +1,22 @@
 import * as React from "react";
 import {
-  squiggleExpression,
+  SqValue,
-  bindings,
   environment,
-  jsImports,
+  SqProject,
-  defaultImports,
-  defaultBindings,
   defaultEnvironment,
 } from "@quri/squiggle-lang";
 import { useSquiggle } from "../lib/hooks";
 import { SquiggleViewer } from "./SquiggleViewer";
+import { JsImports } from "../lib/jsImports";
+import { getValueToRender } from "../lib/utility";
 
-export interface SquiggleChartProps {
+export type SquiggleChartProps = {
   /** The input string for squiggle */
-  code?: string;
+  code: string;
   /** Allows to re-run the code if code hasn't changed */
   executionId?: number;
   /** If the output requires monte carlo sampling, the amount of samples */
   sampleCount?: number;
-  /** The amount of points returned to draw the distribution */
-  environment?: environment;
   /** If the result is a function, where the function domain starts */
   diagramStart?: number;
   /** If the result is a function, where the function domain ends */
@@ -27,14 +24,12 @@ export interface SquiggleChartProps {
   /** If the result is a function, the amount of stops sampled */
   diagramCount?: number;
   /** When the squiggle code gets reevaluated */
-  onChange?(expr: squiggleExpression | undefined): void;
+  onChange?(expr: SqValue | undefined, sourceName: string): void;
   /** CSS width of the element */
   width?: number;
   height?: number;
-  /** Bindings of previous variables declared */
-  bindings?: bindings;
   /** JS imported parameters */
-  jsImports?: jsImports;
+  jsImports?: JsImports;
   /** Whether to show a summary of the distribution */
   showSummary?: boolean;
   /** Set the x scale to be logarithmic by deault */
@@ -51,24 +46,35 @@ export interface SquiggleChartProps {
   minX?: number;
   /** Specify the upper bound of the x scale */
   maxX?: number;
+  /** Whether the x-axis should be dates or numbers */
+  xAxisType?: "number" | "dateTime";
   /** Whether to show vega actions to the user, so they can copy the chart spec */
   distributionChartActions?: boolean;
   enableLocalSettings?: boolean;
-}
+} & (StandaloneExecutionProps | ProjectExecutionProps);
 
+// Props needed for a standalone execution
+type StandaloneExecutionProps = {
+  project?: undefined;
+  continues?: undefined;
+  /** The amount of points returned to draw the distribution, not needed if using a project */
+  environment?: environment;
+};
+
+// Props needed when executing inside a project.
+type ProjectExecutionProps = {
+  environment?: undefined;
+  /** The project that this execution is part of */
+  project: SqProject;
+  /** What other squiggle sources from the project to continue. Default [] */
+  continues?: string[];
+};
 const defaultOnChange = () => {};
+const defaultImports: JsImports = {};
 
-export const SquiggleChart: React.FC<SquiggleChartProps> = React.memo(
+export const splitSquiggleChartSettings = (props: SquiggleChartProps) => {
-  ({
+  const {
-    code = "",
-    executionId = 0,
-    environment,
-    onChange = defaultOnChange, // defaultOnChange must be constant, don't move its definition here
-    height = 200,
-    bindings = defaultBindings,
-    jsImports = defaultImports,
     showSummary = false,
-    width,
     logX = false,
     expY = false,
     diagramStart = 0,
@@ -79,44 +85,72 @@ export const SquiggleChart: React.FC<SquiggleChartProps> = React.memo(
     maxX,
     color,
     title,
+    xAxisType = "number",
     distributionChartActions,
-    enableLocalSettings = false,
+  } = props;
-  }) => {
+
-    const result = useSquiggle({
+  const distributionPlotSettings = {
+    showSummary,
+    logX,
+    expY,
+    format: tickFormat,
+    minX,
+    maxX,
+    color,
+    title,
+    xAxisType,
+    actions: distributionChartActions,
+  };
+
+  const chartSettings = {
+    start: diagramStart,
+    stop: diagramStop,
+    count: diagramCount,
+  };
+
+  return { distributionPlotSettings, chartSettings };
+};
+
+export const SquiggleChart: React.FC<SquiggleChartProps> = React.memo(
+  (props) => {
+    const { distributionPlotSettings, chartSettings } =
+      splitSquiggleChartSettings(props);
+
+    const {
       code,
-      bindings,
+      jsImports = defaultImports,
+      onChange = defaultOnChange, // defaultOnChange must be constant, don't move its definition here
+      executionId = 0,
+      width,
+      height = 200,
+      enableLocalSettings = false,
+      continues,
+      project,
       environment,
+    } = props;
+
+    const resultAndBindings = useSquiggle({
+      environment,
+      continues,
+      project,
+      code,
       jsImports,
       onChange,
       executionId,
     });
 
-    const distributionPlotSettings = {
+    const valueToRender = getValueToRender(resultAndBindings);
-      showSummary,
-      logX,
-      expY,
-      format: tickFormat,
-      minX,
-      maxX,
-      color,
-      title,
-      actions: distributionChartActions,
-    };
-
-    const chartSettings = {
-      start: diagramStart,
-      stop: diagramStop,
-      count: diagramCount,
-    };
 
     return (
       <SquiggleViewer
-        result={result}
+        result={valueToRender}
         width={width}
         height={height}
         distributionPlotSettings={distributionPlotSettings}
         chartSettings={chartSettings}
-        environment={environment ?? defaultEnvironment}
+        environment={
+          project ? project.getEnvironment() : environment ?? defaultEnvironment
+        }
         enableLocalSettings={enableLocalSettings}
       />
     );

packages/components/src/components/SquiggleEditor.tsx

@@ -1,23 +1,29 @@
 import React from "react";
 import { CodeEditor } from "./CodeEditor";
-import { environment, bindings, jsImports } from "@quri/squiggle-lang";
-import { defaultImports, defaultBindings } from "@quri/squiggle-lang";
 import { SquiggleContainer } from "./SquiggleContainer";
-import { SquiggleChart, SquiggleChartProps } from "./SquiggleChart";
+import {
-import { useSquigglePartial, useMaybeControlledValue } from "../lib/hooks";
+  splitSquiggleChartSettings,
-import { SquiggleErrorAlert } from "./SquiggleErrorAlert";
+  SquiggleChartProps,
+} from "./SquiggleChart";
+import { useMaybeControlledValue, useSquiggle } from "../lib/hooks";
+import { JsImports } from "../lib/jsImports";
+import { defaultEnvironment, SqLocation, SqProject } from "@quri/squiggle-lang";
+import { SquiggleViewer } from "./SquiggleViewer";
+import { getErrorLocations, getValueToRender } from "../lib/utility";
 
 const WrappedCodeEditor: React.FC<{
   code: string;
   setCode: (code: string) => void;
-}> = ({ code, setCode }) => (
+  errorLocations?: SqLocation[];
-  <div className="border border-grey-200 p-2 m-4">
+}> = ({ code, setCode, errorLocations }) => (
+  <div className="border border-grey-200 p-2 m-4" data-testid="squiggle-editor">
     <CodeEditor
       value={code}
       onChange={setCode}
       oneLine={true}
       showGutter={false}
       height={20}
+      errorLocations={errorLocations}
     />
   </div>
 );
@@ -27,6 +33,9 @@ export type SquiggleEditorProps = SquiggleChartProps & {
   onCodeChange?: (code: string) => void;
 };
 
+const defaultOnChange = () => {};
+const defaultImports: JsImports = {};
+
 export const SquiggleEditor: React.FC<SquiggleEditorProps> = (props) => {
   const [code, setCode] = useMaybeControlledValue({
     value: props.code,
@@ -34,59 +43,50 @@ export const SquiggleEditor: React.FC<SquiggleEditorProps> = (props) => {
     onChange: props.onCodeChange,
   });
 
-  let chartProps = { ...props, code };
+  const { distributionPlotSettings, chartSettings } =
-  return (
+    splitSquiggleChartSettings(props);
-    <SquiggleContainer>
-      <WrappedCodeEditor code={code} setCode={setCode} />
-      <SquiggleChart {...chartProps} />
-    </SquiggleContainer>
-  );
-};
 
-export interface SquigglePartialProps {
+  const {
-  /** The text inside the input (controlled) */
-  code?: string;
-  /** The default text inside the input (unControlled) */
-  defaultCode?: string;
-  /** when the environment changes. Used again for notebook magic*/
-  onChange?(expr: bindings | undefined): void;
-  /** When the code changes */
-  onCodeChange?(code: string): void;
-  /** Previously declared variables */
-  bindings?: bindings;
-  /** If the output requires monte carlo sampling, the amount of samples */
-  environment?: environment;
-  /** Variables imported from js */
-  jsImports?: jsImports;
-}
-
-export const SquigglePartial: React.FC<SquigglePartialProps> = ({
-  code: controlledCode,
-  defaultCode = "",
-  onChange,
-  onCodeChange,
-  bindings = defaultBindings,
-  environment,
-  jsImports = defaultImports,
-}: SquigglePartialProps) => {
-  const [code, setCode] = useMaybeControlledValue<string>({
-    value: controlledCode,
-    defaultValue: defaultCode,
-    onChange: onCodeChange,
-  });
-
-  const result = useSquigglePartial({
-    code,
-    bindings,
     environment,
+    jsImports = defaultImports,
+    onChange = defaultOnChange, // defaultOnChange must be constant, don't move its definition here
+    executionId = 0,
+    width,
+    height = 200,
+    enableLocalSettings = false,
+    continues,
+    project,
+  } = props;
+
+  const resultAndBindings = useSquiggle({
+    environment,
+    continues,
+    code,
+    project,
     jsImports,
     onChange,
+    executionId,
   });
 
+  const valueToRender = getValueToRender(resultAndBindings);
+  const errorLocations = getErrorLocations(resultAndBindings.result);
+
   return (
     <SquiggleContainer>
-      <WrappedCodeEditor code={code} setCode={setCode} />
+      <WrappedCodeEditor
-      {result.tag !== "Ok" ? <SquiggleErrorAlert error={result.value} /> : null}
+        code={code}
+        setCode={setCode}
+        errorLocations={errorLocations}
+      />
+      <SquiggleViewer
+        result={valueToRender}
+        width={width}
+        height={height}
+        distributionPlotSettings={distributionPlotSettings}
+        chartSettings={chartSettings}
+        environment={environment ?? defaultEnvironment}
+        enableLocalSettings={enableLocalSettings}
+      />
     </SquiggleContainer>
   );
 };

packages/components/src/components/SquiggleEditorWithImportedBindings.tsx

@@ -1,52 +0,0 @@
-import React from "react";
-import { SquiggleEditor } from "./SquiggleEditor";
-import type { SquiggleEditorProps } from "./SquiggleEditor";
-import { runPartial, defaultBindings } from "@quri/squiggle-lang";
-import type {
-  result,
-  errorValue,
-  bindings as bindingsType,
-} from "@quri/squiggle-lang";
-
-function resultDefault(x: result<bindingsType, errorValue>): bindingsType {
-  switch (x.tag) {
-    case "Ok":
-      return x.value;
-    case "Error":
-      return defaultBindings;
-  }
-}
-
-export type SquiggleEditorWithImportedBindingsProps = SquiggleEditorProps & {
-  bindingsImportUrl: string;
-};
-
-export const SquiggleEditorWithImportedBindings: React.FC<
-  SquiggleEditorWithImportedBindingsProps
-> = (props) => {
-  const { bindingsImportUrl, ...editorProps } = props;
-  const [bindingsResult, setBindingsResult] = React.useState({
-    tag: "Ok",
-    value: defaultBindings,
-  } as result<bindingsType, errorValue>);
-  React.useEffect(() => {
-    async function retrieveBindings(fileName: string) {
-      let contents = await fetch(fileName).then((response) => {
-        return response.text();
-      });
-      setBindingsResult(
-        runPartial(
-          contents,
-          editorProps.bindings,
-          editorProps.environment,
-          editorProps.jsImports
-        )
-      );
-    }
-    retrieveBindings(bindingsImportUrl);
-  }, [bindingsImportUrl]);
-  const deliveredBindings = resultDefault(bindingsResult);
-  return (
-    <SquiggleEditor {...{ ...editorProps, bindings: deliveredBindings }} />
-  );
-};

packages/components/src/components/SquiggleErrorAlert.tsx

@@ -1,11 +1,44 @@
-import { errorValue, errorValueToString } from "@quri/squiggle-lang";
+import { SqError, SqFrame } from "@quri/squiggle-lang";
 import React from "react";
 import { ErrorAlert } from "./Alert";
 
 type Props = {
-  error: errorValue;
+  error: SqError;
+};
+
+const StackTraceFrame: React.FC<{ frame: SqFrame }> = ({ frame }) => {
+  const location = frame.location();
+  return (
+    <div>
+      {frame.name()}
+      {location
+        ? ` at line ${location.start.line}, column ${location.start.column}`
+        : ""}
+    </div>
+  );
+};
+
+const StackTrace: React.FC<Props> = ({ error }) => {
+  const frames = error.getFrameArray();
+  return frames.length ? (
+    <div>
+      <div className="font-medium">Stack trace:</div>
+      <div className="ml-4">
+        {frames.map((frame, i) => (
+          <StackTraceFrame frame={frame} key={i} />
+        ))}
+      </div>
+    </div>
+  ) : null;
 };
 
 export const SquiggleErrorAlert: React.FC<Props> = ({ error }) => {
-  return <ErrorAlert heading="Error">{errorValueToString(error)}</ErrorAlert>;
+  return (
+    <ErrorAlert heading="Error">
+      <div className="space-y-4">
+        <div>{error.toString()}</div>
+        <StackTrace error={error} />
+      </div>
+    </ErrorAlert>
+  );
 };

packages/components/src/components/SquigglePlayground.tsx

@@ -8,7 +8,11 @@ import React, {
 } from "react";
 import { useForm, UseFormRegister, useWatch } from "react-hook-form";
 import * as yup from "yup";
-import { useMaybeControlledValue, useRunnerState } from "../lib/hooks";
+import {
+  useMaybeControlledValue,
+  useRunnerState,
+  useSquiggle,
+} from "../lib/hooks";
 import { yupResolver } from "@hookform/resolvers/yup";
 import {
   ChartSquareBarIcon,
@@ -24,9 +28,9 @@ import {
 } from "@heroicons/react/solid";
 import clsx from "clsx";
 
-import { defaultBindings, environment } from "@quri/squiggle-lang";
+import { environment, SqProject } from "@quri/squiggle-lang";
 
-import { SquiggleChart, SquiggleChartProps } from "./SquiggleChart";
+import { SquiggleChartProps } from "./SquiggleChart";
 import { CodeEditor } from "./CodeEditor";
 import { JsonEditor } from "./JsonEditor";
 import { ErrorAlert, SuccessAlert } from "./Alert";
@@ -39,6 +43,9 @@ import { ViewSettings, viewSettingsSchema } from "./ViewSettings";
 import { HeadedSection } from "./ui/HeadedSection";
 import { defaultTickFormat } from "../lib/distributionSpecBuilder";
 import { Button } from "./ui/Button";
+import { JsImports } from "../lib/jsImports";
+import { getErrorLocations, getValueToRender } from "../lib/utility";
+import { SquiggleViewer } from "./SquiggleViewer";
 
 type PlaygroundProps = SquiggleChartProps & {
   /** The initial squiggle string to put in the playground */
@@ -112,8 +119,8 @@ const SamplingSettings: React.FC<{ register: UseFormRegister<FormFields> }> = ({
 );
 
 const InputVariablesSettings: React.FC<{
-  initialImports: any; // TODO - any json type
+  initialImports: JsImports;
-  setImports: (imports: any) => void;
+  setImports: (imports: JsImports) => void;
 }> = ({ initialImports, setImports }) => {
   const [importString, setImportString] = useState(() =>
     JSON.stringify(initialImports)
@@ -122,7 +129,7 @@ const InputVariablesSettings: React.FC<{
 
   const onChange = (value: string) => {
     setImportString(value);
-    let imports = {} as any;
+    let imports = {};
     try {
       imports = JSON.parse(value);
       setImportsAreValid(true);
@@ -175,7 +182,7 @@ const RunControls: React.FC<{
   const CurrentPlayIcon = isRunning ? RefreshIcon : PlayIcon;
 
   return (
-    <div className="flex space-x-1 items-center">
+    <div className="flex space-x-1 items-center" data-testid="autorun-controls">
       {autorunMode ? null : (
         <button onClick={run}>
           <CurrentPlayIcon
@@ -244,6 +251,8 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
   onSettingsChange,
   showEditor = true,
   showShareButton = false,
+  continues,
+  project,
 }) => {
   const [code, setCode] = useMaybeControlledValue({
     value: controlledCode,
@@ -251,7 +260,7 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
     onChange: onCodeChange,
   });
 
-  const [imports, setImports] = useState({});
+  const [imports, setImports] = useState<JsImports>({});
 
   const { register, control } = useForm({
     resolver: yupResolver(schema),
@@ -281,7 +290,7 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
     onSettingsChange?.(vars);
   }, [vars, onSettingsChange]);
 
-  const env: environment = useMemo(
+  const environment: environment = useMemo(
     () => ({
       sampleCount: Number(vars.sampleCount),
       xyPointLength: Number(vars.xyPointLength),
@@ -298,27 +307,53 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
     executionId,
   } = useRunnerState(code);
 
+  const resultAndBindings = useSquiggle({
+    environment,
+    continues,
+    code: renderedCode,
+    project,
+    jsImports: imports,
+    executionId,
+  });
+
+  const valueToRender = getValueToRender(resultAndBindings);
+
   const squiggleChart =
     renderedCode === "" ? null : (
       <div className="relative">
         {isRunning ? (
           <div className="absolute inset-0 bg-white opacity-0 animate-semi-appear" />
         ) : null}
-        <SquiggleChart
+        <SquiggleViewer
-          code={renderedCode}
+          result={valueToRender}
-          executionId={executionId}
+          environment={environment}
-          environment={env}
+          height={vars.chartHeight || 150}
-          {...vars}
+          distributionPlotSettings={{
-          bindings={defaultBindings}
+            showSummary: vars.showSummary ?? false,
-          jsImports={imports}
+            logX: vars.logX ?? false,
+            expY: vars.expY ?? false,
+            format: vars.tickFormat,
+            minX: vars.minX,
+            maxX: vars.maxX,
+            title: vars.title,
+            actions: vars.distributionChartActions,
+          }}
+          chartSettings={{
+            start: vars.diagramStart ?? 0,
+            stop: vars.diagramStop ?? 10,
+            count: vars.diagramCount ?? 20,
+          }}
           enableLocalSettings={true}
         />
       </div>
     );
 
+  const errorLocations = getErrorLocations(resultAndBindings.result);
+
   const firstTab = vars.showEditor ? (
-    <div className="border border-slate-200">
+    <div className="border border-slate-200" data-testid="squiggle-editor">
       <CodeEditor
+        errorLocations={errorLocations}
         value={code}
         onChange={setCode}
         onSubmit={run}
@@ -368,7 +403,9 @@ export const SquigglePlayground: FC<PlaygroundProps> = ({
       >
         {tabs}
       </div>
-      <div className="w-1/2 p-2 pl-4">{squiggleChart}</div>
+      <div className="w-1/2 p-2 pl-4" data-testid="playground-result">
+        {squiggleChart}
+      </div>
     </div>
   );
 

packages/components/src/components/SquiggleViewer/ExpressionViewer.tsx

@@ -1,14 +1,17 @@
-import React from "react";
+import React, { useContext } from "react";
-import { squiggleExpression, declaration } from "@quri/squiggle-lang";
+import { SqDistributionTag, SqValue, SqValueTag } from "@quri/squiggle-lang";
 import { NumberShower } from "../NumberShower";
 import { DistributionChart, defaultPlot, makePlot } from "../DistributionChart";
-import { FunctionChart, FunctionChartSettings } from "../FunctionChart";
+import { FunctionChart } from "../FunctionChart";
 import clsx from "clsx";
 import { VariableBox } from "./VariableBox";
 import { ItemSettingsMenu } from "./ItemSettingsMenu";
 import { hasMassBelowZero } from "../../lib/distributionUtils";
 import { MergedItemSettings } from "./utils";
+import { ViewerContext } from "./ViewerContext";
 
+/*
+// DISABLED FOR 0.4 branch, for now
 function getRange<a>(x: declaration<a>) {
   const first = x.args[0];
   switch (first.tag) {
@@ -31,15 +34,21 @@ function getChartSettings<a>(x: declaration<a>): FunctionChartSettings {
     count: 20,
   };
 }
+*/
 
 const VariableList: React.FC<{
-  path: string[];
+  value: SqValue;
   heading: string;
   children: (settings: MergedItemSettings) => React.ReactNode;
-}> = ({ path, heading, children }) => (
+}> = ({ value, heading, children }) => (
-  <VariableBox path={path} heading={heading}>
+  <VariableBox value={value} heading={heading}>
     {(settings) => (
-      <div className={clsx("space-y-3", path.length ? "pt-1 mt-1" : null)}>
+      <div
+        className={clsx(
+          "space-y-3",
+          value.location.path.items.length ? "pt-1 mt-1" : null
+        )}
+      >
         {children(settings)}
       </div>
     )}
@@ -48,51 +57,44 @@ const VariableList: React.FC<{
 
 export interface Props {
   /** The output of squiggle's run */
-  expression: squiggleExpression;
+  value: SqValue;
-  /** Path to the current item, e.g. `['foo', 'bar', '3']` for `foo.bar[3]`; can be empty on the top-level item. */
-  path: string[];
   width?: number;
 }
 
-export const ExpressionViewer: React.FC<Props> = ({
+export const ExpressionViewer: React.FC<Props> = ({ value, width }) => {
-  path,
+  const { getMergedSettings } = useContext(ViewerContext);
-  expression,
+
-  width,
+  switch (value.tag) {
-}) => {
+    case SqValueTag.Number:
-  if (typeof expression !== "object") {
-    return (
-      <VariableList path={path} heading="Error">
-        {() => `Unknown expression: ${expression}`}
-      </VariableList>
-    );
-  }
-  switch (expression.tag) {
-    case "number":
       return (
-        <VariableBox path={path} heading="Number">
+        <VariableBox value={value} heading="Number">
           {() => (
             <div className="font-semibold text-slate-600">
-              <NumberShower precision={3} number={expression.value} />
+              <NumberShower precision={3} number={value.value} />
             </div>
           )}
         </VariableBox>
       );
-    case "distribution": {
+    case SqValueTag.Distribution: {
-      const distType = expression.value.type();
+      const distType = value.value.tag;
       return (
         <VariableBox
-          path={path}
+          value={value}
           heading={`Distribution (${distType})\n${
-            distType === "Symbolic" ? expression.value.toString() : ""
+            distType === SqDistributionTag.Symbolic
+              ? value.value.toString()
+              : ""
           }`}
           renderSettingsMenu={({ onChange }) => {
-            const shape = expression.value.pointSet();
+            const shape = value.value.pointSet(
+              getMergedSettings(value.location).environment
+            );
             return (
               <ItemSettingsMenu
-                path={path}
+                value={value}
                 onChange={onChange}
                 disableLogX={
-                  shape.tag === "Ok" && hasMassBelowZero(shape.value)
+                  shape.tag === "Ok" && hasMassBelowZero(shape.value.asShape())
                 }
                 withFunctionSettings={false}
               />
@@ -102,7 +104,8 @@ export const ExpressionViewer: React.FC<Props> = ({
           {(settings) => {
             return (
               <DistributionChart
-                plot={defaultPlot(expression.value)}
+                plot={defaultPlot(value.value)}
+                environment={settings.environment}
                 {...settings.distributionPlotSettings}
                 height={settings.height}
                 width={width}
@@ -112,77 +115,54 @@ export const ExpressionViewer: React.FC<Props> = ({
         </VariableBox>
       );
     }
-    case "string":
+    case SqValueTag.String:
       return (
-        <VariableBox path={path} heading="String">
+        <VariableBox value={value} heading="String">
           {() => (
             <>
               <span className="text-slate-400">"</span>
               <span className="text-slate-600 font-semibold font-mono">
-                {expression.value}
+                {value.value}
               </span>
               <span className="text-slate-400">"</span>
             </>
           )}
         </VariableBox>
       );
-    case "boolean":
+    case SqValueTag.Bool:
       return (
-        <VariableBox path={path} heading="Boolean">
+        <VariableBox value={value} heading="Boolean">
-          {() => expression.value.toString()}
+          {() => value.value.toString()}
         </VariableBox>
       );
-    case "symbol":
+    case SqValueTag.Date:
       return (
-        <VariableBox path={path} heading="Symbol">
+        <VariableBox value={value} heading="Date">
-          {() => (
+          {() => value.value.toDateString()}
-            <>
-              <span className="text-slate-500 mr-2">Undefined Symbol:</span>
-              <span className="text-slate-600">{expression.value}</span>
-            </>
-          )}
         </VariableBox>
       );
-    case "call":
+    case SqValueTag.Void:
       return (
-        <VariableBox path={path} heading="Call">
+        <VariableBox value={value} heading="Void">
-          {() => expression.value}
-        </VariableBox>
-      );
-    case "arraystring":
-      return (
-        <VariableBox path={path} heading="Array String">
-          {() => expression.value.map((r) => `"${r}"`).join(", ")}
-        </VariableBox>
-      );
-    case "date":
-      return (
-        <VariableBox path={path} heading="Date">
-          {() => expression.value.toDateString()}
-        </VariableBox>
-      );
-    case "void":
-      return (
-        <VariableBox path={path} heading="Void">
           {() => "Void"}
         </VariableBox>
       );
-    case "timeDuration": {
+    case SqValueTag.TimeDuration: {
       return (
-        <VariableBox path={path} heading="Time Duration">
+        <VariableBox value={value} heading="Time Duration">
-          {() => <NumberShower precision={3} number={expression.value} />}
+          {() => <NumberShower precision={3} number={value.value} />}
         </VariableBox>
       );
     }
-    case "lambda":
+    case SqValueTag.Lambda:
       return (
         <VariableBox
-          path={path}
+          value={value}
           heading="Function"
           renderSettingsMenu={({ onChange }) => {
             return (
               <ItemSettingsMenu
-                path={path}
+                value={value}
                 onChange={onChange}
                 withFunctionSettings={true}
               />
@@ -191,11 +171,11 @@ export const ExpressionViewer: React.FC<Props> = ({
         >
           {(settings) => (
             <>
-              <div className="text-amber-700 bg-amber-100 rounded-md font-mono p-1 pl-2 mb-3 mt-1 text-sm">{`function(${expression.value.parameters.join(
+              <div className="text-amber-700 bg-amber-100 rounded-md font-mono p-1 pl-2 mb-3 mt-1 text-sm">{`function(${value.value
-                ","
+                .parameters()
-              )})`}</div>
+                .join(",")})`}</div>
               <FunctionChart
-                fn={expression.value}
+                fn={value.value}
                 chartSettings={settings.chartSettings}
                 distributionPlotSettings={settings.distributionPlotSettings}
                 height={settings.height}
@@ -208,71 +188,57 @@ export const ExpressionViewer: React.FC<Props> = ({
           )}
         </VariableBox>
       );
-    case "lambdaDeclaration": {
+    case SqValueTag.Declaration: {
       return (
         <VariableBox
-          path={path}
+          value={value}
           heading="Function Declaration"
           renderSettingsMenu={({ onChange }) => {
             return (
               <ItemSettingsMenu
                 onChange={onChange}
-                path={path}
+                value={value}
                 withFunctionSettings={true}
               />
             );
           }}
         >
           {(settings) => (
-            <FunctionChart
+            <div>NOT IMPLEMENTED IN 0.4 YET</div>
-              fn={expression.value.fn}
+            // <FunctionChart
-              chartSettings={getChartSettings(expression.value)}
+            //   fn={expression.value.fn}
-              distributionPlotSettings={settings.distributionPlotSettings}
+            //   chartSettings={getChartSettings(expression.value)}
-              height={settings.height}
+            //   distributionPlotSettings={settings.distributionPlotSettings}
-              environment={{
+            //   height={settings.height}
-                sampleCount: settings.environment.sampleCount / 10,
+            //   environment={{
-                xyPointLength: settings.environment.xyPointLength / 10,
+            //     sampleCount: settings.environment.sampleCount / 10,
-              }}
+            //     xyPointLength: settings.environment.xyPointLength / 10,
-            />
+            //   }}
+            // />
           )}
         </VariableBox>
       );
     }
-    case "module": {
+    case SqValueTag.Record:
-      return (
+      const plot = makePlot(value.value);
-        <VariableList path={path} heading="Module">
-          {(_) =>
-            Object.entries(expression.value)
-              .filter(([key, _]) => !key.match(/^(Math|System)\./))
-              .map(([key, r]) => (
-                <ExpressionViewer
-                  key={key}
-                  path={[...path, key]}
-                  expression={r}
-                  width={width !== undefined ? width - 20 : width}
-                />
-              ))
-          }
-        </VariableList>
-      );
-    }
-    case "record":
-      const plot = makePlot(expression.value);
       if (plot) {
         return (
           <VariableBox
-            path={path}
+            value={value}
-            heading={"Plot"}
+            heading="Plot"
             renderSettingsMenu={({ onChange }) => {
               let disableLogX = plot.distributions.some((x) => {
-                let pointSet = x.distribution.pointSet();
+                let pointSet = x.distribution.pointSet(
+                  getMergedSettings(value.location).environment
+                );
                 return (
-                  pointSet.tag === "Ok" && hasMassBelowZero(pointSet.value)
+                  pointSet.tag === "Ok" &&
+                  hasMassBelowZero(pointSet.value.asShape())
                 );
               });
               return (
                 <ItemSettingsMenu
-                  path={path}
+                  value={value}
                   onChange={onChange}
                   disableLogX={disableLogX}
                   withFunctionSettings={false}
@@ -284,6 +250,7 @@ export const ExpressionViewer: React.FC<Props> = ({
               return (
                 <DistributionChart
                   plot={plot}
+                  environment={settings.environment}
                   {...settings.distributionPlotSettings}
                   height={settings.height}
                   width={width}
@@ -294,43 +261,45 @@ export const ExpressionViewer: React.FC<Props> = ({
         );
       } else {
         return (
-          <VariableList path={path} heading="Record">
+          <VariableList value={value} heading="Record">
             {(_) =>
-              Object.entries(expression.value).map(([key, r]) => (
+              value.value
-                <ExpressionViewer
+                .entries()
-                  key={key}
+                .map(([key, r]) => (
-                  path={[...path, key]}
+                  <ExpressionViewer
-                  expression={r}
+                    key={key}
-                  width={width !== undefined ? width - 20 : width}
+                    value={r}
-                />
+                    width={width !== undefined ? width - 20 : width}
-              ))
+                  />
+                ))
             }
           </VariableList>
         );
       }
-    case "array":
+    case SqValueTag.Array:
       return (
-        <VariableList path={path} heading="Array">
+        <VariableList value={value} heading="Array">
           {(_) =>
-            expression.value.map((r, i) => (
+            value.value
-              <ExpressionViewer
+              .getValues()
-                key={i}
+              .map((r, i) => (
-                path={[...path, String(i)]}
+                <ExpressionViewer
-                expression={r}
+                  key={i}
-                width={width !== undefined ? width - 20 : width}
+                  value={r}
-              />
+                  width={width !== undefined ? width - 20 : width}
-            ))
+                />
+              ))
           }
         </VariableList>
       );
     default: {
       return (
-        <VariableList path={path} heading="Error">
+        <VariableList value={value} heading="Error">
           {() => (
             <div>
               <span>No display for type: </span>{" "}
               <span className="font-semibold text-slate-600">
-                {expression.tag}
+                {(value as { tag: string }).tag}
               </span>
             </div>
           )}

packages/components/src/components/SquiggleViewer/ItemSettingsMenu.tsx

@@ -4,13 +4,14 @@ import { useForm } from "react-hook-form";
 import { yupResolver } from "@hookform/resolvers/yup";
 import { Modal } from "../ui/Modal";
 import { ViewSettings, viewSettingsSchema } from "../ViewSettings";
-import { Path, pathAsString } from "./utils";
 import { ViewerContext } from "./ViewerContext";
 import { defaultTickFormat } from "../../lib/distributionSpecBuilder";
 import { PlaygroundContext } from "../SquigglePlayground";
+import { SqValue } from "@quri/squiggle-lang";
+import { locationAsString } from "./utils";
 
 type Props = {
-  path: Path;
+  value: SqValue;
   onChange: () => void;
   disableLogX?: boolean;
   withFunctionSettings: boolean;
@@ -19,7 +20,7 @@ type Props = {
 const ItemSettingsModal: React.FC<
   Props & { close: () => void; resetScroll: () => void }
 > = ({
-  path,
+  value,
   onChange,
   disableLogX,
   withFunctionSettings,
@@ -29,7 +30,7 @@ const ItemSettingsModal: React.FC<
   const { setSettings, getSettings, getMergedSettings } =
     useContext(ViewerContext);
 
-  const mergedSettings = getMergedSettings(path);
+  const mergedSettings = getMergedSettings(value.location);
 
   const { register, watch } = useForm({
     resolver: yupResolver(viewSettingsSchema),
@@ -53,8 +54,8 @@ const ItemSettingsModal: React.FC<
   });
   useEffect(() => {
     const subscription = watch((vars) => {
-      const settings = getSettings(path); // get the latest version
+      const settings = getSettings(value.location); // get the latest version
-      setSettings(path, {
+      setSettings(value.location, {
         ...settings,
         distributionPlotSettings: {
           showSummary: vars.showSummary,
@@ -75,7 +76,7 @@ const ItemSettingsModal: React.FC<
       onChange();
     });
     return () => subscription.unsubscribe();
-  }, [getSettings, setSettings, onChange, path, watch]);
+  }, [getSettings, setSettings, onChange, value.location, watch]);
 
   const { getLeftPanelElement } = useContext(PlaygroundContext);
 
@@ -83,7 +84,7 @@ const ItemSettingsModal: React.FC<
     <Modal container={getLeftPanelElement()} close={close}>
       <Modal.Header>
         Chart settings
-        {path.length ? (
+        {value.location.path.items.length ? (
           <>
             {" for "}
             <span
@@ -91,7 +92,7 @@ const ItemSettingsModal: React.FC<
               className="cursor-pointer"
               onClick={resetScroll}
             >
-              {pathAsString(path)}
+              {locationAsString(value.location)}
             </span>{" "}
           </>
         ) : (
@@ -120,7 +121,7 @@ export const ItemSettingsMenu: React.FC<Props> = (props) => {
   if (!enableLocalSettings) {
     return null;
   }
-  const settings = getSettings(props.path);
+  const settings = getSettings(props.value.location);
 
   const resetScroll = () => {
     if (!ref.current) return;
@@ -139,7 +140,7 @@ export const ItemSettingsMenu: React.FC<Props> = (props) => {
       {settings.distributionPlotSettings || settings.chartSettings ? (
         <button
           onClick={() => {
-            setSettings(props.path, {
+            setSettings(props.value.location, {
               ...settings,
               distributionPlotSettings: undefined,
               chartSettings: undefined,

packages/components/src/components/SquiggleViewer/VariableBox.tsx

@@ -1,3 +1,4 @@
+import { SqValue } from "@quri/squiggle-lang";
 import React, { useContext, useReducer } from "react";
 import { Tooltip } from "../ui/Tooltip";
 import { LocalItemSettings, MergedItemSettings } from "./utils";
@@ -8,14 +9,14 @@ type SettingsMenuParams = {
 };
 
 type VariableBoxProps = {
-  path: string[];
+  value: SqValue;
   heading: string;
   renderSettingsMenu?: (params: SettingsMenuParams) => React.ReactNode;
   children: (settings: MergedItemSettings) => React.ReactNode;
 };
 
 export const VariableBox: React.FC<VariableBoxProps> = ({
-  path,
+  value: { location },
   heading = "Error",
   renderSettingsMenu,
   children,
@@ -27,10 +28,10 @@ export const VariableBox: React.FC<VariableBoxProps> = ({
   // So we use `forceUpdate` to force rerendering.
   const [_, forceUpdate] = useReducer((x) => x + 1, 0);
 
-  const settings = getSettings(path);
+  const settings = getSettings(location);
 
   const setSettingsAndUpdate = (newSettings: LocalItemSettings) => {
-    setSettings(path, newSettings);
+    setSettings(location, newSettings);
     forceUpdate();
   };
 
@@ -38,11 +39,13 @@ export const VariableBox: React.FC<VariableBoxProps> = ({
     setSettingsAndUpdate({ ...settings, collapsed: !settings.collapsed });
   };
 
-  const isTopLevel = path.length === 0;
+  const isTopLevel = location.path.items.length === 0;
-  const name = isTopLevel ? "Result" : path[path.length - 1];
+  const name = isTopLevel
+    ? { result: "Result", bindings: "Bindings" }[location.path.root]
+    : location.path.items[location.path.items.length - 1];
 
   return (
-    <div>
+    <div role={isTopLevel ? "status" : undefined}>
       <header className="inline-flex space-x-1">
         <Tooltip text={heading}>
           <span
@@ -65,13 +68,13 @@ export const VariableBox: React.FC<VariableBoxProps> = ({
       </header>
       {settings.collapsed ? null : (
         <div className="flex w-full">
-          {path.length ? (
+          {location.path.items.length ? (
             <div
-              className="border-l-2 border-slate-200 hover:border-indigo-600 w-4 cursor-pointer"
+              className="shrink-0 border-l-2 border-slate-200 hover:border-indigo-600 w-4 cursor-pointer"
               onClick={toggleCollapsed}
             ></div>
           ) : null}
-          <div className="grow">{children(getMergedSettings(path))}</div>
+          <div className="grow">{children(getMergedSettings(location))}</div>
         </div>
       )}
     </div>

packages/components/src/components/SquiggleViewer/ViewerContext.ts

@@ -1,14 +1,14 @@
-import { defaultEnvironment } from "@quri/squiggle-lang";
+import { defaultEnvironment, SqValueLocation } from "@quri/squiggle-lang";
 import React from "react";
-import { LocalItemSettings, MergedItemSettings, Path } from "./utils";
+import { LocalItemSettings, MergedItemSettings } from "./utils";
 
 type ViewerContextShape = {
   // Note that we don't store settings themselves in the context (that would cause rerenders of the entire tree on each settings update).
   // Instead, we keep settings in local state and notify the global context via setSettings to pass them down the component tree again if it got rebuilt from scratch.
   // See ./SquiggleViewer.tsx and ./VariableBox.tsx for other implementation details on this.
-  getSettings(path: Path): LocalItemSettings;
+  getSettings(location: SqValueLocation): LocalItemSettings;
-  getMergedSettings(path: Path): MergedItemSettings;
+  getMergedSettings(location: SqValueLocation): MergedItemSettings;
-  setSettings(path: Path, value: LocalItemSettings): void;
+  setSettings(location: SqValueLocation, value: LocalItemSettings): void;
   enableLocalSettings: boolean; // show local settings icon in the UI
 };
 

packages/components/src/components/SquiggleViewer/index.tsx

@@ -1,21 +1,20 @@
 import React, { useCallback, useRef } from "react";
-import { environment } from "@quri/squiggle-lang";
+import { environment, SqValueLocation } from "@quri/squiggle-lang";
 import { DistributionPlottingSettings } from "../DistributionChart";
 import { FunctionChartSettings } from "../FunctionChart";
 import { ExpressionViewer } from "./ExpressionViewer";
 import { ViewerContext } from "./ViewerContext";
 import {
   LocalItemSettings,
+  locationAsString,
   MergedItemSettings,
-  Path,
-  pathAsString,
 } from "./utils";
 import { useSquiggle } from "../../lib/hooks";
 import { SquiggleErrorAlert } from "../SquiggleErrorAlert";
 
 type Props = {
   /** The output of squiggle's run */
-  result: ReturnType<typeof useSquiggle>;
+  result: ReturnType<typeof useSquiggle>["result"];
   width?: number;
   height: number;
   distributionPlotSettings: DistributionPlottingSettings;
@@ -45,22 +44,22 @@ export const SquiggleViewer: React.FC<Props> = ({
   const settingsRef = useRef<Settings>({});
 
   const getSettings = useCallback(
-    (path: Path) => {
+    (location: SqValueLocation) => {
-      return settingsRef.current[pathAsString(path)] || defaultSettings;
+      return settingsRef.current[locationAsString(location)] || defaultSettings;
     },
     [settingsRef]
   );
 
   const setSettings = useCallback(
-    (path: Path, value: LocalItemSettings) => {
+    (location: SqValueLocation, value: LocalItemSettings) => {
-      settingsRef.current[pathAsString(path)] = value;
+      settingsRef.current[locationAsString(location)] = value;
     },
     [settingsRef]
   );
 
   const getMergedSettings = useCallback(
-    (path: Path) => {
+    (location: SqValueLocation) => {
-      const localSettings = getSettings(path);
+      const localSettings = getSettings(location);
       const result: MergedItemSettings = {
         distributionPlotSettings: {
           ...distributionPlotSettings,
@@ -91,7 +90,7 @@ export const SquiggleViewer: React.FC<Props> = ({
       }}
     >
       {result.tag === "Ok" ? (
-        <ExpressionViewer path={[]} expression={result.value} width={width} />
+        <ExpressionViewer value={result.value} width={width} />
       ) : (
         <SquiggleErrorAlert error={result.value} />
       )}

packages/components/src/components/SquiggleViewer/utils.ts

@@ -1,6 +1,6 @@
 import { DistributionPlottingSettings } from "../DistributionChart";
 import { FunctionChartSettings } from "../FunctionChart";
-import { environment } from "@quri/squiggle-lang";
+import { environment, SqValueLocation } from "@quri/squiggle-lang";
 
 export type LocalItemSettings = {
   collapsed: boolean;
@@ -17,6 +17,5 @@ export type MergedItemSettings = {
   environment: environment;
 };
 
-export type Path = string[];
+export const locationAsString = (location: SqValueLocation) =>
-
+  location.path.items.join(".");
-export const pathAsString = (path: Path) => path.join(".");

packages/components/src/index.ts

@@ -1,7 +1,5 @@
+export { SqProject } from "@quri/squiggle-lang/";
 export { SquiggleChart } from "./components/SquiggleChart";
-export { SquiggleEditor, SquigglePartial } from "./components/SquiggleEditor";
+export { SquiggleEditor } from "./components/SquiggleEditor";
 export { SquigglePlayground } from "./components/SquigglePlayground";
 export { SquiggleContainer } from "./components/SquiggleContainer";
-export { SquiggleEditorWithImportedBindings } from "./components/SquiggleEditorWithImportedBindings";
-
-export { mergeBindings } from "@quri/squiggle-lang";

packages/components/src/lib/distributionSpecBuilder.ts

@@ -1,5 +1,5 @@
 import { VisualizationSpec } from "react-vega";
-import type { LogScale, LinearScale, PowScale } from "vega";
+import type { LogScale, LinearScale, PowScale, TimeScale } from "vega";
 
 export type DistributionChartSpecOptions = {
   /** Set the x scale to be logarithmic by deault */
@@ -14,26 +14,21 @@ export type DistributionChartSpecOptions = {
   title?: string;
   /** The formatting of the ticks */
   format?: string;
+  /** Whether the x-axis should be dates or numbers */
+  xAxisType?: "number" | "dateTime";
 };
 
-export let linearXScale: LinearScale = {
+/** X Scales */
+export const linearXScale: LinearScale = {
   name: "xscale",
   clamp: true,
   type: "linear",
   range: "width",
   zero: false,
   nice: false,
-  domain: { data: "domain", field: "x" },
-};
-export let linearYScale: LinearScale = {
-  name: "yscale",
-  type: "linear",
-  range: "height",
-  zero: true,
-  domain: { data: "domain", field: "y" },
 };
 
-export let logXScale: LogScale = {
+export const logXScale: LogScale = {
   name: "xscale",
   type: "log",
   range: "width",
@@ -41,60 +36,104 @@ export let logXScale: LogScale = {
   base: 10,
   nice: false,
   clamp: true,
-  domain: { data: "domain", field: "x" },
 };
 
-export let expYScale: PowScale = {
+export const timeXScale: TimeScale = {
+  name: "xscale",
+  clamp: true,
+  type: "time",
+  range: "width",
+  nice: false,
+};
+
+/** Y Scales */
+export const linearYScale: LinearScale = {
+  name: "yscale",
+  type: "linear",
+  range: "height",
+  zero: true,
+};
+
+export const expYScale: PowScale = {
   name: "yscale",
   type: "pow",
   exponent: 0.1,
   range: "height",
   zero: true,
   nice: false,
-  domain: { data: "domain", field: "y" },
 };
 
 export const defaultTickFormat = ".9~s";
+export const timeTickFormat = "%b %d, %Y %H:%M";
+const width = 500;
 
 export function buildVegaSpec(
-  specOptions: DistributionChartSpecOptions
+  specOptions: DistributionChartSpecOptions & { maxY: number }
 ): VisualizationSpec {
   const {
-    format = defaultTickFormat,
     title,
     minX,
     maxX,
     logX,
     expY,
+    xAxisType = "number",
+    maxY,
   } = specOptions;
 
-  let xScale = logX ? logXScale : linearXScale;
+  const dateTime = xAxisType === "dateTime";
-  if (minX !== undefined && Number.isFinite(minX)) {
-    xScale = { ...xScale, domainMin: minX };
-  }
 
-  if (maxX !== undefined && Number.isFinite(maxX)) {
+  // some fallbacks
-    xScale = { ...xScale, domainMax: maxX };
+  const format = specOptions?.format
-  }
+    ? specOptions.format
+    : dateTime
+    ? timeTickFormat
+    : defaultTickFormat;
 
-  let spec: VisualizationSpec = {
+  let xScale = dateTime ? timeXScale : logX ? logXScale : linearXScale;
+
+  xScale = {
+    ...xScale,
+    domain: [minX ?? 0, maxX ?? 1],
+    domainMin: minX,
+    domainMax: maxX,
+  };
+
+  let yScale = expY ? expYScale : linearYScale;
+  yScale = { ...yScale, domain: [0, maxY ?? 1], domainMin: 0, domainMax: maxY };
+
+  const spec: VisualizationSpec = {
     $schema: "https://vega.github.io/schema/vega/v5.json",
     description: "Squiggle plot chart",
-    width: 500,
+    width: width,
     height: 100,
     padding: 5,
-    data: [
+    data: [{ name: "data" }, { name: "domain" }, { name: "samples" }],
+    signals: [
       {
-        name: "data",
+        name: "hover",
+        value: null,
+        on: [
+          { events: "mouseover", update: "datum" },
+          { events: "mouseout", update: "null" },
+        ],
       },
       {
-        name: "domain",
+        name: "position",
+        value: "[0, 0]",
+        on: [
+          { events: "mousemove", update: "xy() " },
+          { events: "mouseout", update: "null" },
+        ],
+      },
+      {
+        name: "position_scaled",
+        value: null,
+        update: "isArray(position) ? invert('xscale', position[0]) : ''",
       },
     ],
-    signals: [],
     scales: [
       xScale,
-      expY ? expYScale : linearYScale,
+      yScale,
       {
         name: "color",
         type: "ordinal",
@@ -115,7 +154,7 @@ export function buildVegaSpec(
         domainColor: "#fff",
         domainOpacity: 0.0,
         format: format,
-        tickCount: 10,
+        tickCount: dateTime ? 3 : 10,
         labelOverlap: "greedy",
       },
     ],
@@ -232,13 +271,16 @@ export function buildVegaSpec(
                     },
                     size: [{ value: 100 }],
                     tooltip: {
-                      signal: "{ probability: datum.y, value: datum.x }",
+                      signal: dateTime
+                        ? "{ probability: datum.y, value: datetime(datum.x) }"
+                        : "{ probability: datum.y, value: datum.x }",
                     },
                   },
                   update: {
                     x: {
                       scale: "xscale",
                       field: "x",
+                      offset: 0.5, // if this is not included, the circles are slightly left of center.
                     },
                     y: {
                       scale: "yscale",
@@ -255,6 +297,69 @@ export function buildVegaSpec(
           },
         ],
       },
+
+      {
+        name: "sampleset",
+        type: "rect",
+        from: { data: "samples" },
+        encode: {
+          enter: {
+            x: { scale: "xscale", field: "data" },
+            width: { value: 0.1 },
+
+            y: { value: 25, offset: { signal: "height" } },
+            height: { value: 5 },
+          },
+        },
+      },
+      {
+        type: "text",
+        name: "announcer",
+        interactive: false,
+        encode: {
+          enter: {
+            x: { signal: String(width), offset: 1 }, // vega would prefer its internal ` "width" ` variable, but that breaks the squiggle playground. Just setting it to the same var as used elsewhere in the spec achieves the same result.
+            fill: { value: "black" },
+            fontSize: { value: 20 },
+            align: { value: "right" },
+          },
+          update: {
+            text: {
+              signal: dateTime
+                ? "position_scaled ? utcyear(position_scaled) + '-' + utcmonth(position_scaled) + '-' + utcdate(position_scaled) + 'T' + utchours(position_scaled)+':' +utcminutes(position_scaled) : ''"
+                : "position_scaled ? format(position_scaled, ',.4r')  : ''",
+            },
+          },
+        },
+      },
+      {
+        type: "rule",
+        interactive: false,
+        encode: {
+          enter: {
+            x: { value: 0 },
+            y: { scale: "yscale", value: 0 },
+
+            y2: {
+              signal: "height",
+              offset: 2,
+            },
+            strokeDash: { value: [5, 5] },
+          },
+
+          update: {
+            x: {
+              signal:
+                "position ? position[0] < 0 ? null : position[0] > width ? null : position[0]: null",
+            },
+
+            opacity: {
+              signal:
+                "position ? position[0] < 0 ? 0 : position[0] > width ? 0 : 1 : 0",
+            },
+          },
+        },
+      },
     ],
     legends: [
       {

packages/components/src/lib/distributionUtils.ts

@@ -1,5 +1,5 @@
-import { shape } from "@quri/squiggle-lang";
+import { SqShape } from "@quri/squiggle-lang";
 
-export const hasMassBelowZero = (shape: shape) =>
+export const hasMassBelowZero = (shape: SqShape) =>
   shape.continuous.some((x) => x.x <= 0) ||
   shape.discrete.some((x) => x.x <= 0);

packages/components/src/lib/hooks/index.ts

@@ -1,3 +1,3 @@
 export { useMaybeControlledValue } from "./useMaybeControlledValue";
-export { useSquiggle, useSquigglePartial } from "./useSquiggle";
+export { useSquiggle } from "./useSquiggle";
 export { useRunnerState } from "./useRunnerState";

packages/components/src/lib/hooks/useSquiggle.ts

@@ -1,53 +1,97 @@
 import {
-  bindings,
+  result,
+  SqError,
+  SqProject,
+  SqRecord,
+  SqValue,
   environment,
-  jsImports,
-  run,
-  runPartial,
 } from "@quri/squiggle-lang";
 import { useEffect, useMemo } from "react";
+import { JsImports, jsImportsToSquiggleCode } from "../jsImports";
+import * as uuid from "uuid";
 
-type SquiggleArgs<T extends ReturnType<typeof run | typeof runPartial>> = {
+type SquiggleArgs = {
+  environment?: environment;
   code: string;
   executionId?: number;
-  bindings?: bindings;
+  jsImports?: JsImports;
-  jsImports?: jsImports;
+  project?: SqProject;
-  environment?: environment;
+  continues?: string[];
-  onChange?: (expr: Extract<T, { tag: "Ok" }>["value"] | undefined) => void;
+  onChange?: (expr: SqValue | undefined, sourceName: string) => void;
 };
 
-const useSquiggleAny = <T extends ReturnType<typeof run | typeof runPartial>>(
+export type ResultAndBindings = {
-  args: SquiggleArgs<T>,
+  result: result<SqValue, SqError>;
-  f: (...args: Parameters<typeof run>) => T
+  bindings: SqRecord;
-) => {
+};
-  const result: T = useMemo<T>(
+
-    () => f(args.code, args.bindings, args.environment, args.jsImports),
+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 continues = args.continues || defaultContinues;
+
+  const result = useMemo(
+    () => {
+      project.setSource(sourceName, args.code);
+      let fullContinues = continues;
+      if (args.jsImports && Object.keys(args.jsImports).length) {
+        const importsSource = jsImportsToSquiggleCode(args.jsImports);
+        project.setSource(importSourceName(sourceName), importsSource);
+        fullContinues = continues.concat(importSourceName(sourceName));
+      }
+      project.setContinues(sourceName, fullContinues);
+      project.run(sourceName);
+      const result = project.getResult(sourceName);
+      const bindings = project.getBindings(sourceName);
+      return { result, bindings };
+    },
+    // This complains about executionId not being used inside the function body.
+    // This is on purpose, as executionId simply allows you to run the squiggle
+    // code again
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [
-      f,
       args.code,
-      args.bindings,
-      args.environment,
       args.jsImports,
       args.executionId,
+      sourceName,
+      continues,
+      project,
+      env,
     ]
   );
 
   const { onChange } = args;
 
   useEffect(() => {
-    onChange?.(result.tag === "Ok" ? result.value : undefined);
+    onChange?.(
-  }, [result, onChange]);
+      result.result.tag === "Ok" ? result.result.value : undefined,
+      sourceName
+    );
+  }, [result, onChange, sourceName]);
+
+  useEffect(() => {
+    return () => {
+      project.removeSource(sourceName);
+      if (project.getSource(importSourceName(sourceName)))
+        project.removeSource(importSourceName(sourceName));
+    };
+  }, [project, sourceName]);
 
   return result;
 };
-
-export const useSquigglePartial = (
-  args: SquiggleArgs<ReturnType<typeof runPartial>>
-) => {
-  return useSquiggleAny(args, runPartial);
-};
-
-export const useSquiggle = (args: SquiggleArgs<ReturnType<typeof run>>) => {
-  return useSquiggleAny(args, run);
-};

packages/components/src/lib/jsImports.ts

@@ -0,0 +1,51 @@
+type JsImportsValue =
+  | number
+  | string
+  | JsImportsValue[]
+  | {
+      [k: string]: JsImportsValue;
+    };
+
+export type JsImports = {
+  [k: string]: JsImportsValue;
+};
+
+const quote = (arg: string) => `"${arg.replace(new RegExp('"', "g"), '\\"')}"`;
+
+const jsImportsValueToSquiggleCode = (v: JsImportsValue): string => {
+  if (typeof v === "number") {
+    return String(v);
+  } else if (typeof v === "string") {
+    return quote(v);
+  } else if (v instanceof Array) {
+    return "[" + v.map((x) => jsImportsValueToSquiggleCode(x)) + "]";
+  } else {
+    if (Object.keys(v).length) {
+      return (
+        "{" +
+        Object.entries(v)
+          .map(([k, v]) => `${quote(k)}:${jsImportsValueToSquiggleCode(v)},`)
+          .join("") +
+        "}"
+      );
+    } else {
+      return "0"; // squiggle doesn't support empty `{}`
+    }
+  }
+};
+
+export const jsImportsToSquiggleCode = (v: JsImports) => {
+  const validId = new RegExp("[a-zA-Z][[a-zA-Z0-9]*");
+  let result = Object.entries(v)
+    .map(([k, v]) => {
+      if (!k.match(validId)) {
+        return ""; // skipping without warnings; can be improved
+      }
+      return `$${k} = ${jsImportsValueToSquiggleCode(v)}\n`;
+    })
+    .join("");
+  if (!result) {
+    result = "$__no_valid_imports__ = 1"; // without this generated squiggle code can be invalid
+  }
+  return result;
+};

packages/components/src/lib/plotParser.ts

@@ -1,9 +1,15 @@
 import * as yup from "yup";
-import { Distribution, result, squiggleExpression } from "@quri/squiggle-lang";
+import {
+  SqValue,
+  SqValueTag,
+  SqDistribution,
+  result,
+  SqRecord,
+} from "@quri/squiggle-lang";
 
 export type LabeledDistribution = {
   name: string;
-  distribution: Distribution;
+  distribution: SqDistribution;
   color?: string;
 };
 
@@ -21,50 +27,55 @@ function ok<a, b>(x: a): result<a, b> {
 
 const schema = yup
   .object()
-  .strict()
   .noUnknown()
+  .strict()
   .shape({
-    distributions: yup.object().shape({
+    distributions: yup
-      tag: yup.mixed().oneOf(["array"]),
+      .array()
-      value: yup
+      .required()
-        .array()
+      .of(
-        .of(
+        yup.object().required().shape({
-          yup.object().shape({
+          name: yup.string().required(),
-            tag: yup.mixed().oneOf(["record"]),
+          distribution: yup.mixed().required(),
-            value: yup.object({
+        })
-              name: yup.object().shape({
+      ),
-                tag: yup.mixed().oneOf(["string"]),
-                value: yup.string().required(),
-              }),
-              // color: yup
-              //   .object({
-              //     tag: yup.mixed().oneOf(["string"]),
-              //     value: yup.string().required(),
-              //   })
-              //   .default(undefined),
-              distribution: yup.object({
-                tag: yup.mixed().oneOf(["distribution"]),
-                value: yup.mixed(),
-              }),
-            }),
-          })
-        )
-        .required(),
-    }),
   });
 
-export function parsePlot(record: {
+type JsonObject =
-  [key: string]: squiggleExpression;
+  | string
-}): result<Plot, 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(record);
+    const plotRecord = schema.validateSync(toJsonRecord(record));
-    return ok({
+    if (plotRecord.distributions) {
-      distributions: plotRecord.distributions.value.map((x) => ({
+      return ok({ distributions: plotRecord.distributions.map((x) => x) });
-        name: x.value.name.value,
+    } else {
-        // color: x.value.color?.value, // not supported yet
+      // I have no idea why yup's typings thinks this is possible
-        distribution: x.value.distribution.value,
+      return error("no distributions field. Should never get here");
-      })),
+    }
-    });
   } catch (e) {
     const message = e instanceof Error ? e.message : "Unknown error";
     return error(message);

packages/components/src/lib/utility.ts

@@ -1,4 +1,5 @@
-import { result } from "@quri/squiggle-lang";
+import { result, resultMap, SqValueTag } from "@quri/squiggle-lang";
+import { ResultAndBindings } from "./hooks/useSquiggle";
 
 export function flattenResult<a, b>(x: result<a, b>[]): result<a[], b> {
   if (x.length === 0) {
@@ -35,3 +36,18 @@ export function all(arr: boolean[]): boolean {
 export function some(arr: boolean[]): boolean {
   return arr.reduce((x, y) => x || y, false);
 }
+
+export function getValueToRender({ result, bindings }: ResultAndBindings) {
+  return resultMap(result, (value) =>
+    value.tag === SqValueTag.Void ? bindings.asValue() : value
+  );
+}
+
+export function getErrorLocations(result: ResultAndBindings["result"]) {
+  if (result.tag === "Error") {
+    const location = result.value.location();
+    return location ? [location] : [];
+  } else {
+    return [];
+  }
+}

packages/components/src/stories/SquiggleChart.stories.mdx

@@ -79,6 +79,22 @@ could be continuous, discrete or mixed.
   </Story>
 </Canvas>
 
+### Date Distribution
+
+<Canvas>
+  <Story
+    name="Date Distribution"
+    args={{
+      code: "mx(1661819770311, 1661829770311, 1661839770311)",
+      width,
+      xAxisType: "dateTime",
+      width,
+    }}
+  >
+    {Template.bind({})}
+  </Story>
+</Canvas>
+
 ## Mixed distributions
 
 <Canvas>

packages/components/src/stories/SquigglePartial.stories.mdx

@@ -1,51 +0,0 @@
-import { SquigglePartial, SquiggleEditor } from "../components/SquiggleEditor";
-import { useState } from "react";
-import { Canvas, Meta, Story, Props } from "@storybook/addon-docs";
-
-<Meta title="Squiggle/SquigglePartial" component={SquigglePartial} />
-
-export const Template = (props) => <SquigglePartial {...props} />;
-
-# Squiggle Partial
-
-A Squiggle Partial is an editor that does not return a graph to the user, but
-instead returns bindings that can be used by further Squiggle Editors.
-
-<Canvas>
-  <Story
-    name="Standalone"
-    args={{
-      defaultCode: "x = normal(5,2)",
-    }}
-  >
-    {Template.bind({})}
-  </Story>
-</Canvas>
-
-<Canvas>
-  <Story
-    name="With Editor"
-    args={{
-      initialPartialString: "x = normal(5,2)",
-      initialEditorString: "x",
-    }}
-  >
-    {(props) => {
-      let [bindings, setBindings] = useState({});
-      return (
-        <>
-          <SquigglePartial
-            {...props}
-            defaultCode={props.initialPartialString}
-            onChange={setBindings}
-          />
-          <SquiggleEditor
-            {...props}
-            defaultCode={props.initialEditorString}
-            bindings={bindings}
-          />
-        </>
-      );
-    }}
-  </Story>
-</Canvas>

packages/components/src/styles/main.css

@@ -22,3 +22,8 @@ but this line is still necessary for proper initialization of `--tw-*` variables
 .ace_cursor {
   border-left: 2px solid !important;
 }
+
+.ace-error-marker {
+  position: absolute;
+  border-bottom: 1px solid red;
+}

packages/components/test/autorun.test.tsx

@@ -0,0 +1,55 @@
+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")
+  );
+*/
+});

packages/components/test/basic.test.tsx

@@ -0,0 +1,53 @@
+import { render, screen } 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";
+
+test("Chart logs nothing on render", async () => {
+  const { unmount } = render(<SquiggleChart code={"normal(0, 1)"} />);
+  unmount();
+
+  expect(console.log).not.toBeCalled();
+  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");
+});

packages/components/test/cleanup.test.tsx

@@ -0,0 +1,39 @@
+import { render } from "@testing-library/react";
+import React from "react";
+import "@testing-library/jest-dom";
+import { SquiggleChart } from "../src/index";
+import { SqProject } from "@quri/squiggle-lang";
+
+test("Creates and cleans up source", async () => {
+  const project = SqProject.create();
+
+  const { unmount } = render(
+    <SquiggleChart code={"normal(0, 1)"} project={project} />
+  );
+
+  expect(project.getSourceIds().length).toBe(1);
+
+  const sourceId = project.getSourceIds()[0];
+  expect(project.getSource(sourceId)).toBe("normal(0, 1)");
+
+  unmount();
+  expect(project.getSourceIds().length).toBe(0);
+  expect(project.getSource(sourceId)).toBe(undefined);
+});
+
+test("Creates and cleans up source and imports", async () => {
+  const project = SqProject.create();
+
+  const { unmount } = render(
+    <SquiggleChart
+      code={"normal($x, 1)"}
+      project={project}
+      jsImports={{ x: 3 }}
+    />
+  );
+
+  expect(project.getSourceIds().length).toBe(2);
+
+  unmount();
+  expect(project.getSourceIds()).toStrictEqual([]);
+});

packages/components/test/setup.js

@@ -0,0 +1,8 @@
+global.console = {
+  ...console,
+  log: jest.fn(console.log),
+  debug: jest.fn(console.debug),
+  info: jest.fn(console.info),
+  warn: jest.fn(console.warn),
+  error: jest.fn(console.error),
+};

packages/components/vercel.json

@@ -0,0 +1,4 @@
+{
+  "buildCommand": "cd ../.. && npx turbo run build --filter=@quri/squiggle-components",
+  "outputDirectory": "storybook-static"
+}

packages/squiggle-lang/.gitignore

@@ -23,3 +23,4 @@ coverage
 .nyc_output/
 src/rescript/Reducer/Reducer_Peggy/Reducer_Peggy_GeneratedParser.js
 src/rescript/Reducer/Reducer_Peggy/helpers.js
+src/rescript/ReducerProject/ReducerProject_IncludeParser.js

packages/squiggle-lang/.prettierignore

@@ -3,6 +3,8 @@ lib
 *.bs.js
 *.gen.tsx
 .nyc_output/
-_coverage/
+coverage/
 .cache/
 Reducer_Peggy_GeneratedParser.js
+ReducerProject_IncludeParser.js
+src/rescript/Reducer/Reducer_Peggy/helpers.js

packages/squiggle-lang/__tests__/Distributions/Dotwise_test.res

@@ -32,25 +32,29 @@ describe("dotSubtract", () => {
  */
   Skip.test("mean of normal minus exponential (property)", () => {
     assert_(
-      property2(float_(), floatRange(1e-5, 1e5), (mean, rate) => {
+      property2(
-        // We limit ourselves to stdev=1 so that the integral is trivial
+        float_(),
-        let dotDifference = DistributionOperation.Constructors.pointwiseSubtract(
+        floatRange(1e-5, 1e5),
-          ~env,
+        (mean, rate) => {
-          mkNormal(mean, 1.0),
+          // We limit ourselves to stdev=1 so that the integral is trivial
-          mkExponential(rate),
+          let dotDifference = DistributionOperation.Constructors.pointwiseSubtract(
-        )
+            ~env,
-        let meanResult = E.R2.bind(DistributionOperation.Constructors.mean(~env), dotDifference)
+            mkNormal(mean, 1.0),
-        // according to algebra or random variables,
+            mkExponential(rate),
-        let meanAnalytical =
-          mean -.
-          SymbolicDist.Exponential.mean({rate: rate})->E.R2.toExn(
-            "On trusted input this should never happen",
           )
-        switch meanResult {
+          let meanResult = E.R2.bind(DistributionOperation.Constructors.mean(~env), dotDifference)
-        | Ok(meanValue) => abs_float(meanValue -. meanAnalytical) /. abs_float(meanValue) < 1e-2 // 1% relative error
+          // according to algebra or random variables,
-        | Error(err) => err === DistributionTypes.OperationError(DivisionByZeroError)
+          let meanAnalytical =
-        }
+            mean -.
-      }),
+            SymbolicDist.Exponential.mean({rate: rate})->E.R2.toExn(
+              "On trusted input this should never happen",
+            )
+          switch meanResult {
+          | Ok(meanValue) => abs_float(meanValue -. meanAnalytical) /. abs_float(meanValue) < 1e-2 // 1% relative error
+          | Error(err) => err === DistributionTypes.OperationError(DivisionByZeroError)
+          }
+        },
+      ),
     )
     pass
   })

packages/squiggle-lang/__tests__/Distributions/Invariants/AlgebraicCombination_test.res

@@ -40,51 +40,60 @@ let algebraicPower = algebraicPower(~env)
 
 describe("(Algebraic) addition of distributions", () => {
   describe("mean", () => {
-    test("normal(mean=5) + normal(mean=20)", () => {
+    test(
-      normalDist5
+      "normal(mean=5) + normal(mean=20)",
-      ->algebraicAdd(normalDist20)
+      () => {
-      ->E.R2.fmap(DistributionTypes.Constructors.UsingDists.mean)
+        normalDist5
-      ->E.R2.fmap(run)
+        ->algebraicAdd(normalDist20)
-      ->E.R2.fmap(toFloat)
+        ->E.R2.fmap(DistributionTypes.Constructors.UsingDists.mean)
-      ->E.R.toExn("Expected float", _)
+        ->E.R2.fmap(run)
-      ->expect
+        ->E.R2.fmap(toFloat)
-      ->toBe(Some(2.5e1))
+        ->E.R.toExn("Expected float", _)
-    })
+        ->expect
+        ->toBe(Some(2.5e1))
+      },
+    )
 
-    test("uniform(low=9, high=10) + beta(alpha=2, beta=5)", () => {
+    test(
-      // let uniformMean = (9.0 +. 10.0) /. 2.0
+      "uniform(low=9, high=10) + beta(alpha=2, beta=5)",
-      // let betaMean = 1.0 /. (1.0 +. 5.0 /. 2.0)
+      () => {
-      let received =
+        // let uniformMean = (9.0 +. 10.0) /. 2.0
-        uniformDist
+        // let betaMean = 1.0 /. (1.0 +. 5.0 /. 2.0)
-        ->algebraicAdd(betaDist)
+        let received =
-        ->E.R2.fmap(DistributionTypes.Constructors.UsingDists.mean)
+          uniformDist
-        ->E.R2.fmap(run)
+          ->algebraicAdd(betaDist)
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(DistributionTypes.Constructors.UsingDists.mean)
-        ->E.R.toExn("Expected float", _)
+          ->E.R2.fmap(run)
-      switch received {
+          ->E.R2.fmap(toFloat)
-      | None => "algebraicAdd has"->expect->toBe("failed")
+          ->E.R.toExn("Expected float", _)
-      // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+        switch received {
-      // sometimes it works with ~digits=2.
+        | None => "algebraicAdd has"->expect->toBe("failed")
-      | Some(x) => x->expect->toBeSoCloseTo(9.786831807237022, ~digits=1) // (uniformMean +. betaMean)
+        // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
-      }
+        // 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)", () => {
+        }
-      // let uniformMean = (9.0 +. 10.0) /. 2.0
+      },
-      // let betaMean = 1.0 /. (1.0 +. 5.0 /. 2.0)
+    )
-      let received =
+    test(
-        betaDist
+      "beta(alpha=2, beta=5) + uniform(low=9, high=10)",
-        ->algebraicAdd(uniformDist)
+      () => {
-        ->E.R2.fmap(DistributionTypes.Constructors.UsingDists.mean)
+        // let uniformMean = (9.0 +. 10.0) /. 2.0
-        ->E.R2.fmap(run)
+        // let betaMean = 1.0 /. (1.0 +. 5.0 /. 2.0)
-        ->E.R2.fmap(toFloat)
+        let received =
-        ->E.R.toExn("Expected float", _)
+          betaDist
-      switch received {
+          ->algebraicAdd(uniformDist)
-      | None => "algebraicAdd has"->expect->toBe("failed")
+          ->E.R2.fmap(DistributionTypes.Constructors.UsingDists.mean)
-      // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+          ->E.R2.fmap(run)
-      // sometimes it works with ~digits=2.
+          ->E.R2.fmap(toFloat)
-      | Some(x) => x->expect->toBeSoCloseTo(9.784290207736126, ~digits=1) // (uniformMean +. betaMean)
+          ->E.R.toExn("Expected float", _)
-      }
+        switch received {
-    })
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+        // 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.
@@ -122,247 +131,282 @@ describe("(Algebraic) addition of distributions", () => {
         }
       },
     )
-    test("(normal(mean=10) + normal(mean=10)).pdf(1.9e1)", () => {
+    test(
-      let received =
+      "(normal(mean=10) + normal(mean=10)).pdf(1.9e1)",
-        normalDist20
+      () => {
-        ->Ok
+        let received =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.pdf(d, 1.9e1))
+          normalDist20
-        ->E.R2.fmap(run)
+          ->Ok
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.pdf(d, 1.9e1))
-        ->E.R.toOption
+          ->E.R2.fmap(run)
-        ->E.O.flatten
+          ->E.R2.fmap(toFloat)
-      let calculated =
+          ->E.R.toOption
-        normalDist10
+          ->E.O.flatten
-        ->algebraicAdd(normalDist10)
+        let calculated =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.pdf(d, 1.9e1))
+          normalDist10
-        ->E.R2.fmap(run)
+          ->algebraicAdd(normalDist10)
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.pdf(d, 1.9e1))
-        ->E.R.toOption
+          ->E.R2.fmap(run)
-        ->E.O.flatten
+          ->E.R2.fmap(toFloat)
-      switch received {
+          ->E.R.toOption
-      | None =>
+          ->E.O.flatten
-        "this branch occurs when the dispatch to Jstat on trusted input fails."
+        switch received {
-        ->expect
+        | None =>
-        ->toBe("never")
+          "this branch occurs when the dispatch to Jstat on trusted input fails."
-      | Some(x) =>
+          ->expect
-        switch calculated {
+          ->toBe("never")
-        | None => "algebraicAdd has"->expect->toBe("failed")
+        | Some(x) =>
-        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=1)
+          switch calculated {
+          | None => "algebraicAdd has"->expect->toBe("failed")
+          | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=1)
+          }
         }
-      }
+      },
-    })
+    )
-    test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).pdf(10)", () => {
+    test(
-      let received =
+      "(uniform(low=9, high=10) + beta(alpha=2, beta=5)).pdf(10)",
-        uniformDist
+      () => {
-        ->algebraicAdd(betaDist)
+        let received =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.pdf(d, 1e1))
+          uniformDist
-        ->E.R2.fmap(run)
+          ->algebraicAdd(betaDist)
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.pdf(d, 1e1))
-        ->E.R.toExn("Expected float", _)
+          ->E.R2.fmap(run)
-      switch received {
+          ->E.R2.fmap(toFloat)
-      | None => "algebraicAdd has"->expect->toBe("failed")
+          ->E.R.toExn("Expected float", _)
-      // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+        switch received {
-      // sometimes it works with ~digits=4.
+        | None => "algebraicAdd has"->expect->toBe("failed")
-      // This value was calculated by a python script
+        // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
-      | Some(x) => x->expect->toBeSoCloseTo(0.979023, ~digits=0)
+        // sometimes it works with ~digits=4.
-      }
+        // 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)", () => {
+        }
-      let received =
+      },
-        betaDist
+    )
-        ->algebraicAdd(uniformDist)
+    test(
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.pdf(d, 1e1))
+      "(beta(alpha=2, beta=5) + uniform(low=9, high=10)).pdf(10)",
-        ->E.R2.fmap(run)
+      () => {
-        ->E.R2.fmap(toFloat)
+        let received =
-        ->E.R.toExn("Expected float", _)
+          betaDist
-      switch received {
+          ->algebraicAdd(uniformDist)
-      | None => "algebraicAdd has"->expect->toBe("failed")
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.pdf(d, 1e1))
-      // This is nondeterministic.
+          ->E.R2.fmap(run)
-      | Some(x) => x->expect->toBeSoCloseTo(0.979023, ~digits=0)
+          ->E.R2.fmap(toFloat)
-      }
+          ->E.R.toExn("Expected float", _)
-    })
+        switch received {
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        // 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(
-      let received =
+      "(normal(mean=5) + normal(mean=5)).cdf (imprecise)",
-        normalDist10
+      list{6e0, 8e0, 1e1, 1.2e1},
-        ->Ok
+      x => {
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, x))
+        let received =
-        ->E.R2.fmap(run)
+          normalDist10
-        ->E.R2.fmap(toFloat)
+          ->Ok
-        ->E.R.toOption
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, x))
-        ->E.O.flatten
+          ->E.R2.fmap(run)
-      let calculated =
+          ->E.R2.fmap(toFloat)
-        normalDist5
+          ->E.R.toOption
-        ->algebraicAdd(normalDist5)
+          ->E.O.flatten
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, x))
+        let calculated =
-        ->E.R2.fmap(run)
+          normalDist5
-        ->E.R2.fmap(toFloat)
+          ->algebraicAdd(normalDist5)
-        ->E.R.toOption
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, x))
-        ->E.O.flatten
+          ->E.R2.fmap(run)
+          ->E.R2.fmap(toFloat)
+          ->E.R.toOption
+          ->E.O.flatten
 
-      switch received {
+        switch received {
-      | None =>
+        | None =>
-        "this branch occurs when the dispatch to Jstat on trusted input fails."
+          "this branch occurs when the dispatch to Jstat on trusted input fails."
-        ->expect
+          ->expect
-        ->toBe("never")
+          ->toBe("never")
-      | Some(x) =>
+        | Some(x) =>
-        switch calculated {
+          switch calculated {
-        | None => "algebraicAdd has"->expect->toBe("failed")
+          | None => "algebraicAdd has"->expect->toBe("failed")
-        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=0)
+          | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=0)
+          }
         }
-      }
+      },
-    })
+    )
-    test("(normal(mean=10) + normal(mean=10)).cdf(1.25e1)", () => {
+    test(
-      let received =
+      "(normal(mean=10) + normal(mean=10)).cdf(1.25e1)",
-        normalDist20
+      () => {
-        ->Ok
+        let received =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, 1.25e1))
+          normalDist20
-        ->E.R2.fmap(run)
+          ->Ok
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, 1.25e1))
-        ->E.R.toOption
+          ->E.R2.fmap(run)
-        ->E.O.flatten
+          ->E.R2.fmap(toFloat)
-      let calculated =
+          ->E.R.toOption
-        normalDist10
+          ->E.O.flatten
-        ->algebraicAdd(normalDist10)
+        let calculated =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, 1.25e1))
+          normalDist10
-        ->E.R2.fmap(run)
+          ->algebraicAdd(normalDist10)
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, 1.25e1))
-        ->E.R.toOption
+          ->E.R2.fmap(run)
-        ->E.O.flatten
+          ->E.R2.fmap(toFloat)
-      switch received {
+          ->E.R.toOption
-      | None =>
+          ->E.O.flatten
-        "this branch occurs when the dispatch to Jstat on trusted input fails."
+        switch received {
-        ->expect
+        | None =>
-        ->toBe("never")
+          "this branch occurs when the dispatch to Jstat on trusted input fails."
-      | Some(x) =>
+          ->expect
-        switch calculated {
+          ->toBe("never")
-        | None => "algebraicAdd has"->expect->toBe("failed")
+        | Some(x) =>
-        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=2)
+          switch calculated {
+          | None => "algebraicAdd has"->expect->toBe("failed")
+          | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=2)
+          }
         }
-      }
+      },
-    })
+    )
-    test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).cdf(10)", () => {
+    test(
-      let received =
+      "(uniform(low=9, high=10) + beta(alpha=2, beta=5)).cdf(10)",
-        uniformDist
+      () => {
-        ->algebraicAdd(betaDist)
+        let received =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, 1e1))
+          uniformDist
-        ->E.R2.fmap(run)
+          ->algebraicAdd(betaDist)
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, 1e1))
-        ->E.R.toExn("Expected float", _)
+          ->E.R2.fmap(run)
-      switch received {
+          ->E.R2.fmap(toFloat)
-      | None => "algebraicAdd has"->expect->toBe("failed")
+          ->E.R.toExn("Expected float", _)
-      // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+        switch received {
-      // The value was calculated externally using a python script
+        | None => "algebraicAdd has"->expect->toBe("failed")
-      | Some(x) => x->expect->toBeSoCloseTo(0.71148, ~digits=1)
+        // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
-      }
+        // 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)", () => {
+        }
-      let received =
+      },
-        betaDist
+    )
-        ->algebraicAdd(uniformDist)
+    test(
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, 1e1))
+      "(beta(alpha=2, beta=5) + uniform(low=9, high=10)).cdf(10)",
-        ->E.R2.fmap(run)
+      () => {
-        ->E.R2.fmap(toFloat)
+        let received =
-        ->E.R.toExn("Expected float", _)
+          betaDist
-      switch received {
+          ->algebraicAdd(uniformDist)
-      | None => "algebraicAdd has"->expect->toBe("failed")
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.cdf(d, 1e1))
-      // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+          ->E.R2.fmap(run)
-      // The value was calculated externally using a python script
+          ->E.R2.fmap(toFloat)
-      | Some(x) => x->expect->toBeSoCloseTo(0.71148, ~digits=1)
+          ->E.R.toExn("Expected float", _)
-      }
+        switch received {
-    })
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+        // 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(
-      let received =
+      "(normal(mean=5) + normal(mean=5)).inv (imprecise)",
-        normalDist10
+      list{5e-2, 4.2e-3, 9e-3},
-        ->Ok
+      x => {
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, x))
+        let received =
-        ->E.R2.fmap(run)
+          normalDist10
-        ->E.R2.fmap(toFloat)
+          ->Ok
-        ->E.R.toOption
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, x))
-        ->E.O.flatten
+          ->E.R2.fmap(run)
-      let calculated =
+          ->E.R2.fmap(toFloat)
-        normalDist5
+          ->E.R.toOption
-        ->algebraicAdd(normalDist5)
+          ->E.O.flatten
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, x))
+        let calculated =
-        ->E.R2.fmap(run)
+          normalDist5
-        ->E.R2.fmap(toFloat)
+          ->algebraicAdd(normalDist5)
-        ->E.R.toOption
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, x))
-        ->E.O.flatten
+          ->E.R2.fmap(run)
+          ->E.R2.fmap(toFloat)
+          ->E.R.toOption
+          ->E.O.flatten
 
-      switch received {
+        switch received {
-      | None =>
+        | None =>
-        "this branch occurs when the dispatch to Jstat on trusted input fails."
+          "this branch occurs when the dispatch to Jstat on trusted input fails."
-        ->expect
+          ->expect
-        ->toBe("never")
+          ->toBe("never")
-      | Some(x) =>
+        | Some(x) =>
-        switch calculated {
+          switch calculated {
-        | None => "algebraicAdd has"->expect->toBe("failed")
+          | None => "algebraicAdd has"->expect->toBe("failed")
-        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=-1)
+          | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=-1)
+          }
         }
-      }
+      },
-    })
+    )
-    test("(normal(mean=10) + normal(mean=10)).inv(1e-1)", () => {
+    test(
-      let received =
+      "(normal(mean=10) + normal(mean=10)).inv(1e-1)",
-        normalDist20
+      () => {
-        ->Ok
+        let received =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, 1e-1))
+          normalDist20
-        ->E.R2.fmap(run)
+          ->Ok
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, 1e-1))
-        ->E.R.toOption
+          ->E.R2.fmap(run)
-        ->E.O.flatten
+          ->E.R2.fmap(toFloat)
-      let calculated =
+          ->E.R.toOption
-        normalDist10
+          ->E.O.flatten
-        ->algebraicAdd(normalDist10)
+        let calculated =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, 1e-1))
+          normalDist10
-        ->E.R2.fmap(run)
+          ->algebraicAdd(normalDist10)
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, 1e-1))
-        ->E.R.toOption
+          ->E.R2.fmap(run)
-        ->E.O.flatten
+          ->E.R2.fmap(toFloat)
-      switch received {
+          ->E.R.toOption
-      | None =>
+          ->E.O.flatten
-        "this branch occurs when the dispatch to Jstat on trusted input fails."
+        switch received {
-        ->expect
+        | None =>
-        ->toBe("never")
+          "this branch occurs when the dispatch to Jstat on trusted input fails."
-      | Some(x) =>
+          ->expect
-        switch calculated {
+          ->toBe("never")
-        | None => "algebraicAdd has"->expect->toBe("failed")
+        | Some(x) =>
-        | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=-1)
+          switch calculated {
+          | None => "algebraicAdd has"->expect->toBe("failed")
+          | Some(y) => x->expect->toBeSoCloseTo(y, ~digits=-1)
+          }
         }
-      }
+      },
-    })
+    )
-    test("(uniform(low=9, high=10) + beta(alpha=2, beta=5)).inv(2e-2)", () => {
+    test(
-      let received =
+      "(uniform(low=9, high=10) + beta(alpha=2, beta=5)).inv(2e-2)",
-        uniformDist
+      () => {
-        ->algebraicAdd(betaDist)
+        let received =
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, 2e-2))
+          uniformDist
-        ->E.R2.fmap(run)
+          ->algebraicAdd(betaDist)
-        ->E.R2.fmap(toFloat)
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, 2e-2))
-        ->E.R.toExn("Expected float", _)
+          ->E.R2.fmap(run)
-      switch received {
+          ->E.R2.fmap(toFloat)
-      | None => "algebraicAdd has"->expect->toBe("failed")
+          ->E.R.toExn("Expected float", _)
-      // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+        switch received {
-      // sometimes it works with ~digits=2.
+        | None => "algebraicAdd has"->expect->toBe("failed")
-      | Some(x) => x->expect->toBeSoCloseTo(9.179319623146968, ~digits=0)
+        // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
-      }
+        // 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)", () => {
+        }
-      let received =
+      },
-        betaDist
+    )
-        ->algebraicAdd(uniformDist)
+    test(
-        ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, 2e-2))
+      "(beta(alpha=2, beta=5) + uniform(low=9, high=10)).inv(2e-2)",
-        ->E.R2.fmap(run)
+      () => {
-        ->E.R2.fmap(toFloat)
+        let received =
-        ->E.R.toExn("Expected float", _)
+          betaDist
-      switch received {
+          ->algebraicAdd(uniformDist)
-      | None => "algebraicAdd has"->expect->toBe("failed")
+          ->E.R2.fmap(d => DistributionTypes.Constructors.UsingDists.inv(d, 2e-2))
-      // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+          ->E.R2.fmap(run)
-      // sometimes it works with ~digits=2.
+          ->E.R2.fmap(toFloat)
-      | Some(x) => x->expect->toBeSoCloseTo(9.190872365862756, ~digits=0)
+          ->E.R.toExn("Expected float", _)
-      }
+        switch received {
-    })
+        | None => "algebraicAdd has"->expect->toBe("failed")
+        // This is nondeterministic, we could be in a situation where ci fails but you click rerun and it passes, which is bad.
+        // sometimes it works with ~digits=2.
+        | Some(x) => x->expect->toBeSoCloseTo(9.190872365862756, ~digits=0)
+        }
+      },
+    )
   })
 })

packages/squiggle-lang/__tests__/Distributions/Invariants/Means_test.res

@@ -3,7 +3,7 @@ This is the most basic file in our invariants family of tests.
 
 Validate that the addition of means equals the mean of the addition, similar for subtraction and multiplication. 
 
-Details in https://develop--squiggle-documentation.netlify.app/docs/internal/invariants/
+Details in https://squiggle-language.com/docs/internal/invariants/
 
 Note: epsilon of 1e3 means the invariants are, in general, not being satisfied. 
 */
@@ -87,14 +87,22 @@ 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(
-      testAddInvariant(dist, dist)
+      "with two of the same distribution",
-    })
+      distributions,
+      dist => {
+        testAddInvariant(dist, dist)
+      },
+    )
 
-    testAll("with two different distributions", pairsOfDifferentDistributions, dists => {
+    testAll(
-      let (dist1, dist2) = dists
+      "with two different distributions",
-      testAddInvariant(dist1, dist2)
+      pairsOfDifferentDistributions,
-    })
+      dists => {
+        let (dist1, dist2) = dists
+        testAddInvariant(dist1, dist2)
+      },
+    )
 
     testAll(
       "with two different distributions in swapped order",
@@ -116,14 +124,22 @@ 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(
-      testSubtractInvariant(dist, dist)
+      "with two of the same distribution",
-    })
+      distributions,
+      dist => {
+        testSubtractInvariant(dist, dist)
+      },
+    )
 
-    testAll("with two different distributions", pairsOfDifferentDistributions, dists => {
+    testAll(
-      let (dist1, dist2) = dists
+      "with two different distributions",
-      testSubtractInvariant(dist1, dist2)
+      pairsOfDifferentDistributions,
-    })
+      dists => {
+        let (dist1, dist2) = dists
+        testSubtractInvariant(dist1, dist2)
+      },
+    )
 
     testAll(
       "with two different distributions in swapped order",
@@ -145,14 +161,22 @@ 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(
-      testMultiplicationInvariant(dist, dist)
+      "with two of the same distribution",
-    })
+      distributions,
+      dist => {
+        testMultiplicationInvariant(dist, dist)
+      },
+    )
 
-    testAll("with two different distributions", pairsOfDifferentDistributions, dists => {
+    testAll(
-      let (dist1, dist2) = dists
+      "with two different distributions",
-      testMultiplicationInvariant(dist1, dist2)
+      pairsOfDifferentDistributions,
-    })
+      dists => {
+        let (dist1, dist2) = dists
+        testMultiplicationInvariant(dist1, dist2)
+      },
+    )
 
     testAll(
       "with two different distributions in swapped order",

packages/squiggle-lang/__tests__/Distributions/Scoring/KlDivergence_test.res

@@ -17,10 +17,9 @@ describe("klDivergence: continuous -> continuous -> float", () => {
       let answer =
         uniformMakeR(lowAnswer, highAnswer)->E.R2.errMap(s => DistributionTypes.ArgumentError(s))
       let prediction =
-        uniformMakeR(
+        uniformMakeR(lowPrediction, highPrediction)->E.R2.errMap(
-          lowPrediction,
+          s => DistributionTypes.ArgumentError(s),
-          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)
@@ -183,9 +182,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(
+      uniformMakeR(lowPrediction, highPrediction)->E.R2.errMap(
-        s,
+        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)
 

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: mean, stdev: stdev}))
+let mkNormal = (mean, stdev) => DistributionTypes.Symbolic(#Normal({mean, stdev}))
 
 describe("(Symbolic) normalize", () => {
   testAll("has no impact on normal distributions", list{-1e8, -1e-2, 0.0, 1e-4, 1e16}, mean => {
@@ -47,10 +47,7 @@ describe("(Symbolic) mean", () => {
     tup => {
       let (low, medium, high) = tup
       let meanValue = run(
-        FromDist(
+        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Triangular({low, medium, high}))),
-          #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/
     },
@@ -63,7 +60,7 @@ describe("(Symbolic) mean", () => {
     tup => {
       let (alpha, beta) = tup
       let meanValue = run(
-        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Beta({alpha: alpha, beta: beta}))),
+        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Beta({alpha, beta}))),
       )
       meanValue->unpackFloat->expect->toBeCloseTo(1.0 /. (1.0 +. beta /. alpha)) // https://en.wikipedia.org/wiki/Beta_distribution#Mean
     },
@@ -84,8 +81,8 @@ describe("(Symbolic) mean", () => {
       let (mean, stdev) = tup
       let betaDistribution = SymbolicDist.Beta.fromMeanAndStdev(mean, stdev)
       let meanValue =
-        betaDistribution->E.R2.fmap(d =>
+        betaDistribution->E.R2.fmap(
-          run(FromDist(#ToFloat(#Mean), d->DistributionTypes.Symbolic))
+          d => run(FromDist(#ToFloat(#Mean), d->DistributionTypes.Symbolic)),
         )
       switch meanValue {
       | Ok(value) => value->unpackFloat->expect->toBeCloseTo(mean)
@@ -100,7 +97,7 @@ describe("(Symbolic) mean", () => {
     tup => {
       let (mu, sigma) = tup
       let meanValue = run(
-        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Lognormal({mu: mu, sigma: sigma}))),
+        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Lognormal({mu, sigma}))),
       )
       meanValue->unpackFloat->expect->toBeCloseTo(Js.Math.exp(mu +. sigma ** 2.0 /. 2.0)) // https://brilliant.org/wiki/log-normal-distribution/
     },
@@ -112,7 +109,7 @@ describe("(Symbolic) mean", () => {
     tup => {
       let (low, high) = tup
       let meanValue = run(
-        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Uniform({low: low, high: high}))),
+        FromDist(#ToFloat(#Mean), DistributionTypes.Symbolic(#Uniform({low, high}))),
       )
       meanValue->unpackFloat->expect->toBeCloseTo((low +. high) /. 2.0) // https://en.wikipedia.org/wiki/Continuous_uniform_distribution#Moments
     },

packages/squiggle-lang/__tests__/E/splitContinuousAndDiscrete_test.res

@@ -9,22 +9,28 @@ let prepareInputs = (ar, minWeight) =>
 describe("Continuous and discrete splits", () => {
   makeTest(
     "is empty, with no common elements",
-    prepareInputs([1.432, 1.33455, 2.0], 2),
+    prepareInputs([1.33455, 1.432, 2.0], 2),
     ([1.33455, 1.432, 2.0], []),
   )
 
   makeTest(
     "only stores 3.5 as discrete when minWeight is 3",
-    prepareInputs([1.432, 1.33455, 2.0, 2.0, 3.5, 3.5, 3.5], 3),
+    prepareInputs([1.33455, 1.432, 2.0, 2.0, 3.5, 3.5, 3.5], 3),
     ([1.33455, 1.432, 2.0, 2.0], [(3.5, 3.0)]),
   )
 
   makeTest(
     "doesn't store 3.5 as discrete when minWeight is 5",
-    prepareInputs([1.432, 1.33455, 2.0, 2.0, 3.5, 3.5, 3.5], 5),
+    prepareInputs([1.33455, 1.432, 2.0, 2.0, 3.5, 3.5, 3.5], 5),
     ([1.33455, 1.432, 2.0, 2.0, 3.5, 3.5, 3.5], []),
   )
 
+  makeTest(
+    "more general test",
+    prepareInputs([10., 10., 11., 11., 11., 12., 13., 13., 13., 13., 13., 14.], 3),
+    ([10., 10., 12., 14.], [(11., 3.), (13., 5.)]),
+  )
+
   let makeDuplicatedArray = count => {
     let arr = Belt.Array.range(1, count) |> E.A.fmap(float_of_int)
     let sorted = arr |> Belt.SortArray.stableSortBy(_, compare)

packages/squiggle-lang/__tests__/Lodash_test.res

@@ -1,20 +0,0 @@
-open Jest
-open Expect
-
-let makeTest = (~only=false, str, item1, item2) =>
-  only
-    ? Only.test(str, () => expect(item1)->toEqual(item2))
-    : test(str, () => expect(item1)->toEqual(item2))
-
-describe("Lodash", () =>
-  describe("Lodash", () => {
-    makeTest("min", Lodash.min([1, 3, 4]), 1)
-    makeTest("max", Lodash.max([1, 3, 4]), 4)
-    makeTest("uniq", Lodash.uniq([1, 3, 4, 4]), [1, 3, 4])
-    makeTest(
-      "countBy",
-      Lodash.countBy([1, 3, 4, 4], r => r),
-      Js.Dict.fromArray([("1", 1), ("3", 1), ("4", 2)]),
-    )
-  })
-)

packages/squiggle-lang/__tests__/Reducer/Reducer_Bindings/Reducer_Bindings_test.res

@@ -0,0 +1,50 @@
+@@warning("-44")
+module Bindings = Reducer_Bindings
+module Namespace = Reducer_Namespace
+
+open Jest
+open Expect
+open Expect.Operators
+
+describe("Bindings", () => {
+  let value = Reducer_T.IEvNumber(1967.0)
+  let bindings = Bindings.make()->Bindings.set("value", value)
+  test("get", () => {
+    expect(bindings->Bindings.get("value")) == Some(value)
+  })
+
+  test("get nonexisting value", () => {
+    expect(bindings->Bindings.get("nosuchvalue")) == None
+  })
+
+  test("get on extended", () => {
+    expect(bindings->Bindings.extend->Bindings.get("value")) == Some(value)
+  })
+
+  test("locals", () => {
+    expect(bindings->Bindings.locals->Namespace.get("value")) == Some(value)
+  })
+
+  test("locals on extendeed", () => {
+    expect(bindings->Bindings.extend->Bindings.locals->Namespace.get("value")) == None
+  })
+
+  describe("extend", () => {
+    let value2 = Reducer_T.IEvNumber(5.)
+    let extendedBindings = bindings->Bindings.extend->Bindings.set("value", value2)
+
+    test(
+      "get on extended",
+      () => {
+        expect(extendedBindings->Bindings.get("value")) == Some(value2)
+      },
+    )
+
+    test(
+      "get on original",
+      () => {
+        expect(bindings->Bindings.get("value")) == Some(value)
+      },
+    )
+  })
+})

packages/squiggle-lang/__tests__/Reducer/Reducer_Dispatch/Reducer_Dispatch_BuiltInMacros_test.res

@@ -1,146 +0,0 @@
-open Jest
-// open Expect
-
-open Reducer_Expression_ExpressionBuilder
-open Reducer_TestMacroHelpers
-module ExpressionT = Reducer_Expression_T
-
-let exampleExpression = eNumber(1.)
-let exampleExpressionY = eSymbol("y")
-let exampleStatementY = eLetStatement("y", eNumber(1.))
-let exampleStatementX = eLetStatement("y", eSymbol("x"))
-let exampleStatementZ = eLetStatement("z", eSymbol("y"))
-
-// If it is not a macro then it is not expanded
-testMacro([], exampleExpression, "Ok(1)")
-
-describe("bindStatement", () => {
-  // A statement is bound by the bindings created by the previous statement
-  testMacro(
-    [],
-    eBindStatement(eBindings([]), exampleStatementY),
-    "Ok((:$_setBindings_$ @{} :y 1) context: @{})",
-  )
-  // Then it answers the bindings for the next statement when reduced
-  testMacroEval([], eBindStatement(eBindings([]), exampleStatementY), "Ok(@{y: 1})")
-  // Now let's feed a binding to see what happens
-  testMacro(
-    [],
-    eBindStatement(eBindings([("x", IEvNumber(2.))]), exampleStatementX),
-    "Ok((:$_setBindings_$ @{x: 2} :y 2) context: @{x: 2})",
-  )
-  // An expression does not return a binding, thus error
-  testMacro([], eBindStatement(eBindings([]), exampleExpression), "Assignment expected")
-  // When bindings from previous statement are missing the context is injected. This must be the first statement of a block
-  testMacro(
-    [("z", IEvNumber(99.))],
-    eBindStatementDefault(exampleStatementY),
-    "Ok((:$_setBindings_$ @{z: 99} :y 1) context: @{z: 99})",
-  )
-})
-
-describe("bindExpression", () => {
-  // x is simply bound in the expression
-  testMacro(
-    [],
-    eBindExpression(eBindings([("x", IEvNumber(2.))]), eSymbol("x")),
-    "Ok(2 context: @{x: 2})",
-  )
-  // When an let statement is the end expression then bindings are returned
-  testMacro(
-    [],
-    eBindExpression(eBindings([("x", IEvNumber(2.))]), exampleStatementY),
-    "Ok((:$_exportBindings_$ (:$_setBindings_$ @{x: 2} :y 1)) context: @{x: 2})",
-  )
-  // Now let's reduce that expression
-  testMacroEval(
-    [],
-    eBindExpression(eBindings([("x", IEvNumber(2.))]), exampleStatementY),
-    "Ok(@{x: 2,y: 1})",
-  )
-  // When bindings are missing the context is injected. This must be the first and last statement of a block
-  testMacroEval(
-    [("z", IEvNumber(99.))],
-    eBindExpressionDefault(exampleStatementY),
-    "Ok(@{y: 1,z: 99})",
-  )
-})
-
-describe("block", () => {
-  // Block with a single expression
-  testMacro([], eBlock(list{exampleExpression}), "Ok((:$$_bindExpression_$$ 1))")
-  testMacroEval([], eBlock(list{exampleExpression}), "Ok(1)")
-  // Block with a single statement
-  testMacro([], eBlock(list{exampleStatementY}), "Ok((:$$_bindExpression_$$ (:$_let_$ :y 1)))")
-  testMacroEval([], eBlock(list{exampleStatementY}), "Ok(@{y: 1})")
-  // Block with a statement and an expression
-  testMacro(
-    [],
-    eBlock(list{exampleStatementY, exampleExpressionY}),
-    "Ok((:$$_bindExpression_$$ (:$$_bindStatement_$$ (:$_let_$ :y 1)) :y))",
-  )
-  testMacroEval([], eBlock(list{exampleStatementY, exampleExpressionY}), "Ok(1)")
-  // Block with a statement and another statement
-  testMacro(
-    [],
-    eBlock(list{exampleStatementY, exampleStatementZ}),
-    "Ok((:$$_bindExpression_$$ (:$$_bindStatement_$$ (:$_let_$ :y 1)) (:$_let_$ :z :y)))",
-  )
-  testMacroEval([], eBlock(list{exampleStatementY, exampleStatementZ}), "Ok(@{y: 1,z: 1})")
-  // Block inside a block
-  testMacro([], eBlock(list{eBlock(list{exampleExpression})}), "Ok((:$$_bindExpression_$$ {1}))")
-  testMacroEval([], eBlock(list{eBlock(list{exampleExpression})}), "Ok(1)")
-  // Block assigned to a variable
-  testMacro(
-    [],
-    eBlock(list{eLetStatement("z", eBlock(list{eBlock(list{exampleExpressionY})}))}),
-    "Ok((:$$_bindExpression_$$ (:$_let_$ :z {{:y}})))",
-  )
-  testMacroEval(
-    [],
-    eBlock(list{eLetStatement("z", eBlock(list{eBlock(list{exampleExpressionY})}))}),
-    "Ok(@{z: :y})",
-  )
-  // Empty block
-  testMacro([], eBlock(list{}), "Ok(:undefined block)") //TODO: should be an error
-  //   :$$_block_$$ (:$$_block_$$ (:$_let_$ :y (:add :x 1)) :y)"
-  testMacro(
-    [],
-    eBlock(list{
-      eBlock(list{
-        eLetStatement("y", eFunction("add", list{eSymbol("x"), eNumber(1.)})),
-        eSymbol("y"),
-      }),
-    }),
-    "Ok((:$$_bindExpression_$$ {(:$_let_$ :y (:add :x 1)); :y}))",
-  )
-  testMacroEval(
-    [("x", IEvNumber(1.))],
-    eBlock(list{
-      eBlock(list{
-        eLetStatement("y", eFunction("add", list{eSymbol("x"), eNumber(1.)})),
-        eSymbol("y"),
-      }),
-    }),
-    "Ok(2)",
-  )
-})
-
-describe("lambda", () => {
-  // assign a lambda to a variable
-  let lambdaExpression = eFunction("$$_lambda_$$", list{eArrayString(["y"]), exampleExpressionY})
-  testMacro([], lambdaExpression, "Ok(lambda(y=>internal code))")
-  // call a lambda
-  let callLambdaExpression = list{lambdaExpression, eNumber(1.)}->ExpressionT.EList
-  testMacro([], callLambdaExpression, "Ok(((:$$_lambda_$$ [y] :y) 1))")
-  testMacroEval([], callLambdaExpression, "Ok(1)")
-  // Parameters shadow the outer scope
-  testMacroEval([("y", IEvNumber(666.))], callLambdaExpression, "Ok(1)")
-  // When not shadowed by the parameters, the outer scope variables are available
-  let lambdaExpression = eFunction(
-    "$$_lambda_$$",
-    list{eArrayString(["z"]), eFunction("add", list{eSymbol("y"), eSymbol("z")})},
-  )
-  let callLambdaExpression = eList(list{lambdaExpression, eNumber(1.)})
-  testMacroEval([("y", IEvNumber(666.))], callLambdaExpression, "Ok(667)")
-})

packages/squiggle-lang/__tests__/Reducer/Reducer_Dispatch/Reducer_Dispatch_BuiltIn_test.res

@@ -1,37 +0,0 @@
-module ExpressionValue = ReducerInterface.ExternalExpressionValue
-
-open Jest
-open Expect
-
-let expectEvalToBe = (expr: string, answer: string) =>
-  Reducer.evaluate(expr)->ExpressionValue.toStringResult->expect->toBe(answer)
-
-let testEval = (expr, answer) => test(expr, () => expectEvalToBe(expr, answer))
-
-describe("builtin", () => {
-  // All MathJs operators and functions are available for string, number and boolean
-  // .e.g + - / * > >= < <= == /= not and or
-  // See https://mathjs.org/docs/expressions/syntax.html
-  // See https://mathjs.org/docs/reference/functions.html
-  testEval("-1", "Ok(-1)")
-  testEval("1-1", "Ok(0)")
-  testEval("2>1", "Ok(true)")
-  testEval("concat('a','b')", "Ok('ab')")
-})
-
-describe("builtin exception", () => {
-  //It's a pity that MathJs does not return error position
-  test("MathJs Exception", () =>
-    expectEvalToBe("testZadanga(1)", "Error(JS Exception: Error: Undefined function testZadanga)")
-  )
-})
-
-describe("error reporting from collection functions", () => {
-  testEval("arr=[1,2,3]; map(arr, {|x| x*2})", "Ok([2,4,6])")
-  testEval(
-    "arr = [normal(3,2)]; map(arr, zarathsuzaWasHere)",
-    "Error(zarathsuzaWasHere is not defined)",
-  )
-  // FIXME: returns "Error(Function not found: map(Array,Symbol))"
-  // Actually this error is correct but not informative
-})

packages/squiggle-lang/__tests__/Reducer/Reducer_Helpers.res

@@ -1,22 +0,0 @@
-// Reducer_Helpers
-module ErrorValue = Reducer_ErrorValue
-module ExternalExpressionValue = ReducerInterface.ExternalExpressionValue
-module InternalExpressionValue = ReducerInterface.InternalExpressionValue
-module Bindings = Reducer_Bindings
-
-let removeDefaultsInternal = (iev: InternalExpressionValue.t) => {
-  switch iev {
-  | InternalExpressionValue.IEvBindings(nameSpace) =>
-    Bindings.removeOther(
-      nameSpace,
-      ReducerInterface.StdLib.internalStdLib,
-    )->InternalExpressionValue.IEvBindings
-  | value => value
-  }
-}
-
-let removeDefaultsExternal = (ev: ExternalExpressionValue.t): ExternalExpressionValue.t =>
-  ev->InternalExpressionValue.toInternal->removeDefaultsInternal->InternalExpressionValue.toExternal
-
-let rRemoveDefaultsInternal = r => Belt.Result.map(r, removeDefaultsInternal)
-let rRemoveDefaultsExternal = r => Belt.Result.map(r, removeDefaultsExternal)

packages/squiggle-lang/__tests__/Reducer/Reducer_MathJs/Reducer_MathJsEval_test.res

@@ -1,31 +0,0 @@
-module MathJs = Reducer_MathJs
-module ErrorValue = Reducer.ErrorValue
-
-open Jest
-open ExpectJs
-
-describe("eval", () => {
-  test("Number", () => expect(MathJs.Eval.eval("1"))->toEqual(Ok(IEvNumber(1.))))
-  test("Number expr", () => expect(MathJs.Eval.eval("1-1"))->toEqual(Ok(IEvNumber(0.))))
-  test("String", () => expect(MathJs.Eval.eval("'hello'"))->toEqual(Ok(IEvString("hello"))))
-  test("String expr", () =>
-    expect(MathJs.Eval.eval("concat('hello ','world')"))->toEqual(Ok(IEvString("hello world")))
-  )
-  test("Boolean", () => expect(MathJs.Eval.eval("true"))->toEqual(Ok(IEvBool(true))))
-  test("Boolean expr", () => expect(MathJs.Eval.eval("2>1"))->toEqual(Ok(IEvBool(true))))
-})
-
-describe("errors", () => {
-  // All those errors propagete up and are returned by the resolver
-  test("unknown function", () =>
-    expect(MathJs.Eval.eval("testZadanga()"))->toEqual(
-      Error(ErrorValue.REJavaScriptExn(Some("Undefined function testZadanga"), Some("Error"))),
-    )
-  )
-
-  test("unknown answer type", () =>
-    expect(MathJs.Eval.eval("1+1i"))->toEqual(
-      Error(ErrorValue.RETodo("Unhandled MathJs literal type: object")),
-    )
-  )
-})

packages/squiggle-lang/__tests__/Reducer/Reducer_Namespace_test.res

@@ -0,0 +1,62 @@
+@@warning("-44")
+module Namespace = Reducer_Namespace
+
+open Jest
+open Expect
+open Expect.Operators
+
+let makeValue = (v: float) => v->Reducer_T.IEvNumber
+
+describe("Namespace", () => {
+  let value = makeValue(5.)
+  let v2 = makeValue(2.)
+  let ns = Namespace.make()->Namespace.set("value", value)
+
+  test("get", () => {
+    expect(ns->Namespace.get("value")) == Some(value)
+  })
+
+  test("get nonexisting value", () => {
+    expect(ns->Namespace.get("nosuchvalue")) == None
+  })
+
+  test("set", () => {
+    let ns2 = ns->Namespace.set("v2", v2)
+    expect(ns2->Namespace.get("v2")) == Some(v2)
+  })
+
+  test("immutable", () => {
+    let _ = ns->Namespace.set("v2", Reducer_T.IEvNumber(2.))
+    expect(ns->Namespace.get("v2")) == None
+  })
+
+  describe("merge many", () => {
+    let x1 = makeValue(10.)
+    let x2 = makeValue(20.)
+    let x3 = makeValue(30.)
+    let x4 = makeValue(40.)
+    let ns1 = Namespace.make()->Namespace.set("x1", x1)->Namespace.set("x2", x2)
+    let ns2 = Namespace.make()->Namespace.set("x3", x3)->Namespace.set("x4", x4)
+
+    let nsMerged = Namespace.mergeMany([ns, ns1, ns2])
+
+    test(
+      "merge many 1",
+      () => {
+        expect(nsMerged->Namespace.get("x1")) == Some(x1)
+      },
+    )
+    test(
+      "merge many 2",
+      () => {
+        expect(nsMerged->Namespace.get("x4")) == Some(x4)
+      },
+    )
+    test(
+      "merge many 3",
+      () => {
+        expect(nsMerged->Namespace.get("value")) == Some(value)
+      },
+    )
+  })
+})

packages/squiggle-lang/__tests__/Reducer/Reducer_Peggy/Reducer_Peggy_Parse_test.res

@@ -14,47 +14,46 @@ describe("Peggy parse", () => {
   })
 
   describe("literals operators parenthesis", () => {
-    // Note that there is always an outer block. Otherwise, external bindings are ignrored at the first statement
     testParse("1", "{1}")
     testParse("'hello'", "{'hello'}")
     testParse("true", "{true}")
-    testParse("1+2", "{(::add 1 2)}")
+    testParse("1+2", "{(:add 1 2)}")
-    testParse("add(1,2)", "{(::add 1 2)}")
+    testParse("add(1,2)", "{(:add 1 2)}")
     testParse("(1)", "{1}")
-    testParse("(1+2)", "{(::add 1 2)}")
+    testParse("(1+2)", "{(:add 1 2)}")
   })
 
   describe("unary", () => {
-    testParse("-1", "{(::unaryMinus 1)}")
+    testParse("-1", "{(:unaryMinus 1)}")
-    testParse("!true", "{(::not true)}")
+    testParse("!true", "{(:not true)}")
-    testParse("1 + -1", "{(::add 1 (::unaryMinus 1))}")
+    testParse("1 + -1", "{(:add 1 (:unaryMinus 1))}")
-    testParse("-a[0]", "{(::unaryMinus (::$_atIndex_$ :a 0))}")
+    testParse("-a[0]", "{(:unaryMinus (:$_atIndex_$ :a 0))}")
-    testParse("!a[0]", "{(::not (::$_atIndex_$ :a 0))}")
+    testParse("!a[0]", "{(:not (:$_atIndex_$ :a 0))}")
   })
 
   describe("multiplicative", () => {
-    testParse("1 * 2", "{(::multiply 1 2)}")
+    testParse("1 * 2", "{(:multiply 1 2)}")
-    testParse("1 / 2", "{(::divide 1 2)}")
+    testParse("1 / 2", "{(:divide 1 2)}")
-    testParse("1 * 2 * 3", "{(::multiply (::multiply 1 2) 3)}")
+    testParse("1 * 2 * 3", "{(:multiply (:multiply 1 2) 3)}")
-    testParse("1 * 2 / 3", "{(::divide (::multiply 1 2) 3)}")
+    testParse("1 * 2 / 3", "{(:divide (:multiply 1 2) 3)}")
-    testParse("1 / 2 * 3", "{(::multiply (::divide 1 2) 3)}")
+    testParse("1 / 2 * 3", "{(:multiply (:divide 1 2) 3)}")
-    testParse("1 / 2 / 3", "{(::divide (::divide 1 2) 3)}")
+    testParse("1 / 2 / 3", "{(:divide (:divide 1 2) 3)}")
-    testParse("1 * 2 + 3 * 4", "{(::add (::multiply 1 2) (::multiply 3 4))}")
+    testParse("1 * 2 + 3 * 4", "{(:add (:multiply 1 2) (:multiply 3 4))}")
-    testParse("1 * 2 - 3 * 4", "{(::subtract (::multiply 1 2) (::multiply 3 4))}")
+    testParse("1 * 2 - 3 * 4", "{(:subtract (:multiply 1 2) (:multiply 3 4))}")
-    testParse("1 * 2 .+ 3 * 4", "{(::dotAdd (::multiply 1 2) (::multiply 3 4))}")
+    testParse("1 * 2 .+ 3 * 4", "{(:dotAdd (:multiply 1 2) (:multiply 3 4))}")
-    testParse("1 * 2 .- 3 * 4", "{(::dotSubtract (::multiply 1 2) (::multiply 3 4))}")
+    testParse("1 * 2 .- 3 * 4", "{(:dotSubtract (:multiply 1 2) (:multiply 3 4))}")
-    testParse("1 * 2 + 3 .* 4", "{(::add (::multiply 1 2) (::dotMultiply 3 4))}")
+    testParse("1 * 2 + 3 .* 4", "{(:add (:multiply 1 2) (:dotMultiply 3 4))}")
-    testParse("1 * 2 + 3 / 4", "{(::add (::multiply 1 2) (::divide 3 4))}")
+    testParse("1 * 2 + 3 / 4", "{(:add (:multiply 1 2) (:divide 3 4))}")
-    testParse("1 * 2 + 3 ./ 4", "{(::add (::multiply 1 2) (::dotDivide 3 4))}")
+    testParse("1 * 2 + 3 ./ 4", "{(:add (:multiply 1 2) (:dotDivide 3 4))}")
-    testParse("1 * 2 - 3 .* 4", "{(::subtract (::multiply 1 2) (::dotMultiply 3 4))}")
+    testParse("1 * 2 - 3 .* 4", "{(:subtract (:multiply 1 2) (:dotMultiply 3 4))}")
-    testParse("1 * 2 - 3 / 4", "{(::subtract (::multiply 1 2) (::divide 3 4))}")
+    testParse("1 * 2 - 3 / 4", "{(:subtract (:multiply 1 2) (:divide 3 4))}")
-    testParse("1 * 2 - 3 ./ 4", "{(::subtract (::multiply 1 2) (::dotDivide 3 4))}")
+    testParse("1 * 2 - 3 ./ 4", "{(:subtract (:multiply 1 2) (:dotDivide 3 4))}")
-    testParse("1 * 2 - 3 * 4^5", "{(::subtract (::multiply 1 2) (::multiply 3 (::pow 4 5)))}")
+    testParse("1 * 2 - 3 * 4^5", "{(:subtract (:multiply 1 2) (:multiply 3 (:pow 4 5)))}")
     testParse(
       "1 * 2 - 3 * 4^5^6",
-      "{(::subtract (::multiply 1 2) (::multiply 3 (::pow (::pow 4 5) 6)))}",
+      "{(:subtract (:multiply 1 2) (:multiply 3 (:pow (:pow 4 5) 6)))}",
     )
-    testParse("1 * -a[-2]", "{(::multiply 1 (::unaryMinus (::$_atIndex_$ :a (::unaryMinus 2))))}")
+    testParse("1 * -a[-2]", "{(:multiply 1 (:unaryMinus (:$_atIndex_$ :a (:unaryMinus 2))))}")
   })
 
   describe("multi-line", () => {
@@ -70,27 +69,27 @@ describe("Peggy parse", () => {
 
   describe("functions", () => {
     testParse("identity(x) = x", "{:identity = {|:x| {:x}}}") // Function definitions become lambda assignments
-    testParse("identity(x)", "{(::identity :x)}")
+    testParse("identity(x)", "{(:identity :x)}")
   })
 
   describe("arrays", () => {
-    testParse("[]", "{(::$_constructArray_$ ())}")
+    testParse("[]", "{[]}")
-    testParse("[0, 1, 2]", "{(::$_constructArray_$ (0 1 2))}")
+    testParse("[0, 1, 2]", "{[0; 1; 2]}")
-    testParse("['hello', 'world']", "{(::$_constructArray_$ ('hello' 'world'))}")
+    testParse("['hello', 'world']", "{['hello'; 'world']}")
-    testParse("([0,1,2])[1]", "{(::$_atIndex_$ (::$_constructArray_$ (0 1 2)) 1)}")
+    testParse("([0,1,2])[1]", "{(:$_atIndex_$ [0; 1; 2] 1)}")
   })
 
   describe("records", () => {
-    testParse("{a: 1, b: 2}", "{(::$_constructRecord_$ ('a': 1 'b': 2))}")
+    testParse("{a: 1, b: 2}", "{{'a': 1, 'b': 2}}")
-    testParse("{1+0: 1, 2+0: 2}", "{(::$_constructRecord_$ ((::add 1 0): 1 (::add 2 0): 2))}") // key can be any expression
+    testParse("{1+0: 1, 2+0: 2}", "{{(:add 1 0): 1, (:add 2 0): 2}}") // key can be any expression
-    testParse("record.property", "{(::$_atIndex_$ :record 'property')}")
+    testParse("record.property", "{(:$_atIndex_$ :record 'property')}")
   })
 
   describe("post operators", () => {
     //function call, array and record access are post operators with higher priority than unary operators
-    testParse("a==!b(1)", "{(::equal :a (::not (::b 1)))}")
+    testParse("a==!b(1)", "{(:equal :a (:not (:b 1)))}")
-    testParse("a==!b[1]", "{(::equal :a (::not (::$_atIndex_$ :b 1)))}")
+    testParse("a==!b[1]", "{(:equal :a (:not (:$_atIndex_$ :b 1)))}")
-    testParse("a==!b.one", "{(::equal :a (::not (::$_atIndex_$ :b 'one')))}")
+    testParse("a==!b.one", "{(:equal :a (:not (:$_atIndex_$ :b 'one')))}")
   })
 
   describe("comments", () => {
@@ -100,10 +99,10 @@ describe("Peggy parse", () => {
     testParse("/* This is a multi line comment */ 1", "{1}")
     testParse(
       `
-    /* This is 
+  /* This is 
-    a multi line 
+  a multi line 
-    comment */
+  comment */
-    1`,
+  1`,
       "{1}",
     )
   })
@@ -126,70 +125,67 @@ describe("Peggy parse", () => {
   })
 
   describe("logical", () => {
-    testParse("true || false", "{(::or true false)}")
+    testParse("true || false", "{(:or true false)}")
-    testParse("true && false", "{(::and true false)}")
+    testParse("true && false", "{(:and true false)}")
-    testParse("a * b + c", "{(::add (::multiply :a :b) :c)}") // for comparison
+    testParse("a * b + c", "{(:add (:multiply :a :b) :c)}") // for comparison
-    testParse("a && b || c", "{(::or (::and :a :b) :c)}")
+    testParse("a && b || c", "{(:or (:and :a :b) :c)}")
-    testParse("a && b || c && d", "{(::or (::and :a :b) (::and :c :d))}")
+    testParse("a && b || c && d", "{(:or (:and :a :b) (:and :c :d))}")
-    testParse("a && !b || c", "{(::or (::and :a (::not :b)) :c)}")
+    testParse("a && !b || c", "{(:or (:and :a (:not :b)) :c)}")
-    testParse("a && b==c || d", "{(::or (::and :a (::equal :b :c)) :d)}")
+    testParse("a && b==c || d", "{(:or (:and :a (:equal :b :c)) :d)}")
-    testParse("a && b!=c || d", "{(::or (::and :a (::unequal :b :c)) :d)}")
+    testParse("a && b!=c || d", "{(:or (:and :a (:unequal :b :c)) :d)}")
-    testParse("a && !(b==c) || d", "{(::or (::and :a (::not (::equal :b :c))) :d)}")
+    testParse("a && !(b==c) || d", "{(:or (:and :a (:not (:equal :b :c))) :d)}")
-    testParse("a && b>=c || d", "{(::or (::and :a (::largerEq :b :c)) :d)}")
+    testParse("a && b>=c || d", "{(:or (:and :a (:largerEq :b :c)) :d)}")
-    testParse("a && !(b>=c) || d", "{(::or (::and :a (::not (::largerEq :b :c))) :d)}")
+    testParse("a && !(b>=c) || d", "{(:or (:and :a (:not (:largerEq :b :c))) :d)}")
-    testParse("a && b<=c || d", "{(::or (::and :a (::smallerEq :b :c)) :d)}")
+    testParse("a && b<=c || d", "{(:or (:and :a (:smallerEq :b :c)) :d)}")
-    testParse("a && b>c || d", "{(::or (::and :a (::larger :b :c)) :d)}")
+    testParse("a && b>c || d", "{(:or (:and :a (:larger :b :c)) :d)}")
-    testParse("a && b<c || d", "{(::or (::and :a (::smaller :b :c)) :d)}")
+    testParse("a && b<c || d", "{(:or (:and :a (:smaller :b :c)) :d)}")
-    testParse("a && b<c[i] || d", "{(::or (::and :a (::smaller :b (::$_atIndex_$ :c :i))) :d)}")
+    testParse("a && b<c[i] || d", "{(:or (:and :a (:smaller :b (:$_atIndex_$ :c :i))) :d)}")
-    testParse("a && b<c.i || d", "{(::or (::and :a (::smaller :b (::$_atIndex_$ :c 'i'))) :d)}")
+    testParse("a && b<c.i || d", "{(:or (:and :a (:smaller :b (:$_atIndex_$ :c 'i'))) :d)}")
-    testParse("a && b<c(i) || d", "{(::or (::and :a (::smaller :b (::c :i))) :d)}")
+    testParse("a && b<c(i) || d", "{(:or (:and :a (:smaller :b (:c :i))) :d)}")
-    testParse("a && b<1+2 || d", "{(::or (::and :a (::smaller :b (::add 1 2))) :d)}")
+    testParse("a && b<1+2 || d", "{(:or (:and :a (:smaller :b (:add 1 2))) :d)}")
-    testParse(
+    testParse("a && b<1+2*3 || d", "{(:or (:and :a (:smaller :b (:add 1 (:multiply 2 3)))) :d)}")
-      "a && b<1+2*3 || d",
-      "{(::or (::and :a (::smaller :b (::add 1 (::multiply 2 3)))) :d)}",
-    )
     testParse(
       "a && b<1+2*-3+4 || d",
-      "{(::or (::and :a (::smaller :b (::add (::add 1 (::multiply 2 (::unaryMinus 3))) 4))) :d)}",
+      "{(:or (:and :a (:smaller :b (:add (:add 1 (:multiply 2 (:unaryMinus 3))) 4))) :d)}",
     )
     testParse(
       "a && b<1+2*3 || d ? true : false",
-      "{(::$$_ternary_$$ (::or (::and :a (::smaller :b (::add 1 (::multiply 2 3)))) :d) true false)}",
+      "{(::$$_ternary_$$ (:or (:and :a (:smaller :b (:add 1 (:multiply 2 3)))) :d) true false)}",
     )
   })
 
   describe("pipe", () => {
-    testParse("1 -> add(2)", "{(::add 1 2)}")
+    testParse("1 -> add(2)", "{(:add 1 2)}")
-    testParse("-1 -> add(2)", "{(::add (::unaryMinus 1) 2)}")
+    testParse("-1 -> add(2)", "{(:add (:unaryMinus 1) 2)}")
-    testParse("-a[1] -> add(2)", "{(::add (::unaryMinus (::$_atIndex_$ :a 1)) 2)}")
+    testParse("-a[1] -> add(2)", "{(:add (:unaryMinus (:$_atIndex_$ :a 1)) 2)}")
-    testParse("-f(1) -> add(2)", "{(::add (::unaryMinus (::f 1)) 2)}")
+    testParse("-f(1) -> add(2)", "{(:add (:unaryMinus (:f 1)) 2)}")
-    testParse("1 + 2 -> add(3)", "{(::add 1 (::add 2 3))}")
+    testParse("1 + 2 -> add(3)", "{(:add 1 (:add 2 3))}")
-    testParse("1 -> add(2) * 3", "{(::multiply (::add 1 2) 3)}")
+    testParse("1 -> add(2) * 3", "{(:multiply (:add 1 2) 3)}")
-    testParse("1 -> subtract(2)", "{(::subtract 1 2)}")
+    testParse("1 -> subtract(2)", "{(:subtract 1 2)}")
-    testParse("-1 -> subtract(2)", "{(::subtract (::unaryMinus 1) 2)}")
+    testParse("-1 -> subtract(2)", "{(:subtract (:unaryMinus 1) 2)}")
-    testParse("1 -> subtract(2) * 3", "{(::multiply (::subtract 1 2) 3)}")
+    testParse("1 -> subtract(2) * 3", "{(:multiply (:subtract 1 2) 3)}")
   })
 
   describe("elixir pipe", () => {
     //handled together with -> so there is no need for seperate tests
-    testParse("1 |> add(2)", "{(::add 1 2)}")
+    testParse("1 |> add(2)", "{(:add 1 2)}")
   })
 
   describe("to", () => {
-    testParse("1 to 2", "{(::credibleIntervalToDistribution 1 2)}")
+    testParse("1 to 2", "{(:credibleIntervalToDistribution 1 2)}")
-    testParse("-1 to -2", "{(::credibleIntervalToDistribution (::unaryMinus 1) (::unaryMinus 2))}") // lower than unary
+    testParse("-1 to -2", "{(:credibleIntervalToDistribution (:unaryMinus 1) (:unaryMinus 2))}") // lower than unary
     testParse(
       "a[1] to a[2]",
-      "{(::credibleIntervalToDistribution (::$_atIndex_$ :a 1) (::$_atIndex_$ :a 2))}",
+      "{(:credibleIntervalToDistribution (:$_atIndex_$ :a 1) (:$_atIndex_$ :a 2))}",
     ) // lower than post
     testParse(
       "a.p1 to a.p2",
-      "{(::credibleIntervalToDistribution (::$_atIndex_$ :a 'p1') (::$_atIndex_$ :a 'p2'))}",
+      "{(:credibleIntervalToDistribution (:$_atIndex_$ :a 'p1') (:$_atIndex_$ :a 'p2'))}",
     ) // lower than post
-    testParse("1 to 2 + 3", "{(::add (::credibleIntervalToDistribution 1 2) 3)}") // higher than binary operators
+    testParse("1 to 2 + 3", "{(:credibleIntervalToDistribution 1 (:add 2 3))}")
     testParse(
       "1->add(2) to 3->add(4) -> add(4)",
-      "{(::credibleIntervalToDistribution (::add 1 2) (::add (::add 3 4) 4))}",
+      "{(:credibleIntervalToDistribution (:add 1 2) (:add (:add 3 4) 4))}",
     ) // lower than chain
   })
 
@@ -200,8 +196,8 @@ describe("Peggy parse", () => {
   })
 
   describe("lambda", () => {
-    testParse("{|x| x}", "{{|:x| {:x}}}")
+    testParse("{|x| x}", "{{|:x| :x}}")
-    testParse("f={|x| x}", "{:f = {{|:x| {:x}}}}")
+    testParse("f={|x| x}", "{:f = {|:x| :x}}")
     testParse("f(x)=x", "{:f = {|:x| {:x}}}") // Function definitions are lambda assignments
     testParse("f(x)=x ? 1 : 0", "{:f = {|:x| {(::$$_ternary_$$ :x 1 0)}}}") // Function definitions are lambda assignments
   })
@@ -209,31 +205,25 @@ describe("Peggy parse", () => {
   describe("Using lambda as value", () => {
     testParse(
       "myadd(x,y)=x+y; z=myadd; z",
-      "{:myadd = {|:x,:y| {(::add :x :y)}}; :z = {:myadd}; :z}",
+      "{:myadd = {|:x,:y| {(:add :x :y)}}; :z = {:myadd}; :z}",
     )
     testParse(
       "myadd(x,y)=x+y; z=[myadd]; z",
-      "{:myadd = {|:x,:y| {(::add :x :y)}}; :z = {(::$_constructArray_$ (:myadd))}; :z}",
+      "{:myadd = {|:x,:y| {(:add :x :y)}}; :z = {[:myadd]}; :z}",
     )
     testParse(
       "myaddd(x,y)=x+y; z={x: myaddd}; z",
-      "{:myaddd = {|:x,:y| {(::add :x :y)}}; :z = {(::$_constructRecord_$ ('x': :myaddd))}; :z}",
+      "{:myaddd = {|:x,:y| {(:add :x :y)}}; :z = {{'x': :myaddd}}; :z}",
-    )
-    testParse("f({|x| x+1})", "{(::f {|:x| {(::add :x 1)}})}")
-    testParse("map(arr, {|x| x+1})", "{(::map :arr {|:x| {(::add :x 1)}})}")
-    testParse(
-      "map([1,2,3], {|x| x+1})",
-      "{(::map (::$_constructArray_$ (1 2 3)) {|:x| {(::add :x 1)}})}",
-    )
-    testParse(
-      "[1,2,3]->map({|x| x+1})",
-      "{(::map (::$_constructArray_$ (1 2 3)) {|:x| {(::add :x 1)}})}",
     )
+    testParse("f({|x| x+1})", "{(:f {|:x| (:add :x 1)})}")
+    testParse("map(arr, {|x| x+1})", "{(:map :arr {|:x| (:add :x 1)})}")
+    testParse("map([1,2,3], {|x| x+1})", "{(:map [1; 2; 3] {|:x| (:add :x 1)})}")
+    testParse("[1,2,3]->map({|x| x+1})", "{(:map [1; 2; 3] {|:x| (:add :x 1)})}")
   })
   describe("unit", () => {
-    testParse("1m", "{(::fromUnit_m 1)}")
+    testParse("1m", "{(:fromUnit_m 1)}")
-    testParse("1M", "{(::fromUnit_M 1)}")
+    testParse("1M", "{(:fromUnit_M 1)}")
-    testParse("1m+2cm", "{(::add (::fromUnit_m 1) (::fromUnit_cm 2))}")
+    testParse("1m+2cm", "{(:add (:fromUnit_m 1) (:fromUnit_cm 2))}")
   })
   describe("Module", () => {
     testParse("x", "{:x}")
@@ -244,118 +234,118 @@ describe("Peggy parse", () => {
 describe("parsing new line", () => {
   testParse(
     `
-  a + 
+ a + 
-  b`,
+ b`,
-    "{(::add :a :b)}",
+    "{(:add :a :b)}",
   )
   testParse(
     `
-  x=
+ x=
-  1`,
+ 1`,
     "{:x = {1}}",
   )
   testParse(
     `
-  x=1
+ x=1
-  y=2`,
+ y=2`,
     "{:x = {1}; :y = {2}}",
   )
   testParse(
     `
-  x={
+ x={
-   y=2;
+  y=2;
-   y }
+  y }
-  x`,
+ x`,
     "{:x = {:y = {2}; :y}; :x}",
   )
   testParse(
     `
-  x={
+ x={
-   y=2
-   y }
-  x`,
-    "{:x = {:y = {2}; :y}; :x}",
-  )
-  testParse(
-    `
-  x={
-   y=2
-   y 
-   }
-  x`,
-    "{:x = {:y = {2}; :y}; :x}",
-  )
-  testParse(
-    `
-  x=1
   y=2
-  z=3
+  y }
-  `,
+ x`,
+    "{:x = {:y = {2}; :y}; :x}",
+  )
+  testParse(
+    `
+ x={
+  y=2
+  y 
+  }
+ x`,
+    "{:x = {:y = {2}; :y}; :x}",
+  )
+  testParse(
+    `
+ x=1
+ y=2
+ z=3
+ `,
     "{:x = {1}; :y = {2}; :z = {3}}",
   )
   testParse(
     `
-  f={
+ f={
-    x=1
+  x=1
-    y=2
+  y=2
-    z=3
+  z=3
-    x+y+z
+  x+y+z
+ }
+ `,
+    "{:f = {:x = {1}; :y = {2}; :z = {3}; (:add (:add :x :y) :z)}}",
+  )
+  testParse(
+    `
+ f={
+  x=1
+  y=2
+  z=3
+  x+y+z
+ }
+ g=f+4
+ g
+ `,
+    "{:f = {:x = {1}; :y = {2}; :z = {3}; (:add (:add :x :y) :z)}; :g = {(:add :f 4)}; :g}",
+  )
+  testParse(
+    `
+ f =
+  {
+   x=1; //x
+   y=2 //y
+   z=
+    3
+   x+
+    y+
+    z
   }
-  `,
+ g =
-    "{:f = {:x = {1}; :y = {2}; :z = {3}; (::add (::add :x :y) :z)}}",
+  f +
+   4
+ g ->
+  h ->
+  p ->
+  q 
+ `,
+    "{:f = {:x = {1}; :y = {2}; :z = {3}; (:add (:add :x :y) :z)}; :g = {(:add :f 4)}; (:q (:p (:h :g)))}",
   )
   testParse(
     `
-  f={
+  a |>
-    x=1
+  b |>
-    y=2
+  c |>
-    z=3
+  d 
-    x+y+z
+ `,
-  }
+    "{(:d (:c (:b :a)))}",
-  g=f+4
-  g
-  `,
-    "{:f = {:x = {1}; :y = {2}; :z = {3}; (::add (::add :x :y) :z)}; :g = {(::add :f 4)}; :g}",
   )
   testParse(
     `
-  f =
+  a |>
-    {
+  b |>
-      x=1; //x
+  c |>
-      y=2  //y
+  d +
-      z=
+  e
-        3
+ `,
-      x+
+    "{(:add (:d (:c (:b :a))) :e)}",
-        y+
-        z
-    }
-  g =
-    f +
-      4
-  g ->
-    h ->
-    p ->
-    q 
-  `,
-    "{:f = {:x = {1}; :y = {2}; :z = {3}; (::add (::add :x :y) :z)}; :g = {(::add :f 4)}; (::q (::p (::h :g)))}",
-  )
-  testParse(
-    `
-    a |>
-    b |>
-    c |>
-    d 
-  `,
-    "{(::d (::c (::b :a)))}",
-  )
-  testParse(
-    `
-    a |>
-    b |>
-    c |>
-    d +
-    e
-  `,
-    "{(::add (::d (::c (::b :a))) :e)}",
   )
 })

packages/squiggle-lang/__tests__/Reducer/Reducer_Peggy/Reducer_Peggy_Parse_type_test.res

@@ -3,77 +3,83 @@ open Reducer_Peggy_TestHelpers
 
 describe("Peggy parse type", () => {
   describe("type of", () => {
-    testParse("p: number", "{(::$_typeOf_$ :p #number)}")
+    testParse("p: number", "{(::$_typeOf_$ :p #number); (::$_endOfOuterBlock_$ () ())}")
   })
   describe("type alias", () => {
-    testParse("type index=number", "{(::$_typeAlias_$ #index #number)}")
+    testParse(
+      "type index=number",
+      "{(::$_typeAlias_$ #index #number); (::$_endOfOuterBlock_$ () ())}",
+    )
   })
   describe("type or", () => {
     testParse(
       "answer: number|string",
-      "{(::$_typeOf_$ :answer (::$_typeOr_$ (::$_constructArray_$ (#number #string))))}",
+      "{(::$_typeOf_$ :answer (::$_typeOr_$ (::$_constructArray_$ #number #string))); (::$_endOfOuterBlock_$ () ())}",
     )
   })
   describe("type function", () => {
     testParse(
       "f: number=>number=>number",
-      "{(::$_typeOf_$ :f (::$_typeFunction_$ (::$_constructArray_$ (#number #number #number))))}",
+      "{(::$_typeOf_$ :f (::$_typeFunction_$ (::$_constructArray_$ #number #number #number))); (::$_endOfOuterBlock_$ () ())}",
     )
   })
   describe("high priority contract", () => {
     testParse(
       "answer: number<-min<-max(100)|string",
-      "{(::$_typeOf_$ :answer (::$_typeOr_$ (::$_constructArray_$ ((::$_typeModifier_max_$ (::$_typeModifier_min_$ #number) 100) #string))))}",
+      "{(::$_typeOf_$ :answer (::$_typeOr_$ (::$_constructArray_$ (::$_typeModifier_max_$ (::$_typeModifier_min_$ #number) 100) #string))); (::$_endOfOuterBlock_$ () ())}",
     )
     testParse(
       "answer: number<-memberOf([1,3,5])",
-      "{(::$_typeOf_$ :answer (::$_typeModifier_memberOf_$ #number (::$_constructArray_$ (1 3 5))))}",
+      "{(::$_typeOf_$ :answer (::$_typeModifier_memberOf_$ #number (::$_constructArray_$ 1 3 5))); (::$_endOfOuterBlock_$ () ())}",
     )
   })
   describe("low priority contract", () => {
     testParse(
       "answer: number | string $ opaque",
-      "{(::$_typeOf_$ :answer (::$_typeModifier_opaque_$ (::$_typeOr_$ (::$_constructArray_$ (#number #string)))))}",
+      "{(::$_typeOf_$ :answer (::$_typeModifier_opaque_$ (::$_typeOr_$ (::$_constructArray_$ #number #string)))); (::$_endOfOuterBlock_$ () ())}",
     )
   })
   describe("type array", () => {
-    testParse("answer: [number]", "{(::$_typeOf_$ :answer (::$_typeArray_$ #number))}")
+    testParse(
+      "answer: [number]",
+      "{(::$_typeOf_$ :answer (::$_typeArray_$ #number)); (::$_endOfOuterBlock_$ () ())}",
+    )
   })
   describe("type record", () => {
     testParse(
       "answer: {a: number, b: string}",
-      "{(::$_typeOf_$ :answer (::$_typeRecord_$ (::$_constructRecord_$ ('a': #number 'b': #string))))}",
+      "{(::$_typeOf_$ :answer (::$_typeRecord_$ (::$_constructRecord_$ ('a': #number 'b': #string)))); (::$_endOfOuterBlock_$ () ())}",
     )
   })
   describe("type constructor", () => {
     testParse(
       "answer: Age(number)",
-      "{(::$_typeOf_$ :answer (::$_typeConstructor_$ #Age (::$_constructArray_$ (#number))))}",
+      "{(::$_typeOf_$ :answer (::$_typeConstructor_$ #Age (::$_constructArray_$ #number))); (::$_endOfOuterBlock_$ () ())}",
     )
     testParse(
       "answer: Complex(number, number)",
-      "{(::$_typeOf_$ :answer (::$_typeConstructor_$ #Complex (::$_constructArray_$ (#number #number))))}",
+      "{(::$_typeOf_$ :answer (::$_typeConstructor_$ #Complex (::$_constructArray_$ #number #number))); (::$_endOfOuterBlock_$ () ())}",
     )
     testParse(
       "answer: Person({age: number, name: string})",
-      "{(::$_typeOf_$ :answer (::$_typeConstructor_$ #Person (::$_constructArray_$ ((::$_typeRecord_$ (::$_constructRecord_$ ('age': #number 'name': #string)))))))}",
+      "{(::$_typeOf_$ :answer (::$_typeConstructor_$ #Person (::$_constructArray_$ (::$_typeRecord_$ (::$_constructRecord_$ ('age': #number 'name': #string)))))); (::$_endOfOuterBlock_$ () ())}",
     )
     testParse(
       "weekend: Saturday | Sunday",
-      "{(::$_typeOf_$ :weekend (::$_typeOr_$ (::$_constructArray_$ ((::$_typeConstructor_$ #Saturday (::$_constructArray_$ ())) (::$_typeConstructor_$ #Sunday (::$_constructArray_$ ()))))))}",
+      "{(::$_typeOf_$ :weekend (::$_typeOr_$ (::$_constructArray_$ (::$_typeConstructor_$ #Saturday (::$_constructArray_$)) (::$_typeConstructor_$ #Sunday (::$_constructArray_$))))); (::$_endOfOuterBlock_$ () ())}",
     )
   })
   describe("type parenthesis", () => {
     //$ is introduced to avoid parenthesis
     testParse(
       "answer: (number|string)<-opaque",
-      "{(::$_typeOf_$ :answer (::$_typeModifier_opaque_$ (::$_typeOr_$ (::$_constructArray_$ (#number #string)))))}",
+      "{(::$_typeOf_$ :answer (::$_typeModifier_opaque_$ (::$_typeOr_$ (::$_constructArray_$ #number #string)))); (::$_endOfOuterBlock_$ () ())}",
     )
   })
   describe("squiggle expressions in type contracts", () => {
     testParse(
       "odds1 = [1,3,5]; odds2 = [7, 9]; type odds = number<-memberOf(concat(odds1, odds2))",
-      "{:odds1 = {(::$_constructArray_$ (1 3 5))}; :odds2 = {(::$_constructArray_$ (7 9))}; (::$_typeAlias_$ #odds (::$_typeModifier_memberOf_$ #number (::concat :odds1 :odds2)))}",
+      "{:odds1 = {(::$_constructArray_$ 1 3 5)}; :odds2 = {(::$_constructArray_$ 7 9)}; (::$_typeAlias_$ #odds (::$_typeModifier_memberOf_$ #number (::concat :odds1 :odds2))); (::$_endOfOuterBlock_$ () ())}",
     )
   })
 })

packages/squiggle-lang/__tests__/Reducer/Reducer_Peggy/Reducer_Peggy_TestHelpers.res

@@ -1,6 +1,5 @@
 module Expression = Reducer_Expression
 module ExpressionT = Reducer_Expression_T
-module ExpressionValue = ReducerInterface.InternalExpressionValue
 module Parse = Reducer_Peggy_Parse
 module Result = Belt.Result
 module ToExpression = Reducer_Peggy_ToExpression
@@ -10,12 +9,12 @@ open Jest
 open Expect
 
 let expectParseToBe = (expr, answer) =>
-  Parse.parse(expr)->Parse.toStringResult->expect->toBe(answer)
+  Parse.parse(expr, "test")->Parse.toStringResult->expect->toBe(answer)
 
 let testParse = (expr, answer) => test(expr, () => expectParseToBe(expr, answer))
 
-let expectToExpressionToBe = (expr, answer, ~v="_", ()) => {
+let expectExpressionToBe = (expr, answer, ~v="_", ()) => {
-  let rExpr = Parse.parse(expr)->Result.map(ToExpression.fromNode)
+  let rExpr = Parse.parse(expr, "test")->Result.map(ToExpression.fromNode)
   let a1 = rExpr->ExpressionT.toStringResultOkless
 
   if v == "_" {
@@ -23,30 +22,24 @@ let expectToExpressionToBe = (expr, answer, ~v="_", ()) => {
   } else {
     let a2 =
       rExpr
-      ->Result.flatMap(expr =>
+      ->E.R2.errMap(e => e->SqError.fromParseError)
-        Expression.reduceExpression(
+      ->Result.flatMap(expr => Expression.BackCompatible.evaluate(expr))
-          expr,
+      ->Reducer_Value.toStringResultOkless
-          ReducerInterface_StdLib.internalStdLib,
-          ExpressionValue.defaultEnvironment,
-        )
-      )
-      ->Reducer_Helpers.rRemoveDefaultsInternal
-      ->ExpressionValue.toStringResultOkless
     (a1, a2)->expect->toEqual((answer, v))
   }
 }
 
 let testToExpression = (expr, answer, ~v="_", ()) =>
-  test(expr, () => expectToExpressionToBe(expr, answer, ~v, ()))
+  test(expr, () => expectExpressionToBe(expr, answer, ~v, ()))
 
 module MyOnly = {
   let testParse = (expr, answer) => Only.test(expr, () => expectParseToBe(expr, answer))
   let testToExpression = (expr, answer, ~v="_", ()) =>
-    Only.test(expr, () => expectToExpressionToBe(expr, answer, ~v, ()))
+    Only.test(expr, () => expectExpressionToBe(expr, answer, ~v, ()))
 }
 
 module MySkip = {
   let testParse = (expr, answer) => Skip.test(expr, () => expectParseToBe(expr, answer))
   let testToExpression = (expr, answer, ~v="_", ()) =>
-    Skip.test(expr, () => expectToExpressionToBe(expr, answer, ~v, ()))
+    Skip.test(expr, () => expectExpressionToBe(expr, answer, ~v, ()))
 }

packages/squiggle-lang/__tests__/Reducer/Reducer_Peggy/Reducer_Peggy_ToExpression_outerBlock_test.res

@@ -0,0 +1,12 @@
+open Jest
+open Reducer_Peggy_TestHelpers
+
+// Note: these tests aren't useful anymore since outer block macro got deleted.
+// Probably can be removed or folded into other Peggy tests.
+describe("Peggy Outer Block", () => {
+  testToExpression("1", "1", ~v="1", ())
+  testToExpression("x=1", "x = {1}", ~v="()", ())
+  testToExpression("x=1; y=2", "x = {1}; y = {2}", ~v="()", ())
+  testToExpression("x=1; 2", "x = {1}; 2", ~v="2", ())
+  testToExpression("x={a=1; a}; x", "x = {a = {1}; a}; x", ~v="1", ())
+})

packages/squiggle-lang/__tests__/Reducer/Reducer_Peggy/Reducer_Peggy_ToExpression_test.res

@@ -1,5 +1,4 @@
 module Bindings = Reducer_Bindings
-module InternalExpressionValue = ReducerInterface_InternalExpressionValue
 
 open Jest
 open Reducer_Peggy_TestHelpers
@@ -7,147 +6,121 @@ open Reducer_Peggy_TestHelpers
 describe("Peggy to Expression", () => {
   describe("literals operators parenthesis", () => {
     // Note that there is always an outer block. Otherwise, external bindings are ignored at the first statement
-    testToExpression("1", "{1}", ~v="1", ())
+    testToExpression("1", "1", ~v="1", ())
-    testToExpression("'hello'", "{'hello'}", ~v="'hello'", ())
+    testToExpression("'hello'", "'hello'", ~v="'hello'", ())
-    testToExpression("true", "{true}", ~v="true", ())
+    testToExpression("true", "true", ~v="true", ())
-    testToExpression("1+2", "{(:add 1 2)}", ~v="3", ())
+    testToExpression("1+2", "(add)(1, 2)", ~v="3", ())
-    testToExpression("add(1,2)", "{(:add 1 2)}", ~v="3", ())
+    testToExpression("add(1,2)", "(add)(1, 2)", ~v="3", ())
-    testToExpression("(1)", "{1}", ())
+    testToExpression("(1)", "1", ())
-    testToExpression("(1+2)", "{(:add 1 2)}", ())
+    testToExpression("(1+2)", "(add)(1, 2)", ())
   })
 
   describe("unary", () => {
-    testToExpression("-1", "{(:unaryMinus 1)}", ~v="-1", ())
+    testToExpression("-1", "(unaryMinus)(1)", ~v="-1", ())
-    testToExpression("!true", "{(:not true)}", ~v="false", ())
+    testToExpression("!true", "(not)(true)", ~v="false", ())
-    testToExpression("1 + -1", "{(:add 1 (:unaryMinus 1))}", ~v="0", ())
+    testToExpression("1 + -1", "(add)(1, (unaryMinus)(1))", ~v="0", ())
-    testToExpression("-a[0]", "{(:unaryMinus (:$_atIndex_$ :a 0))}", ())
+    testToExpression("-a[0]", "(unaryMinus)(($_atIndex_$)(a, 0))", ())
   })
 
   describe("multi-line", () => {
-    testToExpression("x=1; 2", "{(:$_let_$ :x {1}); 2}", ~v="2", ())
+    testToExpression("x=1; 2", "x = {1}; 2", ~v="2", ())
-    testToExpression("x=1; y=2", "{(:$_let_$ :x {1}); (:$_let_$ :y {2})}", ~v="@{x: 1,y: 2}", ())
+    testToExpression("x=1; y=2", "x = {1}; y = {2}", ())
   })
 
   describe("variables", () => {
-    testToExpression("x = 1", "{(:$_let_$ :x {1})}", ~v="@{x: 1}", ())
+    testToExpression("x = 1", "x = {1}", ())
-    testToExpression("x", "{:x}", ~v=":x", ()) //TODO: value should return error
+    testToExpression("x", "x", ~v="Error(x is not defined)", ()) //TODO: value should return error
-    testToExpression("x = 1; x", "{(:$_let_$ :x {1}); :x}", ~v="1", ())
+    testToExpression("x = 1; x", "x = {1}; x", ~v="1", ())
   })
 
   describe("functions", () => {
-    testToExpression(
+    testToExpression("identity(x) = x", "identity = {|x| {x}}", ()) // Function definitions become lambda assignments
-      "identity(x) = x",
+    testToExpression("identity(x)", "(identity)(x)", ()) // Note value returns error properly
-      "{(:$_let_$ :identity (:$$_lambda_$$ [x] {:x}))}",
-      ~v="@{identity: lambda(x=>internal code)}",
-      (),
-    ) // Function definitions become lambda assignments
-    testToExpression("identity(x)", "{(:identity :x)}", ()) // Note value returns error properly
     testToExpression(
       "f(x) = x> 2 ? 0 : 1; f(3)",
-      "{(:$_let_$ :f (:$$_lambda_$$ [x] {(:$$_ternary_$$ (:larger :x 2) 0 1)})); (:f 3)}",
+      "f = {|x| {(larger)(x, 2) ? (0) : (1)}}; (f)(3)",
       ~v="0",
       (),
     )
   })
 
   describe("arrays", () => {
-    testToExpression("[]", "{(:$_constructArray_$ ())}", ~v="[]", ())
+    testToExpression("[]", "[]", ~v="[]", ())
-    testToExpression("[0, 1, 2]", "{(:$_constructArray_$ (0 1 2))}", ~v="[0,1,2]", ())
+    testToExpression("[0, 1, 2]", "[0, 1, 2]", ~v="[0,1,2]", ())
-    testToExpression(
+    testToExpression("['hello', 'world']", "['hello', 'world']", ~v="['hello','world']", ())
-      "['hello', 'world']",
+    testToExpression("([0,1,2])[1]", "($_atIndex_$)([0, 1, 2], 1)", ~v="1", ())
-      "{(:$_constructArray_$ ('hello' 'world'))}",
-      ~v="['hello','world']",
-      (),
-    )
-    testToExpression("([0,1,2])[1]", "{(:$_atIndex_$ (:$_constructArray_$ (0 1 2)) 1)}", ~v="1", ())
   })
 
   describe("records", () => {
-    testToExpression(
+    testToExpression("{a: 1, b: 2}", "{'a': 1, 'b': 2}", ~v="{a: 1,b: 2}", ())
-      "{a: 1, b: 2}",
+    testToExpression("{1+0: 1, 2+0: 2}", "{(add)(1, 0): 1, (add)(2, 0): 2}", ()) // key can be any expression
-      "{(:$_constructRecord_$ (('a' 1) ('b' 2)))}",
+    testToExpression("record.property", "($_atIndex_$)(record, 'property')", ())
-      ~v="{a: 1,b: 2}",
-      (),
-    )
-    testToExpression(
-      "{1+0: 1, 2+0: 2}",
-      "{(:$_constructRecord_$ (((:add 1 0) 1) ((:add 2 0) 2)))}",
-      (),
-    ) // key can be any expression
-    testToExpression("record.property", "{(:$_atIndex_$ :record 'property')}", ())
     testToExpression(
       "record={property: 1}; record.property",
-      "{(:$_let_$ :record {(:$_constructRecord_$ (('property' 1)))}); (:$_atIndex_$ :record 'property')}",
+      "record = {{'property': 1}}; ($_atIndex_$)(record, 'property')",
       ~v="1",
       (),
     )
   })
 
   describe("comments", () => {
-    testToExpression("1 # This is a line comment", "{1}", ~v="1", ())
+    testToExpression("1 # This is a line comment", "1", ~v="1", ())
-    testToExpression("1 // This is a line comment", "{1}", ~v="1", ())
+    testToExpression("1 // This is a line comment", "1", ~v="1", ())
-    testToExpression("1 /* This is a multi line comment */", "{1}", ~v="1", ())
+    testToExpression("1 /* This is a multi line comment */", "1", ~v="1", ())
-    testToExpression("/* This is a multi line comment */ 1", "{1}", ~v="1", ())
+    testToExpression("/* This is a multi line comment */ 1", "1", ~v="1", ())
   })
 
   describe("ternary operator", () => {
-    testToExpression("true ? 1 : 0", "{(:$$_ternary_$$ true 1 0)}", ~v="1", ())
+    testToExpression("true ? 1 : 0", "true ? (1) : (0)", ~v="1", ())
-    testToExpression("false ? 1 : 0", "{(:$$_ternary_$$ false 1 0)}", ~v="0", ())
+    testToExpression("false ? 1 : 0", "false ? (1) : (0)", ~v="0", ())
-    testToExpression(
+    testToExpression("true ? 1 : false ? 2 : 0", "true ? (1) : (false ? (2) : (0))", ~v="1", ()) // nested ternary
-      "true ? 1 : false ? 2 : 0",
+    testToExpression("false ? 1 : false ? 2 : 0", "false ? (1) : (false ? (2) : (0))", ~v="0", ()) // nested ternary
-      "{(:$$_ternary_$$ true 1 (:$$_ternary_$$ false 2 0))}",
+    describe(
-      ~v="1",
+      "ternary bindings",
-      (),
+      () => {
-    ) // nested ternary
+        testToExpression(
-    testToExpression(
+          // expression binding
-      "false ? 1 : false ? 2 : 0",
+          "f(a) = a > 5 ? 1 : 0; f(6)",
-      "{(:$$_ternary_$$ false 1 (:$$_ternary_$$ false 2 0))}",
+          "f = {|a| {(larger)(a, 5) ? (1) : (0)}}; (f)(6)",
-      ~v="0",
+          ~v="1",
-      (),
+          (),
-    ) // nested ternary
+        )
-    describe("ternary bindings", () => {
+        testToExpression(
-      testToExpression(
+          // when true binding
-        // expression binding
+          "f(a) = a > 5 ? a : 0; f(6)",
-        "f(a) = a > 5 ? 1 : 0; f(6)",
+          "f = {|a| {(larger)(a, 5) ? (a) : (0)}}; (f)(6)",
-        "{(:$_let_$ :f (:$$_lambda_$$ [a] {(:$$_ternary_$$ (:larger :a 5) 1 0)})); (:f 6)}",
+          ~v="6",
-        ~v="1",
+          (),
-        (),
+        )
-      )
+        testToExpression(
-      testToExpression(
+          // when false binding
-        // when true binding
+          "f(a) = a < 5 ? 1 : a; f(6)",
-        "f(a) = a > 5 ? a : 0; f(6)",
+          "f = {|a| {(smaller)(a, 5) ? (1) : (a)}}; (f)(6)",
-        "{(:$_let_$ :f (:$$_lambda_$$ [a] {(:$$_ternary_$$ (:larger :a 5) :a 0)})); (:f 6)}",
+          ~v="6",
-        ~v="6",
+          (),
-        (),
+        )
-      )
+      },
-      testToExpression(
+    )
-        // when false binding
-        "f(a) = a < 5 ? 1 : a; f(6)",
-        "{(:$_let_$ :f (:$$_lambda_$$ [a] {(:$$_ternary_$$ (:smaller :a 5) 1 :a)})); (:f 6)}",
-        ~v="6",
-        (),
-      )
-    })
   })
 
   describe("if then else", () => {
-    testToExpression("if true then 2 else 3", "{(:$$_ternary_$$ true {2} {3})}", ())
+    testToExpression("if true then 2 else 3", "true ? ({2}) : ({3})", ())
-    testToExpression("if true then {2} else {3}", "{(:$$_ternary_$$ true {2} {3})}", ())
+    testToExpression("if true then {2} else {3}", "true ? ({2}) : ({3})", ())
     testToExpression(
       "if false then {2} else if false then {4} else {5}",
-      "{(:$$_ternary_$$ false {2} (:$$_ternary_$$ false {4} {5}))}",
+      "false ? ({2}) : (false ? ({4}) : ({5}))",
       (),
     ) //nested if
   })
 
   describe("pipe", () => {
-    testToExpression("1 -> add(2)", "{(:add 1 2)}", ~v="3", ())
+    testToExpression("1 -> add(2)", "(add)(1, 2)", ~v="3", ())
-    testToExpression("-1 -> add(2)", "{(:add (:unaryMinus 1) 2)}", ~v="1", ()) // note that unary has higher priority naturally
+    testToExpression("-1 -> add(2)", "(add)((unaryMinus)(1), 2)", ~v="1", ()) // note that unary has higher priority naturally
-    testToExpression("1 -> add(2) * 3", "{(:multiply (:add 1 2) 3)}", ~v="9", ())
+    testToExpression("1 -> add(2) * 3", "(multiply)((add)(1, 2), 3)", ~v="9", ())
   })
 
   describe("elixir pipe", () => {
-    testToExpression("1 |> add(2)", "{(:add 1 2)}", ~v="3", ())
+    testToExpression("1 |> add(2)", "(add)(1, 2)", ~v="3", ())
   })
 
   // see testParse for priorities of to and credibleIntervalToDistribution
@@ -157,43 +130,28 @@ describe("Peggy to Expression", () => {
     // Like lambdas they have a local scope.
     testToExpression(
       "y=99; x={y=1; y}",
-      "{(:$_let_$ :y {99}); (:$_let_$ :x {(:$_let_$ :y {1}); :y})}",
+      "y = {99}; x = {y = {1}; y}",
-      ~v="@{x: 1,y: 99}",
+      // "{(:$_let_$ :y {99}); (:$_let_$ :x {(:$_let_$ :y {1}); :y}); (:$_endOfOuterBlock_$ () ())}",
       (),
     )
   })
 
   describe("lambda", () => {
-    testToExpression("{|x| x}", "{(:$$_lambda_$$ [x] {:x})}", ~v="lambda(x=>internal code)", ())
+    testToExpression("{|x| x}", "{|x| x}", ~v="lambda(x=>internal code)", ())
-    testToExpression(
+    testToExpression("f={|x| x}", "f = {|x| x}", ())
-      "f={|x| x}",
+    testToExpression("f(x)=x", "f = {|x| {x}}", ()) // Function definitions are lambda assignments
-      "{(:$_let_$ :f {(:$$_lambda_$$ [x] {:x})})}",
+    testToExpression("f(x)=x ? 1 : 0", "f = {|x| {x ? (1) : (0)}}", ())
-      ~v="@{f: lambda(x=>internal code)}",
-      (),
-    )
-    testToExpression(
-      "f(x)=x",
-      "{(:$_let_$ :f (:$$_lambda_$$ [x] {:x}))}",
-      ~v="@{f: lambda(x=>internal code)}",
-      (),
-    ) // Function definitions are lambda assignments
-    testToExpression(
-      "f(x)=x ? 1 : 0",
-      "{(:$_let_$ :f (:$$_lambda_$$ [x] {(:$$_ternary_$$ :x 1 0)}))}",
-      ~v="@{f: lambda(x=>internal code)}",
-      (),
-    )
   })
 
   describe("module", () => {
     // testToExpression("Math.pi", "{:Math.pi}", ~v="3.141592653589793", ())
     // Only.test("stdlibrary", () => {
-    //   ReducerInterface_StdLib.internalStdLib
+    //  SquiggleLibrary_StdLib.stdLib
-    //   ->IEvBindings
+    //  ->IEvBindings
-    //   ->InternalExpressionValue.toString
+    //  ->Reducer_Value.toString
-    //   ->expect
+    //  ->expect
-    //   ->toBe("")
+    //  ->toBe("")
     // })
-    testToExpression("Math.pi", "{:Math.pi}", ~v="3.141592653589793", ())
+    testToExpression("Math.pi", "Math.pi", ~v="3.141592653589793", ())
   })
 })

packages/squiggle-lang/__tests__/Reducer/Reducer_Peggy/Reducer_Peggy_ToExpression_type_test.res

@@ -5,92 +5,92 @@ describe("Peggy Types to Expression", () => {
   describe("type of", () => {
     testToExpression(
       "p: number",
-      "{(:$_typeOf_$ :p #number)}",
+      "{(:$_typeOf_$ :p #number); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {p: #number}}",
+      // ~v="@{_typeReferences_: {p: #number}}",
       (),
     )
   })
   describe("type alias", () => {
     testToExpression(
       "type index=number",
-      "{(:$_typeAlias_$ #index #number)}",
+      "{(:$_typeAlias_$ #index #number); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeAliases_: {index: #number}}",
+      // ~v="@{_typeAliases_: {index: #number}}",
       (),
     )
   })
   describe("type or", () => {
     testToExpression(
       "answer: number|string|distribution",
-      "{(:$_typeOf_$ :answer (:$_typeOr_$ (:$_constructArray_$ (#number #string #distribution))))}",
+      "{(:$_typeOf_$ :answer (:$_typeOr_$ (:$_constructArray_$ #number #string #distribution))); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {answer: {typeOr: [#number,#string,#distribution],typeTag: 'typeOr'}}}",
+      // ~v="@{_typeReferences_: {answer: {typeOr: [#number,#string,#distribution],typeTag: 'typeOr'}}}",
       (),
     )
   })
   describe("type function", () => {
     testToExpression(
       "f: number=>number=>number",
-      "{(:$_typeOf_$ :f (:$_typeFunction_$ (:$_constructArray_$ (#number #number #number))))}",
+      "{(:$_typeOf_$ :f (:$_typeFunction_$ (:$_constructArray_$ #number #number #number))); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {f: {inputs: [#number,#number],output: #number,typeTag: 'typeFunction'}}}",
+      // ~v="@{_typeReferences_: {f: {inputs: [#number,#number],output: #number,typeTag: 'typeFunction'}}}",
       (),
     )
     testToExpression(
       "f: number=>number",
-      "{(:$_typeOf_$ :f (:$_typeFunction_$ (:$_constructArray_$ (#number #number))))}",
+      "{(:$_typeOf_$ :f (:$_typeFunction_$ (:$_constructArray_$ #number #number))); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {f: {inputs: [#number],output: #number,typeTag: 'typeFunction'}}}",
+      // ~v="@{_typeReferences_: {f: {inputs: [#number],output: #number,typeTag: 'typeFunction'}}}",
       (),
     )
   })
   describe("high priority contract", () => {
     testToExpression(
       "answer: number<-min(1)<-max(100)|string",
-      "{(:$_typeOf_$ :answer (:$_typeOr_$ (:$_constructArray_$ ((:$_typeModifier_max_$ (:$_typeModifier_min_$ #number 1) 100) #string))))}",
+      "{(:$_typeOf_$ :answer (:$_typeOr_$ (:$_constructArray_$ (:$_typeModifier_max_$ (:$_typeModifier_min_$ #number 1) 100) #string))); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {answer: {typeOr: [{max: 100,min: 1,typeIdentifier: #number,typeTag: 'typeIdentifier'},#string],typeTag: 'typeOr'}}}",
+      // ~v="@{_typeReferences_: {answer: {typeOr: [{max: 100,min: 1,typeIdentifier: #number,typeTag: 'typeIdentifier'},#string],typeTag: 'typeOr'}}}",
       (),
     )
     testToExpression(
       "answer: number<-memberOf([1,3,5])",
-      "{(:$_typeOf_$ :answer (:$_typeModifier_memberOf_$ #number (:$_constructArray_$ (1 3 5))))}",
+      "{(:$_typeOf_$ :answer (:$_typeModifier_memberOf_$ #number (:$_constructArray_$ 1 3 5))); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {answer: {memberOf: [1,3,5],typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
+      // ~v="@{_typeReferences_: {answer: {memberOf: [1,3,5],typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
       (),
     )
     testToExpression(
       "answer: number<-min(1)",
-      "{(:$_typeOf_$ :answer (:$_typeModifier_min_$ #number 1))}",
+      "{(:$_typeOf_$ :answer (:$_typeModifier_min_$ #number 1)); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {answer: {min: 1,typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
+      // ~v="@{_typeReferences_: {answer: {min: 1,typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
       (),
     )
     testToExpression(
       "answer: number<-max(10)",
-      "{(:$_typeOf_$ :answer (:$_typeModifier_max_$ #number 10))}",
+      "{(:$_typeOf_$ :answer (:$_typeModifier_max_$ #number 10)); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {answer: {max: 10,typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
+      // ~v="@{_typeReferences_: {answer: {max: 10,typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
       (),
     )
     testToExpression(
       "answer: number<-min(1)<-max(10)",
-      "{(:$_typeOf_$ :answer (:$_typeModifier_max_$ (:$_typeModifier_min_$ #number 1) 10))}",
+      "{(:$_typeOf_$ :answer (:$_typeModifier_max_$ (:$_typeModifier_min_$ #number 1) 10)); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {answer: {max: 10,min: 1,typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
+      // ~v="@{_typeReferences_: {answer: {max: 10,min: 1,typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
       (),
     )
     testToExpression(
       "answer: number<-max(10)<-min(1)",
-      "{(:$_typeOf_$ :answer (:$_typeModifier_min_$ (:$_typeModifier_max_$ #number 10) 1))}",
+      "{(:$_typeOf_$ :answer (:$_typeModifier_min_$ (:$_typeModifier_max_$ #number 10) 1)); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {answer: {max: 10,min: 1,typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
+      // ~v="@{_typeReferences_: {answer: {max: 10,min: 1,typeIdentifier: #number,typeTag: 'typeIdentifier'}}}",
       (),
     )
   })
   describe("low priority contract", () => {
     testToExpression(
       "answer: number | string $ opaque",
-      "{(:$_typeOf_$ :answer (:$_typeModifier_opaque_$ (:$_typeOr_$ (:$_constructArray_$ (#number #string)))))}",
+      "{(:$_typeOf_$ :answer (:$_typeModifier_opaque_$ (:$_typeOr_$ (:$_constructArray_$ #number #string)))); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeReferences_: {answer: {opaque: true,typeOr: [#number,#string],typeTag: 'typeOr'}}}",
+      // ~v="@{_typeReferences_: {answer: {opaque: true,typeOr: [#number,#string],typeTag: 'typeOr'}}}",
       (),
     )
   })
   describe("squiggle expressions in type contracts", () => {
     testToExpression(
       "odds1 = [1,3,5]; odds2 = [7, 9]; type odds = number<-memberOf(concat(odds1, odds2))",
-      "{(:$_let_$ :odds1 {(:$_constructArray_$ (1 3 5))}); (:$_let_$ :odds2 {(:$_constructArray_$ (7 9))}); (:$_typeAlias_$ #odds (:$_typeModifier_memberOf_$ #number (:concat :odds1 :odds2)))}",
+      "{(:$_let_$ :odds1 {(:$_constructArray_$ 1 3 5)}); (:$_let_$ :odds2 {(:$_constructArray_$ 7 9)}); (:$_typeAlias_$ #odds (:$_typeModifier_memberOf_$ #number (:concat :odds1 :odds2))); (:$_endOfOuterBlock_$ () ())}",
-      ~v="@{_typeAliases_: {odds: {memberOf: [1,3,5,7,9],typeIdentifier: #number,typeTag: 'typeIdentifier'}},odds1: [1,3,5],odds2: [7,9]}",
+      // ~v="@{_typeAliases_: {odds: {memberOf: [1,3,5,7,9],typeIdentifier: #number,typeTag: 'typeIdentifier'}},odds1: [1,3,5],odds2: [7,9]}",
       (),
     )
   })

packages/squiggle-lang/__tests__/Reducer/Reducer_Peggy/Reducer_Peggy_ToExpression_void_test.res

@@ -3,18 +3,18 @@ open Reducer_Peggy_TestHelpers
 
 describe("Peggy void", () => {
   //literal
-  testToExpression("()", "{()}", ~v="()", ())
+  testToExpression("()", "()", ~v="()", ())
   testToExpression(
     "fn()=1",
-    "{(:$_let_$ :fn (:$$_lambda_$$ [_] {1}))}",
+    "fn = {|_| {1}}",
-    ~v="@{fn: lambda(_=>internal code)}",
+    // ~v="@{fn: lambda(_=>internal code)}",
     (),
   )
-  testToExpression("fn()=1; fn()", "{(:$_let_$ :fn (:$$_lambda_$$ [_] {1})); (:fn ())}", ~v="1", ())
+  testToExpression("fn()=1; fn()", "fn = {|_| {1}}; (fn)(())", ~v="1", ())
   testToExpression(
     "fn(a)=(); call fn(1)",
-    "{(:$_let_$ :fn (:$$_lambda_$$ [a] {()})); (:$_let_$ :_ {(:fn 1)})}",
+    "fn = {|a| {()}}; _ = {(fn)(1)}",
-    ~v="@{_: (),fn: lambda(a=>internal code)}",
+    // ~v="@{_: (),fn: lambda(a=>internal code)}",
     (),
   )
 })

packages/squiggle-lang/__tests__/Reducer/Reducer_TestHelpers.res

@@ -1,6 +1,5 @@
+module Expression = Reducer_Expression
 module ExpressionT = Reducer_Expression_T
-module ExternalExpressionValue = ReducerInterface.ExternalExpressionValue
-module ErrorValue = Reducer_ErrorValue
 
 open Jest
 open Expect
@@ -8,30 +7,22 @@ open Expect
 let unwrapRecord = rValue =>
   rValue->Belt.Result.flatMap(value =>
     switch value {
-    | ExternalExpressionValue.EvRecord(aRecord) => Ok(aRecord)
+    | Reducer_T.IEvRecord(aRecord) => Ok(aRecord)
-    | _ => ErrorValue.RETodo("TODO: External bindings must be returned")->Error
+    | _ => SqError.Message.RETodo("TODO: Internal bindings must be returned")->Error
     }
   )
 
-let expectParseToBe = (expr: string, answer: string) =>
+let expectParseToBe = (code: string, answer: string) =>
-  Reducer.parse(expr)->ExpressionT.toStringResult->expect->toBe(answer)
+  Expression.BackCompatible.parse(code)->ExpressionT.toStringResult->expect->toBe(answer)
 
-let expectEvalToBe = (expr: string, answer: string) =>
+let expectEvalToBe = (code: string, answer: string) =>
-  Reducer.evaluate(expr)
+  Expression.BackCompatible.evaluateString(code)->Reducer_Value.toStringResult->expect->toBe(answer)
-  ->Reducer_Helpers.rRemoveDefaultsExternal
+
-  ->ExternalExpressionValue.toStringResult
+let expectEvalError = (code: string) =>
+  Expression.BackCompatible.evaluateString(code)
+  ->Reducer_Value.toStringResult
   ->expect
-  ->toBe(answer)
+  ->toMatch("Error\\(")
-
-let expectEvalError = (expr: string) =>
-  Reducer.evaluate(expr)->ExternalExpressionValue.toStringResult->expect->toMatch("Error\(")
-
-let expectEvalBindingsToBe = (expr: string, bindings: Reducer.externalBindings, answer: string) =>
-  Reducer.evaluateUsingOptions(expr, ~externalBindings=Some(bindings), ~environment=None)
-  ->Reducer_Helpers.rRemoveDefaultsExternal
-  ->ExternalExpressionValue.toStringResult
-  ->expect
-  ->toBe(answer)
 
 let testParseToBe = (expr, answer) => test(expr, () => expectParseToBe(expr, answer))
 let testDescriptionParseToBe = (desc, expr, answer) =>
@@ -40,18 +31,12 @@ let testDescriptionParseToBe = (desc, expr, answer) =>
 let testEvalError = expr => test(expr, () => expectEvalError(expr))
 let testEvalToBe = (expr, answer) => test(expr, () => expectEvalToBe(expr, answer))
 let testDescriptionEvalToBe = (desc, expr, answer) => test(desc, () => expectEvalToBe(expr, answer))
-let testEvalBindingsToBe = (expr, bindingsList, answer) =>
-  test(expr, () => expectEvalBindingsToBe(expr, bindingsList->Js.Dict.fromList, answer))
 
 module MySkip = {
   let testParseToBe = (expr, answer) => Skip.test(expr, () => expectParseToBe(expr, answer))
   let testEvalToBe = (expr, answer) => Skip.test(expr, () => expectEvalToBe(expr, answer))
-  let testEvalBindingsToBe = (expr, bindingsList, answer) =>
-    Skip.test(expr, () => expectEvalBindingsToBe(expr, bindingsList->Js.Dict.fromList, answer))
 }
 module MyOnly = {
   let testParseToBe = (expr, answer) => Only.test(expr, () => expectParseToBe(expr, answer))
   let testEvalToBe = (expr, answer) => Only.test(expr, () => expectEvalToBe(expr, answer))
-  let testEvalBindingsToBe = (expr, bindingsList, answer) =>
-    Only.test(expr, () => expectEvalBindingsToBe(expr, bindingsList->Js.Dict.fromList, answer))
 }

packages/squiggle-lang/__tests__/Reducer/Reducer_TestMacroHelpers.res

@@ -1,88 +0,0 @@
-open Jest
-open Expect
-
-module BindingsReplacer = Reducer_Expression_BindingsReplacer
-module Expression = Reducer_Expression
-// module ExpressionValue = ReducerInterface.ExpressionValue
-module InternalExpressionValue = ReducerInterface.InternalExpressionValue
-module ExpressionWithContext = Reducer_ExpressionWithContext
-module Macro = Reducer_Expression_Macro
-module T = Reducer_Expression_T
-module Bindings = Reducer_Bindings
-
-let testMacro_ = (
-  tester,
-  bindArray: array<(string, InternalExpressionValue.t)>,
-  expr: T.expression,
-  expectedCode: string,
-) => {
-  let bindings = Bindings.fromArray(bindArray)
-  tester(expr->T.toString, () =>
-    expr
-    ->Macro.expandMacroCall(
-      bindings,
-      InternalExpressionValue.defaultEnvironment,
-      Expression.reduceExpression,
-    )
-    ->ExpressionWithContext.toStringResult
-    ->expect
-    ->toEqual(expectedCode)
-  )
-}
-
-let testMacroEval_ = (
-  tester,
-  bindArray: array<(string, InternalExpressionValue.t)>,
-  expr: T.expression,
-  expectedValue: string,
-) => {
-  let bindings = Bindings.fromArray(bindArray)
-  tester(expr->T.toString, () =>
-    expr
-    ->Macro.doMacroCall(
-      bindings,
-      InternalExpressionValue.defaultEnvironment,
-      Expression.reduceExpression,
-    )
-    ->InternalExpressionValue.toStringResult
-    ->expect
-    ->toEqual(expectedValue)
-  )
-}
-
-let testMacro = (
-  bindArray: array<(string, InternalExpressionValue.t)>,
-  expr: T.expression,
-  expectedExpr: string,
-) => testMacro_(test, bindArray, expr, expectedExpr)
-let testMacroEval = (
-  bindArray: array<(string, InternalExpressionValue.t)>,
-  expr: T.expression,
-  expectedValue: string,
-) => testMacroEval_(test, bindArray, expr, expectedValue)
-
-module MySkip = {
-  let testMacro = (
-    bindArray: array<(string, InternalExpressionValue.t)>,
-    expr: T.expression,
-    expectedExpr: string,
-  ) => testMacro_(Skip.test, bindArray, expr, expectedExpr)
-  let testMacroEval = (
-    bindArray: array<(string, InternalExpressionValue.t)>,
-    expr: T.expression,
-    expectedValue: string,
-  ) => testMacroEval_(Skip.test, bindArray, expr, expectedValue)
-}
-
-module MyOnly = {
-  let testMacro = (
-    bindArray: array<(string, InternalExpressionValue.t)>,
-    expr: T.expression,
-    expectedExpr: string,
-  ) => testMacro_(Only.test, bindArray, expr, expectedExpr)
-  let testMacroEval = (
-    bindArray: array<(string, InternalExpressionValue.t)>,
-    expr: T.expression,
-    expectedValue: string,
-  ) => testMacroEval_(Only.test, bindArray, expr, expectedValue)
-}

packages/squiggle-lang/__tests__/Reducer/Reducer_Type/Reducer_Type_Compile_test.res

@@ -1,52 +0,0 @@
-module Expression = Reducer_Expression
-module InternalExpressionValue = ReducerInterface_InternalExpressionValue
-module Bindings = Reducer_Bindings
-module T = Reducer_Type_T
-module TypeCompile = Reducer_Type_Compile
-
-open Jest
-open Expect
-
-let myIevEval = (aTypeSourceCode: string) =>
-  TypeCompile.ievFromTypeExpression(aTypeSourceCode, Expression.reduceExpression)
-let myIevEvalToString = (aTypeSourceCode: string) =>
-  myIevEval(aTypeSourceCode)->InternalExpressionValue.toStringResult
-
-let myIevExpectEqual = (aTypeSourceCode, answer) =>
-  expect(myIevEvalToString(aTypeSourceCode))->toEqual(answer)
-
-let myIevTest = (test, aTypeSourceCode, answer) =>
-  test(aTypeSourceCode, () => myIevExpectEqual(aTypeSourceCode, answer))
-
-let myTypeEval = (aTypeSourceCode: string) =>
-  TypeCompile.fromTypeExpression(aTypeSourceCode, Expression.reduceExpression)
-let myTypeEvalToString = (aTypeSourceCode: string) => myTypeEval(aTypeSourceCode)->T.toStringResult
-
-let myTypeExpectEqual = (aTypeSourceCode, answer) =>
-  expect(myTypeEvalToString(aTypeSourceCode))->toEqual(answer)
-
-let myTypeTest = (test, aTypeSourceCode, answer) =>
-  test(aTypeSourceCode, () => myTypeExpectEqual(aTypeSourceCode, answer))
-
-//   | ItTypeIdentifier(string)
-myTypeTest(test, "number", "number")
-myTypeTest(test, "(number)", "number")
-//   | ItModifiedType({modifiedType: iType})
-myIevTest(test, "number<-min(0)", "Ok({min: 0,typeIdentifier: #number,typeTag: 'typeIdentifier'})")
-myTypeTest(test, "number<-min(0)", "number<-min(0)")
-//   | ItTypeOr({typeOr: array<iType>})
-myTypeTest(test, "number | string", "(number | string)")
-//   | ItTypeFunction({inputs: array<iType>, output: iType})
-myTypeTest(test, "number => number => number", "(number => number => number)")
-//   | ItTypeArray({element: iType})
-myIevTest(test, "[number]", "Ok({element: #number,typeTag: 'typeArray'})")
-myTypeTest(test, "[number]", "[number]")
-//   | ItTypeTuple({elements: array<iType>})
-myTypeTest(test, "[number, string]", "[number, string]")
-//   | ItTypeRecord({properties: Belt.Map.String.t<iType>})
-myIevTest(
-  test,
-  "{age: number, name: string}",
-  "Ok({properties: {age: #number,name: #string},typeTag: 'typeRecord'})",
-)
-myTypeTest(test, "{age: number, name: string}", "{age: number, name: string}")

packages/squiggle-lang/__tests__/Reducer/Reducer_Type/Reducer_Type_TypeChecker_arguments_test.res

@@ -1,41 +0,0 @@
-module Expression = Reducer_Expression
-module ExpressionT = Reducer_Expression_T
-module ErrorValue = Reducer_ErrorValue
-module InternalExpressionValue = ReducerInterface_InternalExpressionValue
-module Bindings = Reducer_Bindings
-module T = Reducer_Type_T
-module TypeChecker = Reducer_Type_TypeChecker
-
-open Jest
-open Expect
-
-let checkArgumentsSourceCode = (aTypeSourceCode: string, sourceCode: string): result<
-  'v,
-  ErrorValue.t,
-> => {
-  let reducerFn = Expression.reduceExpression
-  let rResult =
-    Reducer.parse(sourceCode)->Belt.Result.flatMap(expr =>
-      reducerFn(expr, Bindings.emptyBindings, InternalExpressionValue.defaultEnvironment)
-    )
-  rResult->Belt.Result.flatMap(result =>
-    switch result {
-    | IEvArray(args) => TypeChecker.checkArguments(aTypeSourceCode, args, reducerFn)
-    | _ => Js.Exn.raiseError("Arguments has to be an array")
-    }
-  )
-}
-
-let myCheckArguments = (aTypeSourceCode: string, sourceCode: string): string =>
-  switch checkArgumentsSourceCode(aTypeSourceCode, sourceCode) {
-  | Ok(_) => "Ok"
-  | Error(error) => ErrorValue.errorToString(error)
-  }
-
-let myCheckArgumentsExpectEqual = (aTypeSourceCode, sourceCode, answer) =>
-  expect(myCheckArguments(aTypeSourceCode, sourceCode))->toEqual(answer)
-
-let myCheckArgumentsTest = (test, aTypeSourceCode, sourceCode, answer) =>
-  test(aTypeSourceCode, () => myCheckArgumentsExpectEqual(aTypeSourceCode, sourceCode, answer))
-
-myCheckArgumentsTest(test, "number=>number=>number", "[1,2]", "Ok")

packages/squiggle-lang/__tests__/Reducer/Reducer_Type/Reducer_Type_TypeChecker_test.res

@@ -1,72 +0,0 @@
-module Expression = Reducer_Expression
-module ExpressionT = Reducer_Expression_T
-module ErrorValue = Reducer_ErrorValue
-module InternalExpressionValue = ReducerInterface_InternalExpressionValue
-module Bindings = Reducer_Bindings
-module T = Reducer_Type_T
-module TypeChecker = Reducer_Type_TypeChecker
-
-open Jest
-open Expect
-
-// In development, you are expected to use TypeChecker.isTypeOf(aTypeSourceCode, result, reducerFn).
-// isTypeOfSourceCode is written to use strings instead of expression values.
-
-let isTypeOfSourceCode = (aTypeSourceCode: string, sourceCode: string): result<
-  'v,
-  ErrorValue.t,
-> => {
-  let reducerFn = Expression.reduceExpression
-  let rResult =
-    Reducer.parse(sourceCode)->Belt.Result.flatMap(expr =>
-      reducerFn(expr, Bindings.emptyBindings, InternalExpressionValue.defaultEnvironment)
-    )
-  rResult->Belt.Result.flatMap(result => TypeChecker.isTypeOf(aTypeSourceCode, result, reducerFn))
-}
-
-let myTypeCheck = (aTypeSourceCode: string, sourceCode: string): string =>
-  switch isTypeOfSourceCode(aTypeSourceCode, sourceCode) {
-  | Ok(_) => "Ok"
-  | Error(error) => ErrorValue.errorToString(error)
-  }
-
-let myTypeCheckExpectEqual = (aTypeSourceCode, sourceCode, answer) =>
-  expect(myTypeCheck(aTypeSourceCode, sourceCode))->toEqual(answer)
-
-let myTypeCheckTest = (test, aTypeSourceCode, sourceCode, answer) =>
-  test(aTypeSourceCode, () => myTypeCheckExpectEqual(aTypeSourceCode, sourceCode, answer))
-
-myTypeCheckTest(test, "number", "1", "Ok")
-myTypeCheckTest(test, "number", "'2'", "Expected type: number but got: '2'")
-myTypeCheckTest(test, "string", "3", "Expected type: string but got: 3")
-myTypeCheckTest(test, "string", "'a'", "Ok")
-myTypeCheckTest(test, "[number]", "[1,2,3]", "Ok")
-myTypeCheckTest(test, "[number]", "['a','a','a']", "Expected type: number but got: 'a'")
-myTypeCheckTest(test, "[number]", "[1,'a',3]", "Expected type: number but got: 'a'")
-myTypeCheckTest(test, "[number, string]", "[1,'a']", "Ok")
-myTypeCheckTest(test, "[number, string]", "[1, 2]", "Expected type: string but got: 2")
-myTypeCheckTest(
-  test,
-  "[number, string, string]",
-  "[1,'a']",
-  "Expected type: [number, string, string] but got: [1,'a']",
-)
-myTypeCheckTest(
-  test,
-  "[number, string]",
-  "[1,'a', 3]",
-  "Expected type: [number, string] but got: [1,'a',3]",
-)
-myTypeCheckTest(test, "{age: number, name: string}", "{age: 1, name: 'a'}", "Ok")
-myTypeCheckTest(
-  test,
-  "{age: number, name: string}",
-  "{age: 1, name: 'a', job: 'IT'}",
-  "Expected type: {age: number, name: string} but got: {age: 1,job: 'IT',name: 'a'}",
-)
-myTypeCheckTest(test, "number | string", "1", "Ok")
-myTypeCheckTest(test, "date | string", "1", "Expected type: (date | string) but got: 1")
-myTypeCheckTest(test, "number<-min(10)", "10", "Ok")
-myTypeCheckTest(test, "number<-min(10)", "0", "Expected type: number<-min(10) but got: 0")
-myTypeCheckTest(test, "any", "0", "Ok")
-myTypeCheckTest(test, "any", "'a'", "Ok")

packages/squiggle-lang/__tests__/Reducer/Reducer_Type/Reducer_Type_switch_replacement_test.res

@@ -1,123 +0,0 @@
-open Jest
-open Expect
-
-module DispatchT = Reducer_Dispatch_T
-module Expression = Reducer_Expression
-module ExpressionT = Reducer_Expression_T
-module TypeCompile = Reducer_Type_Compile
-module TypeChecker = Reducer_Type_TypeChecker
-open ReducerInterface_InternalExpressionValue
-
-type errorValue = Reducer_ErrorValue.errorValue
-
-// Let's build a function to replace switch statements
-// In dispatchChainPiece, we execute an return the result of execution if there is a type match.
-// Otherwise we return None so that the call chain can continue.
-// So we want to build a function like
-// dispatchChainPiece = (call: functionCall, environment): option<result<internalExpressionValue, errorValue>>
-
-// Now lets make the dispatchChainPiece itself.
-// Note that I am not passing the reducer to the dispatchChainPiece as an argument because it is in the context anyway.
-// Keep in mind that reducerFn is necessary for map/reduce so dispatchChainPiece should have a reducerFn in context.
-
-let makeMyDispatchChainPiece = (reducer: ExpressionT.reducerFn): DispatchT.dispatchChainPiece => {
-  // Let's have a pure implementations
-  module Implementation = {
-    let stringConcat = (a: string, b: string): string => Js.String2.concat(a, b)
-    let arrayConcat = (
-      a: Js.Array2.t<internalExpressionValue>,
-      b: Js.Array2.t<internalExpressionValue>,
-    ): Js.Array2.t<internalExpressionValue> => Js.Array2.concat(a, b)
-    let plot = _r => "yey, plotted"
-  }
-
-  let extractStringString = args =>
-    switch args {
-    | [IEvString(a), IEvString(b)] => (a, b)
-    | _ => raise(Reducer_Exception.ImpossibleException("extractStringString developer error"))
-    }
-
-  let extractArrayArray = args =>
-    switch args {
-    | [IEvArray(a), IEvArray(b)] => (a, b)
-    | _ => raise(Reducer_Exception.ImpossibleException("extractArrayArray developer error"))
-    }
-
-  // Let's bridge the pure implementation to expression values
-  module Bridge = {
-    let stringConcat: DispatchT.genericIEvFunction = (args, _environment) => {
-      let (a, b) = extractStringString(args)
-      Implementation.stringConcat(a, b)->IEvString->Ok
-    }
-    let arrayConcat: DispatchT.genericIEvFunction = (args, _environment) => {
-      let (a, b) = extractArrayArray(args)
-      Implementation.arrayConcat(a, b)->IEvArray->Ok
-    }
-    let plot: DispatchT.genericIEvFunction = (args, _environment) => {
-      switch args {
-      // Just assume that we are doing the business of extracting and converting the deep record
-      | [IEvRecord(_)] => Implementation.plot({"title": "This is a plot"})->IEvString->Ok
-      | _ => raise(Reducer_Exception.ImpossibleException("plot developer error"))
-      }
-    }
-  }
-
-  // concat functions are to illustrate polymoprhism. And the plot function is to illustrate complex types
-  let jumpTable = [
-    (
-      "concat",
-      TypeCompile.fromTypeExpressionExn("string=>string=>string", reducer),
-      Bridge.stringConcat,
-    ),
-    (
-      "concat",
-      TypeCompile.fromTypeExpressionExn("[any]=>[any]=>[any]", reducer),
-      Bridge.arrayConcat,
-    ),
-    (
-      "plot",
-      TypeCompile.fromTypeExpressionExn(
-        // Nested complex types are available
-        // records {property: type}
-        // arrays [type]
-        // tuples [type, type]
-        // <- type contracts are available naturally and they become part of dispatching
-        // Here we are not enumerating the possibilities because type checking has a dedicated test
-        "{title: string, line: {width: number, color: string}}=>string",
-        reducer,
-      ),
-      Bridge.plot,
-    ),
-  ]
-
-  //Here we are creating a dispatchChainPiece function that will do the actual dispatch from the jumpTable
-  Reducer_Dispatch_ChainPiece.makeFromTypes(jumpTable)
-}
-
-// And finally, let's write a library dispatch for our external library
-// Exactly the same as the one used in real life
-let _dispatch = (
-  call: functionCall,
-  environment,
-  reducer: Reducer_Expression_T.reducerFn,
-  chain,
-): result<internalExpressionValue, 'e> => {
-  let dispatchChainPiece = makeMyDispatchChainPiece(reducer)
-  dispatchChainPiece(call, environment)->E.O2.defaultFn(() => chain(call, environment, reducer))
-}
-
-// What is important about this implementation?
-// A) Exactly the same function jump table can be used to create type guarded lambda functions
-// Guarded lambda functions will be the basis of the next version of Squiggle
-// B) Complicated recursive record types are not a problem.
-
-describe("Type Dispatch", () => {
-  let reducerFn = Expression.reduceExpression
-  let dispatchChainPiece = makeMyDispatchChainPiece(reducerFn)
-  test("stringConcat", () => {
-    let call: functionCall = ("concat", [IEvString("hello"), IEvString("world")])
-
-    let result = dispatchChainPiece(call, defaultEnvironment)
-    expect(result)->toEqual(Some(Ok(IEvString("helloworld"))))
-  })
-})

packages/squiggle-lang/__tests__/Reducer/Reducer_Value_test.res

@@ -0,0 +1,14 @@
+open Jest
+open Expect
+
+describe("ExpressionValue", () => {
+  test("argsToString", () =>
+    expect([IEvNumber(1.), IEvString("a")]->Reducer_Value.argsToString)->toBe("1,'a'")
+  )
+
+  test("toStringFunctionCall", () =>
+    expect(("fn", [IEvNumber(1.), IEvString("a")])->Reducer_Value.toStringFunctionCall)->toBe(
+      "fn(1,'a')",
+    )
+  )
+})

packages/squiggle-lang/__tests__/Reducer/Reducer_constructArray_test.res

@@ -0,0 +1,13 @@
+open Jest
+open Reducer_Peggy_TestHelpers
+
+describe("Construct Array", () => {
+  testToExpression("[1,2]", "[1, 2]", ~v="[1,2]", ())
+  testToExpression("[]", "[]", ~v="[]", ())
+  testToExpression(
+    "f(x)=x; g(x)=x; [f, g]",
+    "f = {|x| {x}}; g = {|x| {x}}; [f, g]",
+    ~v="[lambda(x=>internal code),lambda(x=>internal code)]",
+    (),
+  )
+})

packages/squiggle-lang/__tests__/Reducer/Reducer_externalBindings_test.res

@@ -1,14 +0,0 @@
-open Jest
-open Reducer_TestHelpers
-
-describe("Eval with Bindings", () => {
-  testEvalBindingsToBe("x", list{("x", ExternalExpressionValue.EvNumber(1.))}, "Ok(1)")
-  testEvalBindingsToBe("x+1", list{("x", ExternalExpressionValue.EvNumber(1.))}, "Ok(2)")
-  testParseToBe("y = x+1; y", "Ok({(:$_let_$ :y {(:add :x 1)}); :y})")
-  testEvalBindingsToBe("y = x+1; y", list{("x", ExternalExpressionValue.EvNumber(1.))}, "Ok(2)")
-  testEvalBindingsToBe(
-    "y = x+1",
-    list{("x", ExternalExpressionValue.EvNumber(1.))},
-    "Ok(@{x: 1,y: 2})",
-  )
-})

packages/squiggle-lang/__tests__/Reducer/Reducer_functionAssignment_test.res

@@ -2,11 +2,15 @@ open Jest
 open Reducer_TestHelpers
 
 describe("Parse function assignment", () => {
-  testParseToBe("f(x)=x", "Ok({(:$_let_$ :f (:$$_lambda_$$ [x] {:x}))})")
+  testParseToBe("f(x)=x", "Ok(f = {|x| {x}})")
-  testParseToBe("f(x)=2*x", "Ok({(:$_let_$ :f (:$$_lambda_$$ [x] {(:multiply 2 :x)}))})")
+  testParseToBe("f(x)=2*x", "Ok(f = {|x| {(multiply)(2, x)}})")
   //MathJs does not allow blocks in function definitions
 })
 
 describe("Evaluate function assignment", () => {
   testEvalToBe("f(x)=x; f(1)", "Ok(1)")
 })
+
+describe("Shadowing", () => {
+  testEvalToBe("x = 5; f(y) = x*y; x = 6; f(2)", "Ok(10)")
+})

packages/squiggle-lang/__tests__/Reducer/Reducer_functionTricks_test.res

@@ -34,38 +34,29 @@ describe("symbol not defined", () => {
   testEvalToBe("f(x)=x(y); f(f)", "Error(y is not defined)")
   testEvalToBe("f(x)=x; f(f)", "Ok(lambda(x=>internal code))")
   testEvalToBe("f(x)=x(y); f(z)", "Error(z is not defined)")
-  testEvalToBe("f(x)=x(y); f(2)", "Error(2 is not a function)")
+  testEvalToBe("f(x)=x(y); f(2)", "Error(y is not defined)")
   testEvalToBe("f(x)=x(1); f(2)", "Error(2 is not a function)")
 })
 
 describe("call and bindings", () => {
-  testEvalToBe("f(x)=x+1", "Ok(@{f: lambda(x=>internal code)})")
+  testEvalToBe("f(x)=x+1; f(0)", "Ok(1)")
   testEvalToBe("f(x)=x+1; f(1)", "Ok(2)")
-  testEvalToBe("f=1;y=2", "Ok(@{f: 1,y: 2})")
+  testEvalToBe("f=1;y=2", "Ok(())")
-  testEvalToBe("f(x)=x+1; y=f(1)", "Ok(@{f: lambda(x=>internal code),y: 2})")
+  testEvalToBe("f(x)=x+1; y=f(1); y", "Ok(2)")
   testEvalToBe("f(x)=x+1; y=f(1); f(1)", "Ok(2)")
-  testEvalToBe("f(x)=x+1; y=f(1); z=f(1)", "Ok(@{f: lambda(x=>internal code),y: 2,z: 2})")
+  testEvalToBe("f(x)=x+1; y=f(1); z=f(1); z", "Ok(2)")
-  testEvalToBe(
+  testEvalToBe("f(x)=x+1; g(x)=f(x)+1; g(0)", "Ok(2)")
-    "f(x)=x+1; g(x)=f(x)+1",
+  testParseToBe("f=99; g(x)=f; g(2)", "Ok(f = {99}; g = {|x| {f}}; (g)(2))")
-    "Ok(@{f: lambda(x=>internal code),g: lambda(x=>internal code)})",
-  )
-  testParseToBe(
-    "f=99; g(x)=f; g(2)",
-    "Ok({(:$_let_$ :f {99}); (:$_let_$ :g (:$$_lambda_$$ [x] {:f})); (:g 2)})",
-  )
   testEvalToBe("f=99; g(x)=f; g(2)", "Ok(99)")
   testEvalToBe("f(x)=x; g(x)=f(x); g(2)", "Ok(2)")
-  testEvalToBe(
+  testEvalToBe("f(x)=x+1; g(x)=f(x)+1; y=g(2); y", "Ok(4)")
-    "f(x)=x+1; g(x)=f(x)+1; y=g(2)",
-    "Ok(@{f: lambda(x=>internal code),g: lambda(x=>internal code),y: 4})",
-  )
   testEvalToBe("f(x)=x+1; g(x)=f(x)+1; g(2)", "Ok(4)")
 })
 
 describe("function tricks", () => {
   testEvalError("f(x)=f(y)=2; f(2)") //Error because chain assignment is not allowed
   testEvalToBe("y=2;g(x)=y+1;g(2)", "Ok(3)")
-  testEvalToBe("y=2;g(x)=inspect(y)+1", "Ok(@{g: lambda(x=>internal code),y: 2})")
+  testEvalToBe("y=2;g(x)=inspect(y)+1;y", "Ok(2)")
   MySkip.testEvalToBe("f(x) = x(x); f(f)", "????") // TODO: Infinite loop. Any solution? Catching proper exception or timeout?
   MySkip.testEvalToBe("f(x, x)=x+x; f(1,2)", "????") // TODO: Duplicate parameters
   testEvalToBe("myadd(x,y)=x+y; z=myadd; z", "Ok(lambda(x,y=>internal code))")
@@ -73,10 +64,7 @@ describe("function tricks", () => {
 })
 
 describe("lambda in structures", () => {
-  testEvalToBe(
+  testEvalToBe("myadd(x,y)=x+y; z=[myadd]", "Ok(())")
-    "myadd(x,y)=x+y; z=[myadd]",
-    "Ok(@{myadd: lambda(x,y=>internal code),z: [lambda(x,y=>internal code)]})",
-  )
   testEvalToBe("myadd(x,y)=x+y; z=[myadd]; z[0]", "Ok(lambda(x,y=>internal code))")
   testEvalToBe("myadd(x,y)=x+y; z=[myadd]; z[0](3,2)", "Ok(5)")
   testEvalToBe("myaddd(x,y)=x+y; z={x: myaddd}; z", "Ok({x: lambda(x,y=>internal code)})")

packages/squiggle-lang/__tests__/Reducer/Reducer_mapReduce_test.res

@@ -5,3 +5,7 @@ Skip.describe("map reduce (sam)", () => {
   testEvalToBe("addone(x)=x+1; map(2, addone)", "Error???")
   testEvalToBe("addone(x)=x+1; map(2, {x: addone})", "Error???")
 })
+
+describe("map", () => {
+  testEvalToBe("arr=[1,2,3]; map(arr, {|x| x*2})", "Ok([2,4,6])")
+})

packages/squiggle-lang/__tests__/Reducer/Reducer_ternaryOperator_test.res

@@ -2,7 +2,7 @@ open Jest
 open Reducer_TestHelpers
 
 describe("Parse ternary operator", () => {
-  testParseToBe("true ? 'YES' : 'NO'", "Ok({(:$$_ternary_$$ true 'YES' 'NO')})")
+  testParseToBe("true ? 'YES' : 'NO'", "Ok(true ? ('YES') : ('NO'))")
 })
 
 describe("Evaluate ternary operator", () => {

packages/squiggle-lang/__tests__/Reducer/Reducer_test.res

@@ -2,19 +2,29 @@ open Jest
 open Reducer_TestHelpers
 
 describe("eval", () => {
-  // All MathJs operators and functions are builtin for string, float and boolean
-  // .e.g + - / * > >= < <= == /= not and or
-  // See https://mathjs.org/docs/reference/functions.html
   describe("expressions", () => {
     testEvalToBe("1", "Ok(1)")
+    testEvalToBe("-1", "Ok(-1)")
+    testEvalToBe("1-1", "Ok(0)")
     testEvalToBe("1+2", "Ok(3)")
     testEvalToBe("(1+2)*3", "Ok(9)")
     testEvalToBe("2>1", "Ok(true)")
     testEvalToBe("concat('a ', 'b')", "Ok('a b')")
+    testEvalToBe("concat([3,4], [5,6,7])", "Ok([3,4,5,6,7])")
     testEvalToBe("log(10)", "Ok(2.302585092994046)")
-    testEvalToBe("cos(10)", "Ok(-0.8390715290764524)")
+    testEvalToBe("Math.cos(10)", "Ok(-0.8390715290764524)")
     // TODO more built ins
   })
+
+  describe("missing function", () => {
+    testEvalToBe("testZadanga(1)", "Error(testZadanga is not defined)")
+
+    testEvalToBe(
+      "arr = [normal(3,2)]; map(arr, zarathsuzaWasHere)",
+      "Error(zarathsuzaWasHere is not defined)",
+    )
+  })
+
   describe("arrays", () => {
     test("empty array", () => expectEvalToBe("[]", "Ok([])"))
     testEvalToBe("[1, 2, 3]", "Ok([1,2,3])")
@@ -27,14 +37,16 @@ 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(
-      expectEvalToBe(
+      "always the same property ending",
-        `{
+      () =>
+        expectEvalToBe(
+          `{
       a: 1, 
       b: 2,
     }`,
-        "Ok({a: 1,b: 2})",
+          "Ok({a: 1,b: 2})",
-      )
+        ),
     )
   })
 
@@ -48,7 +60,11 @@ describe("eval", () => {
     testEvalToBe("x=1; y=x+1; y+1", "Ok(3)")
     testEvalError("1; x=1")
     testEvalError("1; 1")
-    testEvalToBe("x=1; x=1", "Ok(@{x: 1})")
+    testEvalToBe("x=1; x=1; x", "Ok(1)")
+  })
+
+  describe("blocks", () => {
+    testEvalToBe("x = { y = { z = 5; z * 2 }; y + 3 }; x", "Ok(13)")
   })
 })
 
@@ -64,3 +80,33 @@ describe("test exceptions", () => {
   //   "Error(TODO: unhandled rescript exception)",
   // )
 })
+
+describe("stacktraces", () => {
+  test("nested calls", () => {
+    open Expect
+
+    let error =
+      Expression.BackCompatible.evaluateString(`
+  f(x) = {
+    y = "a"
+    x + y
+  }
+  g = {|x| f(x)}
+  h(x) = g(x)
+  h(5)
+`)
+      ->E.R.getError
+      ->E.O2.toExn("oops")
+      ->SqError.toStringWithStackTrace
+
+    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)]
+Stack trace:
+  f at line 4, column 5
+  g at line 6, column 12
+  h at line 7, column 10
+  <top> at line 8, column 3
+`)
+  })
+})

packages/squiggle-lang/__tests__/ReducerInterface/ReducerInterface_ExpressionValue_test.res

@@ -1,11 +0,0 @@
-open ReducerInterface.ExternalExpressionValue
-open Jest
-open Expect
-
-describe("ExpressionValue", () => {
-  test("argsToString", () => expect([EvNumber(1.), EvString("a")]->argsToString)->toBe("1,'a'"))
-
-  test("toStringFunctionCall", () =>
-    expect(("fn", [EvNumber(1.), EvString("a")])->toStringFunctionCall)->toBe("fn(1,'a')")
-  )
-})

packages/squiggle-lang/__tests__/ReducerProject/ReducerProject_Topology_test.res

@@ -0,0 +1,36 @@
+@@warning("-44")
+module Topology = ReducerProject_Topology
+
+open Jest
+open Expect
+open Expect.Operators
+
+describe("Topology Diff", () => {
+  test("when equal 1x", () => {
+    Topology.runOrderDiff(["a"], ["a"])->expect == []
+  })
+
+  test("when equal 3x", () => {
+    Topology.runOrderDiff(["a", "b", "c"], ["a", "b", "c"])->expect == []
+  })
+
+  test("less dependents", () => {
+    Topology.runOrderDiff(["a", "b"], ["a", "b", "c", "d"])->expect == []
+  })
+
+  test("more dependents", () => {
+    Topology.runOrderDiff(["a", "b", "c", "d"], ["a", "b"])->expect == ["c", "d"]
+  })
+
+  test("change midway", () => {
+    Topology.runOrderDiff(["a", "b", "bb", "c", "d"], ["a", "b", "c", "d"])->expect == [
+        "bb",
+        "c",
+        "d",
+      ]
+  })
+
+  test("swap", () => {
+    Topology.runOrderDiff(["a", "b", "c", "d"], ["a", "c", "b", "d"])->expect == ["b", "c", "d"]
+  })
+})

packages/squiggle-lang/__tests__/ReducerProject/ReducerProject_includes_test.res

@@ -0,0 +1,111 @@
+@@warning("-44")
+module Project = ForTS_ReducerProject
+
+open Jest
+open Expect
+open Expect.Operators
+
+describe("Parse includes", () => {
+  let project = Project.createProject()
+  Project.setSource(
+    project,
+    "main",
+    `
+#include 'common'
+x=1`,
+  )
+  Project.parseIncludes(project, "main")
+  test("dependencies", () => {
+    expect(Project.getDependencies(project, "main")) == ["common"]
+  })
+  test("dependents", () => {
+    expect(Project.getDependents(project, "main")) == []
+  })
+  test("getIncludes", () => {
+    let mainIncludes = Project.getIncludes(project, "main")
+    switch mainIncludes {
+    | Ok(includes) => expect(includes) == ["common"]
+    | Error(error) => fail(error->SqError.toString)
+    }
+  })
+  test("past chain", () => {
+    expect(project->Project.getPastChain("main")) == ["common"]
+  })
+  test("import as variables", () => {
+    expect(project->Project.Private.getIncludesAsVariables("main")) == []
+  })
+})
+
+describe("Parse includes", () => {
+  let project = Project.createProject()
+  Project.setSource(
+    project,
+    "main",
+    `
+#include 'common'
+#include 'myModule' as myVariable
+x=1`,
+  )
+  Project.parseIncludes(project, "main")
+
+  test("dependencies", () => {
+    expect(Project.getDependencies(project, "main")) == ["common", "myModule"]
+  })
+
+  test("dependents", () => {
+    expect(Project.getDependents(project, "main")) == []
+  })
+
+  test("getIncludes", () => {
+    let mainIncludes = Project.getIncludes(project, "main")
+    switch mainIncludes {
+    | Ok(includes) => expect(includes) == ["common", "myModule"]
+    | Error(error) => fail(error->SqError.toString)
+    }
+  })
+
+  test("direct past chain", () => {
+    expect(project->Project.Private.getPastChain("main")) == ["common"]
+  })
+
+  test("direct includes", () => {
+    expect(project->Project.Private.getDirectIncludes("main")) == ["common"]
+  })
+
+  test("include as variables", () => {
+    expect(project->Project.Private.getIncludesAsVariables("main")) == [("myVariable", "myModule")]
+  })
+})
+
+describe("Parse multiple direct includes", () => {
+  let project = Project.createProject()
+  Project.setSource(
+    project,
+    "main",
+    `
+#include 'common' 
+#include 'common2'
+#include 'myModule' as myVariable
+x=1`,
+  )
+  Project.parseIncludes(project, "main")
+  test("dependencies", () => {
+    expect(Project.getDependencies(project, "main")) == ["common", "common2", "myModule"]
+  })
+  test("dependents", () => {
+    expect(Project.getDependents(project, "main")) == []
+  })
+  test("getIncludes", () => {
+    let mainIncludes = Project.getIncludes(project, "main")
+    switch mainIncludes {
+    | Ok(includes) => expect(includes) == ["common", "common2", "myModule"]
+    | Error(error) => fail(error->SqError.toString)
+    }
+  })
+  test("direct past chain", () => {
+    expect(Project.getPastChain(project, "main")) == ["common", "common2"]
+  })
+  test("include as variables", () => {
+    expect(project->Project.Private.getIncludesAsVariables("main")) == [("myVariable", "myModule")]
+  })
+})

packages/squiggle-lang/__tests__/ReducerProject/ReducerProject_test.res

@@ -0,0 +1,201 @@
+@@warning("-44")
+module Project = ForTS_ReducerProject
+module Bindings = Reducer_Bindings
+
+open Jest
+open Expect
+open Expect.Operators
+
+let runFetchResult = (project, sourceId) => {
+  Project.run(project, sourceId)
+  Project.getResult(project, sourceId)->Reducer_Value.toStringResult
+}
+
+let runFetchFlatBindings = (project, sourceId) => {
+  Project.run(project, sourceId)
+  Project.getBindings(project, sourceId)->Reducer_Value.toStringRecord
+}
+
+test("test result true", () => {
+  let project = Project.createProject()
+  Project.setSource(project, "main", "true")
+  runFetchResult(project, "main")->expect->toBe("Ok(true)")
+})
+
+test("test result false", () => {
+  let project = Project.createProject()
+  Project.setSource(project, "main", "false")
+  runFetchResult(project, "main")->expect->toBe("Ok(false)")
+})
+
+test("test library", () => {
+  let project = Project.createProject()
+  Project.setSource(project, "main", "x=Math.pi; x")
+  runFetchResult(project, "main")->expect->toBe("Ok(3.141592653589793)")
+})
+
+test("test bindings", () => {
+  let project = Project.createProject()
+  Project.setSource(project, "variables", "myVariable=666")
+  runFetchFlatBindings(project, "variables")->expect->toBe("{myVariable: 666}")
+})
+
+describe("project1", () => {
+  let project = Project.createProject()
+  Project.setSource(project, "first", "x=1")
+  Project.setSource(project, "main", "x")
+  Project.setContinues(project, "main", ["first"])
+
+  test("runOrder", () => {
+    expect(Project.getRunOrder(project)) == ["first", "main"]
+  })
+  test("dependents first", () => {
+    expect(Project.getDependents(project, "first")) == ["main"]
+  })
+  test("dependencies first", () => {
+    expect(Project.getDependencies(project, "first")) == []
+  })
+  test("dependents main", () => {
+    expect(Project.getDependents(project, "main")) == []
+  })
+  test("dependencies main", () => {
+    expect(Project.getDependencies(project, "main")) == ["first"]
+  })
+
+  test("past chain first", () => {
+    expect(ReducerProject.getPastChain(project, "first")) == []
+  })
+  test("past chain main", () => {
+    expect(ReducerProject.getPastChain(project, "main")) == ["first"]
+  })
+
+  test("test result", () => {
+    runFetchResult(project, "main")->expect->toBe("Ok(1)")
+  })
+  test("test bindings", () => {
+    runFetchFlatBindings(project, "first")->expect->toBe("{x: 1}")
+  })
+})
+
+describe("project2", () => {
+  let project = Project.createProject()
+  Project.setContinues(project, "main", ["second"])
+  Project.setContinues(project, "second", ["first"])
+  Project.setSource(project, "first", "x=1")
+  Project.setSource(project, "second", "y=2")
+  Project.setSource(project, "main", "z=3;y")
+
+  test("runOrder", () => {
+    expect(Project.getRunOrder(project)) == ["first", "second", "main"]
+  })
+  test("runOrderFor", () => {
+    expect(Project.getRunOrderFor(project, "first")) == ["first"]
+  })
+  test("dependencies first", () => {
+    expect(Project.getDependencies(project, "first")) == []
+  })
+  test("dependents first", () => {
+    expect(Project.getDependents(project, "first")) == ["second", "main"]
+  })
+  test("dependents main", () => {
+    expect(Project.getDependents(project, "main")) == []
+  })
+  test("dependencies main", () => {
+    expect(Project.getDependencies(project, "main")) == ["first", "second"]
+  })
+  test("test result", () => {
+    runFetchResult(project, "main")->expect->toBe("Ok(2)")
+  })
+  test("test bindings", () => {
+    // bindings from continues are not exposed!
+    runFetchFlatBindings(project, "main")->expect->toBe("{z: 3}")
+  })
+})
+
+describe("removing sources", () => {
+  let project = Project.createProject()
+  Project.setContinues(project, "main", ["second"])
+  Project.setContinues(project, "second", ["first"])
+  Project.setSource(project, "first", "x=1")
+  Project.setSource(project, "second", "y=2")
+  Project.setSource(project, "main", "y")
+
+  Project.removeSource(project, "main")
+
+  test("project doesn't have source", () => {
+    expect(Project.getSource(project, "main")) == None
+  })
+
+  test("dependents get updated", () => {
+    expect(Project.getDependents(project, "second")) == []
+  })
+})
+
+describe("project with include", () => {
+  let project = Project.createProject()
+  Project.setContinues(project, "main", ["second"])
+  Project.setContinues(project, "second", ["first"])
+
+  Project.setSource(
+    project,
+    "first",
+    `
+  #include 'common'
+  x=1`,
+  )
+  Project.parseIncludes(project, "first")
+  Project.parseIncludes(project, "first") //The only way of setting includes
+  //Don't forget to parse includes after changing the source
+
+  Project.setSource(project, "common", "common=0")
+  Project.setSource(
+    project,
+    "second",
+    `
+  #include 'common'
+  y=2`,
+  )
+  Project.parseIncludes(project, "second") //The only way of setting includes
+
+  Project.setSource(project, "main", "z=3; y")
+
+  test("runOrder", () => {
+    expect(Project.getRunOrder(project)) == ["common", "first", "second", "main"]
+  })
+
+  test("runOrderFor", () => {
+    expect(Project.getRunOrderFor(project, "first")) == ["common", "first"]
+  })
+
+  test("dependencies first", () => {
+    expect(Project.getDependencies(project, "first")) == ["common"]
+  })
+  test("dependents first", () => {
+    expect(Project.getDependents(project, "first")) == ["second", "main"]
+  })
+  test("dependents main", () => {
+    expect(Project.getDependents(project, "main")) == []
+  })
+  test("dependencies main", () => {
+    expect(Project.getDependencies(project, "main")) == ["common", "first", "second"]
+  })
+  test("test result", () => {
+    runFetchResult(project, "main")->expect->toBe("Ok(2)")
+  })
+  test("test bindings", () => {
+    // bindings from continues are not exposed!
+    runFetchFlatBindings(project, "main")->expect->toBe("{z: 3}")
+  })
+})
+
+describe("project with independent sources", () => {
+  let project = Project.createProject()
+  Project.setSource(project, "first", "1")
+  Project.setSource(project, "second", "2")
+  test("run order of first", () => {
+    expect(Project.getRunOrderFor(project, "first")) == ["first"]
+  })
+  test("run order of second", () => {
+    expect(Project.getRunOrderFor(project, "second")) == ["second"]
+  })
+})

packages/squiggle-lang/__tests__/ReducerProject/ReducerProject_tutorial_1_test.res

@@ -0,0 +1,116 @@
+@@warning("-44")
+module Project = ForTS_ReducerProject
+module Bindings = Reducer_Bindings
+
+open Jest
+open Expect
+open Expect.Operators
+
+describe("ReducerProject Tutorial", () => {
+  describe("Single source", () => {
+    /*
+Case "Running a single source". 
+*/
+    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. 
+       You can run any source in the project. It will be compiled and run if it hasn't happened already; otherwise already existing results will be presented.
+       The dependencies will be automatically compiled and run. So you don't need to worry about that in a multi source project.
+       In summary you issue a run command on the whole project or on a specific source to ensure that there is a result for that source.
+ */
+        let project = Project.createProject()
+        /* Every source has a name. This is used for debugging, dependencies and error messages. */
+        project->Project.setSource("main", "1 + 2")
+        /* Let's run "main" source. */
+        project->Project.run("main")
+        /* Now you have a result for "main" source. 
+       Running one by one is necessary for UI to navigate among the sources and to see the results by source. 
+       And you're free to run any source you want. 
+       You will look at the results of this source and you don't want to run the others if not required.
+ */
+
+        /* However, you could also run the whole project.
+       If you have all the sources, you can always run the whole project. 
+       Dependencies and recompiling on demand will be taken care of by the project. 
+ */
+        project->Project.runAll
+
+        /* Either with run or runAll you executed the project. 
+       You can get the result of a specific source by calling getResult for that source. 
+       You can get the bindings of a specific source by calling getBindings for that source. 
+       If there is any runtime error, getResult will return the error.
+
+       Note that getResult returns None if the source has not been run.
+       Getting None means you have forgotten to run the source.
+ */
+        let result = project->Project.getResult("main")
+        let bindings = project->Project.getBindings("main")
+
+        /* Let's display the result and bindings */
+        (result->Reducer_Value.toStringResult, bindings->Reducer_Value.toStringRecord)->expect ==
+          ("Ok(3)", "{}")
+        /* You've got 3 with empty bindings. */
+      },
+    )
+
+    test(
+      "run summary",
+      () => {
+        let project = Project.createProject()
+        project->Project.setSource("main", "1 + 2")
+        project->Project.runAll
+        let result = project->Project.getResult("main")
+        let bindings = project->Project.getBindings("main")
+        /* Now you have external bindings and external result. */
+        (
+          result->Reducer_Value.toStringResult,
+          bindings->Reducer_T.IEvRecord->Reducer_Value.toString,
+        )->expect == ("Ok(3)", "{}")
+      },
+    )
+
+    test(
+      "run with an environment",
+      () => {
+        /* Running the source code like above allows you to set a custom environment */
+        let project = Project.createProject()
+
+        /* Optional. Set your custom environment anytime before running */
+        project->Project.setEnvironment(Reducer_Context.defaultEnvironment)
+
+        project->Project.setSource("main", "1 + 2")
+        project->Project.runAll
+        let result = project->Project.getResult("main")
+        let _bindings = project->Project.getBindings("main")
+        result->Reducer_Value.toStringResult->expect == "Ok(3)"
+      },
+    )
+
+    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)", "{}")
+      },
+    )
+  })
+})
+
+//TODO multiple sources
+//TODO multiple sources with includes. Introduction to includes
+//TODO multiple sources with multi level includes. Cycle detection
+//TODO
+//TODO: Implement a runOrder consideration - clean results based on run order.
+//TODO: runOrder vs setSource/touchSource
+//TODO: Advanced details: (below)
+//TODO  runOrder. includes vs continues. Run order based reexecution
+//TODO: dependents and reexecution
+//TODO: dependencies and reexecution
+//TODO: cleanAllResults clean
+//TODO: cleanAll clean 

packages/squiggle-lang/__tests__/ReducerProject/ReducerProject_tutorial_2_multisource_test.res

@@ -0,0 +1,113 @@
+@@warning("-44")
+module Project = ForTS_ReducerProject
+module Bindings = Reducer_Bindings
+
+open Jest
+open Expect
+open Expect.Operators
+
+describe("ReducerProject Tutorial", () => {
+  describe("Multi source", () => {
+    /*
+     Case "Running multiple sources" */
+    test(
+      "Chaining",
+      () => {
+        let project = Project.createProject()
+        /* This time let's add 3 sources and chain them together */
+        project->Project.setSource("source1", "x=1")
+
+        project->Project.setSource("source2", "y=x+1")
+        /* To run, source2 depends on source1 */
+        project->Project.setContinues("source2", ["source1"])
+
+        project->Project.setSource("source3", "z=y+1")
+        /* To run, source3 depends on source2 */
+        project->Project.setContinues("source3", ["source2"])
+
+        /* Now we can run the project */
+        project->Project.runAll
+
+        /* And let's check the result and bindings of source3 */
+        let result3 = project->Project.getResult("source3")
+        let bindings3 = project->Project.getBindings("source3")
+
+        (result3->Reducer_Value.toStringResult, bindings3->Reducer_Value.toStringRecord)->expect ==
+          ("Ok(())", "{z: 3}")
+      },
+    )
+
+    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()
+
+        /* This time source1 and source2 are not depending on anything */
+        project->Project.setSource("source1", "x=1")
+        project->Project.setSource("source2", "y=2")
+
+        project->Project.setSource("source3", "z=x+y")
+        /* To run, source3 depends on source1 and source3 together */
+        project->Project.setContinues("source3", ["source1", "source2"])
+
+        /* Now we can run the project */
+        project->Project.runAll
+
+        /* And let's check the result and bindings of source3 */
+        let result3 = project->Project.getResult("source3")
+        let bindings3 = project->Project.getBindings("source3")
+
+        (result3->Reducer_Value.toStringResult, bindings3->Reducer_Value.toStringRecord)->expect ==
+          ("Ok(())", "{z: 3}")
+      },
+    )
+
+    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. */
+        let project = Project.createProject()
+
+        /* This time source1 and source2 are not depending on anything */
+        project->Project.setSource("source1", "x=1")
+        project->Project.setSource("source2", "y=2")
+
+        project->Project.setSource(
+          "source3",
+          `
+      #include "source1"
+      #include "source2"
+      z=x+y`,
+        )
+        /* We need to parse the includes to set the dependencies */
+        project->Project.parseIncludes("source3")
+
+        /* Now we can run the project */
+        project->Project.runAll
+
+        /* And let's check the result and bindings of source3 
+      This time you are getting all the variables because we are including the other sources 
+      Behind the scenes parseIncludes is setting the dependencies */
+        let result3 = project->Project.getResult("source3")
+        let bindings3 = project->Project.getBindings("source3")
+
+        (result3->Reducer_Value.toStringResult, bindings3->Reducer_Value.toStringRecord)->expect ==
+          ("Ok(())", "{z: 3}")
+        /*
+      Doing it like this is too verbose for a storybook 
+      But I hope you have seen the relation of setContinues and parseIncludes */
+        /*
+         Dealing with includes needs more. 
+         - There are parse errors
+         - There are cyclic includes
+         - 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. */
+      },
+    )
+  })
+})

packages/squiggle-lang/__tests__/ReducerProject/ReducerProject_tutorial_3_includes_test.res

@@ -0,0 +1,201 @@
+@@warning("-44")
+module Project = ForTS_ReducerProject
+module Bindings = Reducer_Bindings
+
+open Jest
+open Expect
+open Expect.Operators
+
+describe("ReducerProject Tutorial", () => {
+  /* Case: Includes
+In the previous tutorial we have set the similarity between setContinues and parseIncludes.
+Here we will finally proceed to a real life scenario. */
+
+  describe("parseIncludes", () => {
+    /* Here we investigate the details about parseIncludes, before setting up a real life scenario in the next section. */
+    /* Everything happens inside a project, so let's have a project */
+    let project = Project.createProject()
+    project->Project.setSource(
+      "main",
+      `
+    #include "common"
+    x=1
+    `,
+    )
+    /* We need to parse includes after changing the source */
+    project->Project.parseIncludes("main")
+    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",
+      () => {
+        /* Parse includes has set the includes */
+        switch project->Project.getIncludes("main") {
+        | Ok(includes) => includes->expect == ["common"]
+        | Error(err) => err->SqError.toString->fail
+        }
+        /* If the includes cannot be parsed then you get a syntax error.
+      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",
+      () => {
+        /* 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",
+      () => {
+        /* 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.
+    Therefore one has to write a function to load sources recursively and and setSources
+    while checking for dependencies */
+
+        /* Let's make a dummy loader */
+        let loadSource = (sourceName: string) =>
+          switch sourceName {
+          | "source1" => "x=1"
+          | "source2" => `
+            #include "source1"
+            y=2`
+          | "source3" => `
+            #include "source2"
+            z=3`
+          | _ => `source ${sourceName} not found`->Js.Exn.raiseError
+          }
+
+        /* let's recursively load the sources */
+        let rec loadIncludesRecursively = (project, sourceName, visited) => {
+          if visited->Js.Array2.includes(sourceName) {
+            /* Oh we have already visited this source. There is an include cycle */
+            "Cyclic include ${sourceName}"->Js.Exn.raiseError
+          } else {
+            let newVisited = Js.Array2.copy(visited)
+            let _ = newVisited->Js.Array2.push(sourceName)
+            /* Let's parse the includes and dive into them */
+            Project.parseIncludes(project, sourceName)
+            let rIncludes = project->Project.getIncludes(sourceName)
+            switch rIncludes {
+            /* Maybe there is an include syntax error */
+            | Error(err) => err->SqError.toString->Js.Exn.raiseError
+
+            | Ok(includes) =>
+              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)
+                  project->Project.setSource(newIncludeName, newSource)
+                  /* The new source is loaded and added to the project. */
+                  /* Of course the new source might have includes too. */
+                  /* Let's recursively load them */
+                  project->loadIncludesRecursively(newIncludeName, newVisited)
+                },
+              )
+            }
+          }
+        }
+        /* As we have a fake source loader and a recursive include handler,
+         We can not set up a real project */
+
+        /* * Here starts our real life project! * */
+
+        let project = Project.createProject()
+
+        project->Project.setSource(
+          "main",
+          `
+        #include "source1"
+        #include "source2"
+        #include "source3"
+        a = x+y+z
+        b = doubleX
+        a
+        `,
+        )
+        /* Setting source requires parsing and loading the includes recursively */
+        project->loadIncludesRecursively("main", []) // Not visited yet
+
+        /* Let's salt it more. Let's have another source in the project which also has includes */
+        /* doubleX includes source1 which is eventually included by main as well */
+        project->Project.setSource(
+          "doubleX",
+          `
+        #include "source1"
+        doubleX = x * 2
+        `,
+        )
+        project->loadIncludesRecursively("doubleX", [])
+        /* Remember, any time you set a source, you need to load includes recursively */
+
+        /* As doubleX is not included by main, it is not loaded recursively.
+         So we link it to the project as a dependency */
+        project->Project.setContinues("main", ["doubleX"])
+
+        /* Let's run the project */
+        project->Project.runAll
+        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}")
+            /* Everything as expected */
+          },
+        )
+      },
+    )
+  })
+
+  describe("Includes myFile as myVariable", () => {
+    /* Instead of including into global space you can also put a module into a record variable */
+    let project = Project.createProject()
+    Project.setSource(
+      project,
+      "main",
+      `
+    #include "common" as common
+    x=1
+    `,
+    )
+    Project.parseIncludes(project, "main")
+    test(
+      "getDependencies",
+      () => {
+        Project.getDependencies(project, "main")->expect == ["common"]
+      },
+    )
+    test(
+      "getIncludes",
+      () => {
+        switch Project.getIncludes(project, "main") {
+        | Ok(includes) => includes->expect == ["common"]
+        | Error(err) => err->SqError.toString->fail
+        }
+      },
+    )
+  })
+})

packages/squiggle-lang/__tests__/ReducerProject/ReducerProject_tutorial_4_injecting_user_values.res

@@ -0,0 +1,37 @@
+@@warning("-44")
+module Project = ForTS_ReducerProject
+
+open Jest
+open Expect
+open Expect.Operators
+
+describe("ReducerProject Tutorial", () => {
+  /* Let's build a project that depends on values from the UI */
+  let project = Project.createProject()
+  Project.setSource(project, "main", "x+y+z")
+  /* x, y and z is not defined in the project but they has to come from the user */
+  test("Injecting user values", () => {
+    /* User has input the values */
+    let x = 1
+    let y = 2
+    let z = 3
+    /* Then we construct a source code to define those values */
+    let userCode = `
+      x = ${x->Js.Int.toString}
+      y = ${y->Js.Int.toString}
+      z = ${z->Js.Int.toString}
+    `
+    /* We inject the user code into the project */
+    Project.setSource(project, "userCode", userCode)
+    /* "main" is depending on the user code */
+    Project.setContinues(project, "main", ["userCode"])
+    /* We can now run the project */
+    Project.runAll(project)
+    let result = Project.getResult(project, "main")
+    result->Reducer_Value.toStringResult->expect == "Ok(6)"
+  })
+})
+
+/* Note that this is not final version of the project */
+/* In the future, for safety, we will provide a way to inject values instead of a source code */
+/* But time is limited for now... */

packages/squiggle-lang/__tests__/ReducerProject/ReducerProject_tutorial_5_calling_functions.res

@@ -0,0 +1,39 @@
+@@warning("-44")
+module Project = ForTS_ReducerProject
+module Bindings = Reducer_Bindings
+
+open Jest
+open Expect
+open Expect.Operators
+
+describe("ReducerProject Tutorial", () => {
+  /* Let's build a project to provide a function. */
+  /* But we will call that function on an array of user input. */
+  let project = Project.createProject()
+  Project.setSource(project, "library", "double(x) = x * 2")
+  /* userCode is not here yet but its dependency is fixed. So we can set it once and for all */
+  Project.setContinues(project, "userCode", ["library"])
+
+  let userValues = [1, 2, 3, 4, 5]
+
+  let userResults = Belt.Array.map(userValues, aUserValue => {
+    let userCode = `double(${aUserValue->Js.Int.toString})`
+    /* Put the constructed source in the project */
+    /* We have already set that it depends on "library" */
+    Project.setSource(project, "userCode", userCode)
+    /* Run the project */
+    Project.runAll(project)
+    /* Get the result */
+    Project.getResult(project, "userCode")
+    /* I have to remind you that the "library" is run only once and for all.
+     The library is not run for each user value. */
+  })
+
+  test("userResults", () => {
+    let userResultsAsString = Belt.Array.map(
+      userResults,
+      aResult => aResult->Reducer_Value.toStringResult,
+    )
+    userResultsAsString->expect == ["Ok(2)", "Ok(4)", "Ok(6)", "Ok(8)", "Ok(10)"]
+  })
+})

packages/squiggle-lang/__tests__/SqError_test.res

@@ -0,0 +1,41 @@
+open Jest
+open Expect
+
+describe("SqError.Message", () => {
+  test("toString", () =>
+    expect(SqError.Message.REOther("test error")->SqError.Message.toString)->toBe(
+      "Error: test error",
+    )
+  )
+})
+
+describe("SqError", () => {
+  test("fromMessage", () =>
+    expect(SqError.Message.REOther("test error")->SqError.fromMessage->SqError.toString)->toBe(
+      "Error: test error",
+    )
+  )
+
+  test("toStringWithStackTrace with empty stacktrace", () =>
+    expect(
+      SqError.Message.REOther("test error")->SqError.fromMessage->SqError.toStringWithStackTrace,
+    )->toBe("Error: test error")
+  )
+
+  test("toStringWithStackTrace", () => {
+    let frameStack =
+      Reducer_FrameStack.make()
+      ->Reducer_FrameStack.extend("frame1", None)
+      ->Reducer_FrameStack.extend("frame2", None)
+
+    expect(
+      SqError.Message.REOther("test error")
+      ->SqError.fromMessageWithFrameStack(frameStack)
+      ->SqError.toStringWithStackTrace,
+    )->toBe(`Error: test error
+Stack trace:
+  frame2
+  frame1
+`)
+  })
+})

packages/squiggle-lang/__tests__/SquiggleLibrary/SquiggleLibrary_Distribution_test.res

@@ -23,7 +23,7 @@ describe("eval on distribution functions", () => {
     testEval("-normal(5,2)", "Ok(Normal(-5,2))")
   })
   describe("to", () => {
-    testEval("5 to 2", "Error(TODO: Low value must be less than high value.)")
+    testEval("5 to 2", "Error(Error: Low value must be less than high value.)")
     testEval("to(2,5)", "Ok(Lognormal(1.1512925464970227,0.27853260523016377))")
     testEval("to(-2,2)", "Ok(Normal(0,1.2159136638235384))")
   })
@@ -98,6 +98,7 @@ describe("eval on distribution functions", () => {
       "log(normal(5,2), normal(10,1))",
       "Error(Distribution Math Error: Logarithm of input error: First input must be completely greater than 0)",
     )
+    testEval("log(2, SampleSet.fromDist(0.0001 to 5))", "Ok(Sample Set Distribution)") // log with low values, see https://github.com/quantified-uncertainty/squiggle/issues/1098
     testEval("log(uniform(5,8))", "Ok(Sample Set Distribution)")
     testEval("log10(uniform(5,8))", "Ok(Sample Set Distribution)")
   })
@@ -119,13 +120,13 @@ describe("eval on distribution functions", () => {
 
 describe("parse on distribution functions", () => {
   describe("power", () => {
-    testParse("normal(5,2) ^ normal(5,1)", "Ok({(:pow (:normal 5 2) (:normal 5 1))})")
+    testParse("normal(5,2) ^ normal(5,1)", "Ok((pow)((normal)(5, 2), (normal)(5, 1)))")
-    testParse("3 ^ normal(5,1)", "Ok({(:pow 3 (:normal 5 1))})")
+    testParse("3 ^ normal(5,1)", "Ok((pow)(3, (normal)(5, 1)))")
-    testParse("normal(5,2) ^ 3", "Ok({(:pow (:normal 5 2) 3)})")
+    testParse("normal(5,2) ^ 3", "Ok((pow)((normal)(5, 2), 3))")
   })
   describe("subtraction", () => {
-    testParse("10 - normal(5,1)", "Ok({(:subtract 10 (:normal 5 1))})")
+    testParse("10 - normal(5,1)", "Ok((subtract)(10, (normal)(5, 1)))")
-    testParse("normal(5,1) - 10", "Ok({(:subtract (:normal 5 1) 10)})")
+    testParse("normal(5,1) - 10", "Ok((subtract)((normal)(5, 1), 10))")
   })
   describe("pointwise arithmetic expressions", () => {
     testParse(~skip=true, "normal(5,2) .+ normal(5,1)", "Ok((:dotAdd (:normal 5 2) (:normal 5 1)))")
@@ -135,12 +136,12 @@ describe("parse on distribution functions", () => {
       "Ok((:$$_block_$$ (:dotSubtract (:normal 5 2) (:normal 5 1))))",
       // TODO: !!! returns "Ok({(:dotPow (:normal 5 2) (:normal 5 1))})"
     )
-    testParse("normal(5,2) .* normal(5,1)", "Ok({(:dotMultiply (:normal 5 2) (:normal 5 1))})")
+    testParse("normal(5,2) .* normal(5,1)", "Ok((dotMultiply)((normal)(5, 2), (normal)(5, 1)))")
-    testParse("normal(5,2) ./ normal(5,1)", "Ok({(:dotDivide (:normal 5 2) (:normal 5 1))})")
+    testParse("normal(5,2) ./ normal(5,1)", "Ok((dotDivide)((normal)(5, 2), (normal)(5, 1)))")
-    testParse("normal(5,2) .^ normal(5,1)", "Ok({(:dotPow (:normal 5 2) (:normal 5 1))})")
+    testParse("normal(5,2) .^ normal(5,1)", "Ok((dotPow)((normal)(5, 2), (normal)(5, 1)))")
   })
   describe("equality", () => {
-    testParse("5 == normal(5,2)", "Ok({(:equal 5 (:normal 5 2))})")
+    testParse("5 == normal(5,2)", "Ok((equal)(5, (normal)(5, 2)))")
   })
   describe("pointwise adding two normals", () => {
     testParse(~skip=true, "normal(5,2) .+ normal(5,1)", "Ok((:dotAdd (:normal 5 2) (:normal 5 1)))")

packages/squiggle-lang/__tests__/SquiggleLibrary/SquiggleLibrary_FunctionRegistryLibrary_test.res

@@ -2,16 +2,18 @@ open Jest
 open Expect
 open Reducer_TestHelpers
 
-let expectEvalToBeOk = (expr: string) =>
+let expectEvalToBeOk = (code: string) =>
-  Reducer.evaluate(expr)->Reducer_Helpers.rRemoveDefaultsExternal->E.R.isOk->expect->toBe(true)
+  Reducer_Expression.BackCompatible.evaluateString(code)->E.R.isOk->expect->toBe(true)
 
 let registry = FunctionRegistry_Library.registry
 let examples = E.A.to_list(FunctionRegistry_Core.Registry.allExamples(registry))
 
 describe("FunctionRegistry Library", () => {
   describe("Regular tests", () => {
+    testEvalToBe("List.length([3,5,8])", "Ok(3)")
+    testEvalToBe("List.length([])", "Ok(0)")
     testEvalToBe("List.make(3, 'HI')", "Ok(['HI','HI','HI'])")
-    testEvalToBe("make(3, 'HI')", "Error(Function not found: make(Number,String))")
+    testEvalToBe("make(3, 'HI')", "Error(make is not defined)")
     testEvalToBe("List.upTo(1,3)", "Ok([1,2,3])")
     testEvalToBe("List.first([3,5,8])", "Ok(3)")
     testEvalToBe("List.last([3,5,8])", "Ok(8)")
@@ -63,9 +65,15 @@ describe("FunctionRegistry Library", () => {
     testEvalToBe("SampleSet.fromList([3,5,2,3,5,2,3,5,2,3,3,5])", "Ok(Sample Set Distribution)")
     testEvalToBe("SampleSet.fromList([3,5,2,3,5,2,3,5,2,3,3,5])", "Ok(Sample Set Distribution)")
     testEvalToBe("SampleSet.fromFn({|| sample(normal(5,2))})", "Ok(Sample Set Distribution)")
-    testEvalToBe("SampleSet.min(SampleSet.fromDist(normal(50,2)), 2)", "Ok(Sample Set Distribution)")
+    testEvalToBe(
+      "SampleSet.min(SampleSet.fromDist(normal(50,2)), 2)",
+      "Ok(Sample Set Distribution)",
+    )
     testEvalToBe("mean(SampleSet.min(SampleSet.fromDist(normal(50,2)), 2))", "Ok(2)")
-    testEvalToBe("SampleSet.max(SampleSet.fromDist(normal(50,2)), 10)", "Ok(Sample Set Distribution)")
+    testEvalToBe(
+      "SampleSet.max(SampleSet.fromDist(normal(50,2)), 10)",
+      "Ok(Sample Set Distribution)",
+    )
     testEvalToBe(
       "addOne(t)=t+1; SampleSet.toList(SampleSet.map(SampleSet.fromList([1,2,3,4,5,6]), addOne))",
       "Ok([2,3,4,5,6,7])",
@@ -74,25 +82,43 @@ describe("FunctionRegistry Library", () => {
       "SampleSet.toList(SampleSet.mapN([SampleSet.fromList([1,2,3,4,5,6]), SampleSet.fromList([6, 5, 4, 3, 2, 1])], {|x| x[0] > x[1] ? x[0] : x[1]}))",
       "Ok([6,5,4,4,5,6])",
     )
+    testEvalToBe(
+      "SampleSet.fromList([1, 2, 3])",
+      "Error(Error: Too few samples when constructing sample set)",
+    )
+
+    testEvalToBe("Dict.merge({a: 1, b: 2}, {b: 3, c: 4, d: 5})", "Ok({a: 1,b: 3,c: 4,d: 5})")
+    testEvalToBe(
+      "Dict.mergeMany([{a: 1, b: 2}, {c: 3, d: 4}, {c: 5, e: 6}])",
+      "Ok({a: 1,b: 2,c: 5,d: 4,e: 6})",
+    )
+    testEvalToBe("Dict.keys({a: 1, b: 2})", "Ok(['a','b'])")
+    testEvalToBe("Dict.values({a: 1, b: 2})", "Ok([1,2])")
+    testEvalToBe("Dict.toList({a: 1, b: 2})", "Ok([['a',1],['b',2]])")
+    testEvalToBe("Dict.fromList([['a', 1], ['b', 2]])", "Ok({a: 1,b: 2})")
   })
 
   describe("Fn auto-testing", () => {
-    testAll("tests of validity", examples, r => {
+    testAll(
-      expectEvalToBeOk(r)
+      "tests of validity",
-    })
+      examples,
+      r => {
+        expectEvalToBeOk(r)
+      },
+    )
 
     testAll(
       "tests of type",
       E.A.to_list(
-        FunctionRegistry_Core.Registry.allExamplesWithFns(registry)->E.A2.filter(((fn, _)) =>
+        FunctionRegistry_Core.Registry.allExamplesWithFns(registry)->E.A2.filter(
-          E.O.isSome(fn.output)
+          ((fn, _)) => E.O.isSome(fn.output),
         ),
       ),
       ((fn, example)) => {
         let responseType =
           example
-          ->Reducer.evaluate
+          ->Reducer_Expression.BackCompatible.evaluateString
-          ->E.R2.fmap(ReducerInterface_InternalExpressionValue.externalValueToValueType)
+          ->E.R2.fmap(Reducer_Value.valueToValueType)
         let expectedOutputType = fn.output |> E.O.toExn("")
         expect(responseType)->toEqual(Ok(expectedOutputType))
       },

packages/squiggle-lang/__tests__/TS/JS_test.ts

@@ -1,10 +1,5 @@
-import {
+import { run, SqProject, SqValue, SqValueTag } from "../../src/js";
-  Distribution,
+import { testRun } from "./TestHelpers";
-  resultMap,
-  defaultBindings,
-  mergeBindings,
-} from "../../src/js/index";
-import { testRun, testRunPartial } from "./TestHelpers";
 
 function Ok<b>(x: b) {
   return { tag: "Ok", value: x };
@@ -12,97 +7,57 @@ function Ok<b>(x: b) {
 
 describe("Simple calculations and results", () => {
   test("mean(normal(5,2))", () => {
-    expect(testRun("mean(normal(5,2))")).toEqual({
+    const result = testRun("mean(normal(5,2))"); // FIXME
-      tag: "number",
+    expect(result.toString()).toEqual("5");
-      value: 5,
-    });
   });
   test("10+10", () => {
-    let foo = testRun("10 + 10");
+    let result = testRun("10 + 10");
-    expect(foo).toEqual({ tag: "number", value: 20 });
+    expect(result.toString()).toEqual("20");
   });
 });
 describe("Log function", () => {
   test("log(1) = 0", () => {
     let foo = testRun("log(1)");
-    expect(foo).toEqual({ tag: "number", value: 0 });
+    expect(foo.toString()).toEqual("0");
   });
 });
 
 describe("Array", () => {
   test("nested Array", () => {
-    expect(testRun("[[1]]")).toEqual({
+    expect(testRun("[[ 1 ]]").toString()).toEqual("[[1]]");
-      tag: "array",
-      value: [
-        {
-          tag: "array",
-          value: [
-            {
-              tag: "number",
-              value: 1,
-            },
-          ],
-        },
-      ],
-    });
   });
 });
 
 describe("Record", () => {
   test("Return record", () => {
-    expect(testRun("{a: 1}")).toEqual({
+    expect(testRun("{a:1}").toString()).toEqual("{a: 1}");
-      tag: "record",
-      value: {
-        a: {
-          tag: "number",
-          value: 1,
-        },
-      },
-    });
   });
 });
 
-describe("Partials", () => {
+describe("Continues", () => {
-  test("Can pass variables between partials and cells", () => {
+  test("Bindings from continues are accessible", () => {
-    let bindings = testRunPartial(`x = 5`);
+    const project = SqProject.create();
-    let bindings2 = testRunPartial(`y = x + 2`, bindings);
+    project.setSource("p1", "x = 5");
-    expect(testRun(`y + 3`, bindings2)).toEqual({
+    project.setSource("p2", "y = x + 2");
-      tag: "number",
+    project.setSource("main", "y + 3");
-      value: 10,
+    project.setContinues("main", ["p2"]);
-    });
+    project.setContinues("p2", ["p1"]);
+    project.run("main");
+    const result = project.getResult("main");
+    expect(result.tag).toEqual("Ok");
+    expect(result.value.toString()).toEqual("10");
   });
   test("Can merge bindings from three partials", () => {
-    let bindings1 = testRunPartial(`x = 1`);
+    const project = SqProject.create();
-    let bindings2 = testRunPartial(`y = 2`);
+    project.setSource("p1", "x = 1");
-    let bindings3 = testRunPartial(`z = 3`);
+    project.setSource("p2", "y = 2");
-    expect(
+    project.setSource("p3", "z = 3");
-      testRun(`x + y + z`, mergeBindings([bindings1, bindings2, bindings3]))
+    project.setSource("main", "x + y + z");
-    ).toEqual({
+    project.setContinues("main", ["p1", "p2", "p3"]);
-      tag: "number",
+    project.run("main");
-      value: 6,
+    const result = project.getResult("main");
-    });
+    expect(result.tag).toEqual("Ok");
-  });
+    expect(result.value.toString()).toEqual("6");
-});
-
-describe("JS Imports", () => {
-  test("Can pass parameters into partials and cells", () => {
-    let bindings = testRunPartial(`y = $x + 2`, defaultBindings, { x: 1 });
-    let bindings2 = testRunPartial(`z = y + $a`, bindings, { a: 3 });
-    expect(testRun(`z`, bindings2)).toEqual({
-      tag: "number",
-      value: 6,
-    });
-  });
-  test("Complicated deep parameters", () => {
-    expect(
-      testRun(`$x.y[0][0].w + $x.z + $u.v`, defaultBindings, {
-        x: { y: [[{ w: 1 }]], z: 2 },
-        u: { v: 3 },
-      })
-    ).toEqual({
-      tag: "number",
-      value: 6,
-    });
   });
 });
 
@@ -112,50 +67,62 @@ describe("Distribution", () => {
   let env = { sampleCount: 8, xyPointLength: 100 };
   let dist1Samples = [3, 4, 5, 6, 6, 7, 10, 15, 30];
   let dist1SampleCount = dist1Samples.length;
-  let dist = new Distribution(
+
-    { tag: "SampleSet", value: [3, 4, 5, 6, 6, 7, 10, 15, 30] },
+  const buildDist = (samples: number[]) => {
-    env
+    const src = `SampleSet.fromList([${samples.join(",")}])`;
-  );
+    const { result } = run(src, {
-  let dist2 = new Distribution(
+      environment: env,
-    { tag: "SampleSet", value: [20, 22, 24, 29, 30, 35, 38, 44, 52] },
+    });
-    env
+    if (result.tag !== "Ok") {
-  );
+      throw new Error(
+        `Failed to build SampleSet: from ${src}: ${result.value}`
+      );
+    }
+    const dist = result.value;
+    if (dist.tag !== SqValueTag.Distribution) {
+      throw new Error("Expected Distribution");
+    }
+    return dist.value;
+  };
+
+  const dist = buildDist(dist1Samples);
+  const dist2 = buildDist([20, 22, 24, 29, 30, 35, 38, 44, 52]);
 
   test("mean", () => {
-    expect(dist.mean().value).toBeCloseTo(9.5555555);
+    expect(dist.mean(env).value).toBeCloseTo(9.5555555);
   });
   test("pdf", () => {
-    expect(dist.pdf(5.0).value).toBeCloseTo(0.10499097598222966, 1);
+    expect(dist.pdf(env, 5.0).value).toBeCloseTo(0.10499097598222966, 1);
   });
   test("cdf", () => {
-    expect(dist.cdf(5.0).value).toBeCloseTo(
+    expect(dist.cdf(env, 5.0).value).toBeCloseTo(
       dist1Samples.filter((x) => x <= 5).length / dist1SampleCount,
       1
     );
   });
   test("inv", () => {
-    expect(dist.inv(0.5).value).toBeCloseTo(6);
+    expect(dist.inv(env, 0.5).value).toBeCloseTo(6);
-  });
-  test("toPointSet", () => {
-    expect(
-      resultMap(dist.toPointSet(), (r: Distribution) => r.toString())
-    ).toEqual(Ok("Point Set Distribution"));
-  });
-  test("toSparkline", () => {
-    expect(dist.toSparkline(20).value).toEqual("▁▁▃▇█▇▄▂▂▂▁▁▁▁▁▂▂▁▁▁");
-  });
-  test("algebraicAdd", () => {
-    expect(
-      resultMap(dist.algebraicAdd(dist2), (r: Distribution) =>
-        r.toSparkline(20)
-      ).value
-    ).toEqual(Ok("▁▁▂▄▆████▇▆▄▄▃▃▃▂▁▁▁"));
-  });
-  test("pointwiseAdd", () => {
-    expect(
-      resultMap(dist.pointwiseAdd(dist2), (r: Distribution) =>
-        r.toSparkline(20)
-      ).value
-    ).toEqual(Ok("▁▂██▃▃▃▃▄▅▄▃▃▂▂▂▁▁▁▁"));
   });
+  // test("toPointSet", () => {
+  //   expect(
+  //     resultMap(dist.toPointSet(), (r: Distribution) => r.toString())
+  //   ).toEqual(Ok("Point Set Distribution"));
+  // });
+  // test("toSparkline", () => {
+  //   expect(dist.toSparkline(20).value).toEqual("▁▁▃▇█▇▄▂▂▂▁▁▁▁▁▂▂▁▁▁");
+  // });
+  // test("algebraicAdd", () => {
+  //   expect(
+  //     resultMap(dist.algebraicAdd(dist2), (r: Distribution) =>
+  //       r.toSparkline(20)
+  //     ).value
+  //   ).toEqual(Ok("▁▁▂▄▆████▇▆▄▄▃▃▃▂▁▁▁"));
+  // });
+  // test("pointwiseAdd", () => {
+  //   expect(
+  //     resultMap(dist.pointwiseAdd(dist2), (r: Distribution) =>
+  //       r.toSparkline(20)
+  //     ).value
+  //   ).toEqual(Ok("▁▂██▃▃▃▃▄▅▄▃▃▂▂▂▁▁▁▁"));
+  // });
 });

packages/squiggle-lang/__tests__/TS/Jstat_test.ts

@@ -1,4 +1,3 @@
-// import { errorValueToString } from "../../src/js/index";
 import * as fc from "fast-check";
 import { testRun } from "./TestHelpers";