diff --git a/.github/workflows/benchmarks.yml b/.github/workflows/benchmarks.yml
deleted file mode 100644
index 3628f7e91..000000000
--- a/.github/workflows/benchmarks.yml
+++ /dev/null
@@ -1,41 +0,0 @@
-name: Benchmarks
-
-on:
-  workflow_dispatch: {}
-  schedule:
-    - cron: '0 0 * * *'
-
-jobs:
-  check_changes:
-    runs-on: ubuntu-latest
-    name: Check latest commit
-    outputs:
-      should_run: ${{steps.should_run.outputs.should_run}}
-    steps:
-      - uses: actions/checkout@v2
-      - name: print latest_commit
-        run: echo ${{github.sha}}
-      - id: should_run
-        continue-on-error: true
-        name: check latest commit is less than a day
-        if: ${{ github.event_name == 'schedule' }}
-        run: test -z $(git rev-list --after="24 hours" ${{github.sha}}) && echo "::set-output name=should_run::false"
-
-  benchmark:
-    needs: check_changes
-    if: ${{needs.check_changes.outputs.should_run != 'false'}}
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v3
-    - uses: dtolnay/rust-toolchain@nightly
-    - run: cd crates/steel-core && cargo bench --bench my_benchmark -- --output-format bencher | tee output.txt
-    - uses: actions/cache@v1
-      with:
-        path: ./cache
-        key: ${{ runner.os }}-benchmark
-    - uses: rhysd/github-action-benchmark@v1
-      with:
-        tool: 'cargo'
-        output-file-path: crates/steel-core/output.txt
-        github-token: ${{secrets.GITHUB_TOKEN}}
-        auto-push: true
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
deleted file mode 100644
index fefbd4fab..000000000
--- a/.github/workflows/docs.yml
+++ /dev/null
@@ -1,41 +0,0 @@
-name: Deploy
-on:
-  push:
-    branches:
-      - master
-
-jobs:
-  deploy:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write  # To push a branch 
-      pull-requests: write  # To create a PR from that branch
-    steps:
-    - uses: actions/checkout@v4
-      with:
-        fetch-depth: 0
-    - name: Install latest mdbook
-      run: |
-        tag=$(curl 'https://api.github.com/repos/rust-lang/mdbook/releases/latest' | jq -r '.tag_name')
-        url="https://github.com/rust-lang/mdbook/releases/download/${tag}/mdbook-${tag}-x86_64-unknown-linux-gnu.tar.gz"
-        mkdir mdbook
-        curl -sSL $url | tar -xz --directory=./mdbook
-        echo `pwd`/mdbook >> $GITHUB_PATH
-    - name: Deploy GitHub Pages
-      run: |
-        cd docs
-        mdbook build
-        git worktree add gh-pages
-        git config user.name "Deploy from CI"
-        git config user.email ""
-        cd gh-pages
-        # Delete the ref to avoid keeping history.
-        git update-ref -d refs/heads/gh-pages
-        # There are benchmarks stored in dev/bench/ that we would like to
-        # keep around. Otherwise, this just adds the book as a separate
-        # directory.
-        rm -rf *
-        mv ../book/ .
-        git add book
-        git commit -m "Deploy $GITHUB_SHA to gh-pages"
-        git push --force --set-upstream origin gh-pages
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
deleted file mode 100644
index 4b37ff563..000000000
--- a/.github/workflows/rust.yml
+++ /dev/null
@@ -1,88 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-
-jobs:
-
-  test:
-    name: Test Suite
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-
-      - name: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
-
-      - name: Set the STEEL_HOME environment variable
-        run: echo STEEL_HOME=${PWD}/.steel >> $GITHUB_ENV 
-
-      - uses: Swatinem/rust-cache@v2
-        with:
-          shared-key: "build"
-
-      - name: Build
-        run: cargo build --verbose
-
-      - name: Install cogs
-        env:
-          STEEL_HOME: ${{ env.STEEL_HOME }}
-        run: |
-          echo $STEEL_HOME
-          mkdir -p .steel/cogs
-          cd cogs/
-          cargo run -- install.scm
-
-      - name: install steel dylib installer
-        run: mkdir $STEEL_HOME/native && cd crates/cargo-steel-lib && cargo install --path .
-
-      - name: install websockets dylib
-        run: cd crates/steel-websockets && cargo steel-lib
-
-      - uses: actions-rs/cargo@v1
-        env:
-          STEEL_HOME: ${{ env.STEEL_HOME }}
-        with:
-          command: test
-          args: --all
-
-      - name: install cargo-tarpaulin
-        run: cargo install cargo-tarpaulin
-
-      - name: run code coverage
-        run: cargo tarpaulin --all -o "lcov"
-
-      - name: Coveralls GitHub Action
-        uses: coverallsapp/github-action@v1.1.2
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          path-to-lcov: ./lcov.info
-
-  rustfmt:
-    name: Rustfmt
-    runs-on: ubuntu-latest
-    needs: test
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v2
-      - name: Install Rust toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          toolchain: stable
-          profile: minimal
-          override: true
-          components: rustfmt
-      - name: Check formatting
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
diff --git a/.gitignore b/.gitignore
deleted file mode 100644
index e4ac3801b..000000000
--- a/.gitignore
+++ /dev/null
@@ -1,6 +0,0 @@
-/target
-**/*.rs.bk
-/scratch
-docs/book
-.vscode/
-/result
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
deleted file mode 100644
index f4828d39c..000000000
--- a/CONTRIBUTING.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# Contributing to Steel
-
-## Getting Started
-
-The following will clone Steel from the primary repository and run the test
-suite. You should have previously setup a [recent rust tool
-chain](https://www.rust-lang.org/tools/install).
-
-```bash
-git clone https://github.com/mattwparas/steel.git &&
-cd steel &&
-mkdir -p .steel/cogs &&
-export STEEL_HOME="$(pwd)/.steel" &&
-cargo build &&
-pushd cogs &&
-cargo run -- install.scm &&
-popd &&
-cargo test --all
-```
-
-## Commit message style
-
-Steel does not employ a strict commit message style or convention. Try to
-follow best practices by keeping the first line concise and descriptive,
-otherwise use your best judgement.
-
-## Submitting Patches
-
-IMPORTANT: By submitting a patch, you agree that your work will be licensed
-under the license used by the project.
-
-Follow common advice when submitting a patch:
-
-- Keep the patch focused.
-- Include tests.
-- Work in a separate branch, not `master`.
-- Before working on "big ideas", open an issue to discuss approaches or
-  requirements to limit wasted effort.
diff --git a/Cargo.lock b/Cargo.lock
deleted file mode 100644
index f8034c2ce..000000000
--- a/Cargo.lock
+++ /dev/null
@@ -1,4297 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "abi_stable"
-version = "0.11.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69d6512d3eb05ffe5004c59c206de7f99c34951504056ce23fc953842f12c445"
-dependencies = [
- "abi_stable_derive",
- "abi_stable_shared",
- "const_panic",
- "core_extensions",
- "crossbeam-channel",
- "generational-arena",
- "libloading",
- "lock_api",
- "parking_lot",
- "paste",
- "repr_offset",
- "rustc_version",
- "serde",
- "serde_derive",
- "serde_json",
-]
-
-[[package]]
-name = "abi_stable_derive"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0aecd3efa5a5294f5c67913d45f985ccb382b3c93327581529610eeecdf4821a"
-dependencies = [
- "abi_stable_shared",
- "as_derive_utils",
- "core_extensions",
- "proc-macro2",
- "quote",
- "rustc_version",
- "syn 1.0.107",
- "typed-arena",
-]
-
-[[package]]
-name = "abi_stable_shared"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2b5df7688c123e63f4d4d649cba63f2967ba7f7861b1664fca3f77d3dad2b63"
-dependencies = [
- "core_extensions",
-]
-
-[[package]]
-name = "addr2line"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4fa78e18c64fce05e902adecd7a5eed15a5e0a3439f7b0e169f0252214865e3"
-dependencies = [
- "gimli",
-]
-
-[[package]]
-name = "adler"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
-
-[[package]]
-name = "ahash"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
-dependencies = [
- "getrandom",
- "once_cell",
- "version_check",
-]
-
-[[package]]
-name = "ahash"
-version = "0.8.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91429305e9f0a25f6205c5b8e0d2db09e0708a7a6df0f42212bb56c32c8ac97a"
-dependencies = [
- "cfg-if 1.0.0",
- "once_cell",
- "version_check",
- "zerocopy",
-]
-
-[[package]]
-name = "aho-corasick"
-version = "0.7.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "android_system_properties"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "anes"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
-
-[[package]]
-name = "anyhow"
-version = "1.0.71"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c7d0618f0e0b7e8ff11427422b64564d5fb0be1940354bfe2e0529b18a9d9b8"
-
-[[package]]
-name = "arrayvec"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
-
-[[package]]
-name = "as_derive_utils"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff3c96645900a44cf11941c111bd08a6573b0e2f9f69bc9264b179d8fae753c4"
-dependencies = [
- "core_extensions",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "async-ffi"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4de21c0feef7e5a556e51af767c953f0501f7f300ba785cc99c47bdc8081a50"
-dependencies = [
- "abi_stable",
-]
-
-[[package]]
-name = "async-trait"
-version = "0.1.64"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd7fce9ba8c3c042128ce72d8b2ddbf3a05747efb67ea0313c635e10bda47a2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "atty"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
-dependencies = [
- "hermit-abi 0.1.19",
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "auto_impl"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fee3da8ef1276b0bee5dd1c7258010d8fffd31801447323115a25560e1327b89"
-dependencies = [
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
-[[package]]
-name = "axum"
-version = "0.6.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e246206a63c9830e118d12c894f56a82033da1a2361f5544deeee3df85c99d9"
-dependencies = [
- "async-trait",
- "axum-core",
- "bitflags 1.3.2",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "hyper",
- "itoa",
- "matchit",
- "memchr",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "rustversion",
- "serde",
- "serde_json",
- "serde_path_to_error",
- "serde_urlencoded",
- "sync_wrapper",
- "tokio",
- "tower",
- "tower-http",
- "tower-layer",
- "tower-service",
-]
-
-[[package]]
-name = "axum-core"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cae3e661676ffbacb30f1a824089a8c9150e71017f7e1e38f2aa32009188d34"
-dependencies = [
- "async-trait",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "mime",
- "rustversion",
- "tower-layer",
- "tower-service",
-]
-
-[[package]]
-name = "backtrace"
-version = "0.3.68"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4319208da049c43661739c5fade2ba182f09d1dc2299b32298d3a31692b17e12"
-dependencies = [
- "addr2line",
- "cc",
- "cfg-if 1.0.0",
- "libc",
- "miniz_oxide",
- "object",
- "rustc-demangle",
-]
-
-[[package]]
-name = "base64"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
-
-[[package]]
-name = "base64"
-version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
-
-[[package]]
-name = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "bit-set"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1"
-dependencies = [
- "bit-vec",
-]
-
-[[package]]
-name = "bit-vec"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitflags"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07"
-
-[[package]]
-name = "bitmaps"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69cce20737498f97b993470a6e536b8523f0af7892a4f928cceb1ac5e52ebe7e"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "bumpalo"
-version = "3.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
-
-[[package]]
-name = "byteorder"
-version = "1.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
-
-[[package]]
-name = "bytes"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
-
-[[package]]
-name = "camino"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c77df041dc383319cc661b428b6961a005db4d6808d5e12536931b1ca9556055"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "cargo-platform"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbdb825da8a5df079a43676dbe042702f1707b1109f713a01420fbb4cc71fa27"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "cargo-steel-lib"
-version = "0.1.0"
-dependencies = [
- "cargo_metadata",
-]
-
-[[package]]
-name = "cargo_metadata"
-version = "0.15.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08a1ec454bc3eead8719cb56e15dbbfecdbc14e4b3a3ae4936cc6e31f5fc0d07"
-dependencies = [
- "camino",
- "cargo-platform",
- "semver 1.0.16",
- "serde",
- "serde_json",
- "thiserror",
-]
-
-[[package]]
-name = "cast"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
-
-[[package]]
-name = "cc"
-version = "1.0.79"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
-
-[[package]]
-name = "cfg-if"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "chrono"
-version = "0.4.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
-dependencies = [
- "iana-time-zone",
- "num-integer",
- "num-traits",
- "winapi",
-]
-
-[[package]]
-name = "ciborium"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0c137568cc60b904a7724001b35ce2630fd00d5d84805fbb608ab89509d788f"
-dependencies = [
- "ciborium-io",
- "ciborium-ll",
- "serde",
-]
-
-[[package]]
-name = "ciborium-io"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "346de753af073cc87b52b2083a506b38ac176a44cfb05497b622e27be899b369"
-
-[[package]]
-name = "ciborium-ll"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "213030a2b5a4e0c0892b6652260cf6ccac84827b83a85a534e178e3906c4cf1b"
-dependencies = [
- "ciborium-io",
- "half",
-]
-
-[[package]]
-name = "clap"
-version = "4.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f13b9c79b5d1dd500d20ef541215a6423c75829ef43117e1b4d17fd8af0b5d76"
-dependencies = [
- "bitflags 1.3.2",
- "clap_derive",
- "clap_lex",
- "is-terminal",
- "once_cell",
- "strsim",
- "termcolor",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "684a277d672e91966334af371f1a7b5833f9aa00b07c84e92fbce95e00208ce8"
-dependencies = [
- "heck",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "clap_lex"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "783fe232adfca04f90f56201b26d79682d4cd2625e0bc7290b95123afe558ade"
-dependencies = [
- "os_str_bytes",
-]
-
-[[package]]
-name = "clipboard-win"
-version = "4.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7191c27c2357d9b7ef96baac1773290d4ca63b24205b82a3fd8a0637afcf0362"
-dependencies = [
- "error-code",
- "str-buf",
- "winapi",
-]
-
-[[package]]
-name = "codegen"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff61280aed771c3070e7dcc9e050c66f1eb1e3b96431ba66f9f74641d02fc41d"
-dependencies = [
- "indexmap",
-]
-
-[[package]]
-name = "codespan-reporting"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3538270d33cc669650c4b093848450d380def10c331d38c768e34cac80576e6e"
-dependencies = [
- "termcolor",
- "unicode-width",
-]
-
-[[package]]
-name = "colored"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3616f750b84d8f0de8a58bda93e08e2a81ad3f523089b05f1dffecab48c6cbd"
-dependencies = [
- "atty",
- "lazy_static",
- "winapi",
-]
-
-[[package]]
-name = "const_panic"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6051f239ecec86fde3410901ab7860d458d160371533842974fc61f96d15879b"
-
-[[package]]
-name = "coolor"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af4d7a805ca0d92f8c61a31c809d4323fdaa939b0b440e544d21db7797c5aaad"
-dependencies = [
- "crossterm",
-]
-
-[[package]]
-name = "core-foundation"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
-
-[[package]]
-name = "core_extensions"
-version = "1.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92c71dc07c9721607e7a16108336048ee978c3a8b129294534272e8bac96c0ee"
-dependencies = [
- "core_extensions_proc_macros",
-]
-
-[[package]]
-name = "core_extensions_proc_macros"
-version = "1.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69f3b219d28b6e3b4ac87bc1fc522e0803ab22e055da177bff0068c4150c61a6"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28d997bd5e24a5928dd43e46dc529867e207907fe0b239c3477d924f7f2ca320"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "cranelift"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0310bd7ad567c4e939b83fc497d334ebf5d6237ba1e2f4599d0c8b81be4a5f0"
-dependencies = [
- "cranelift-codegen",
- "cranelift-frontend",
-]
-
-[[package]]
-name = "cranelift-bforest"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fa7c3188913c2d11a361e0431e135742372a2709a99b103e79758e11a0a797e"
-dependencies = [
- "cranelift-entity",
-]
-
-[[package]]
-name = "cranelift-codegen"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29285f70fd396a8f64455a15a6e1d390322e4a5f5186de513141313211b0a23e"
-dependencies = [
- "cranelift-bforest",
- "cranelift-codegen-meta",
- "cranelift-codegen-shared",
- "cranelift-entity",
- "log",
- "regalloc2",
- "smallvec",
- "target-lexicon",
-]
-
-[[package]]
-name = "cranelift-codegen-meta"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "057eac2f202ec95aebfd8d495e88560ac085f6a415b3c6c28529dc5eb116a141"
-dependencies = [
- "cranelift-codegen-shared",
-]
-
-[[package]]
-name = "cranelift-codegen-shared"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75d93869efd18874a9341cfd8ad66bcb08164e86357a694a0e939d29e87410b9"
-
-[[package]]
-name = "cranelift-entity"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e34bd7a1fefa902c90a921b36323f17a398b788fa56a75f07a29d83b6e28808"
-
-[[package]]
-name = "cranelift-frontend"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "457018dd2d6ee300953978f63215b5edf3ae42dbdf8c7c038972f10394599f72"
-dependencies = [
- "cranelift-codegen",
- "log",
- "smallvec",
- "target-lexicon",
-]
-
-[[package]]
-name = "cranelift-jit"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fa7749513eea849d9b32d45d4d0561e0ad5545a9b2f69aee00ffd79f165c01c"
-dependencies = [
- "anyhow",
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-module",
- "cranelift-native",
- "libc",
- "log",
- "region",
- "target-lexicon",
- "winapi",
-]
-
-[[package]]
-name = "cranelift-module"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "734f00b74a59ffcb62e56f3d73cefdef91e87e56e0ce30f1365f678b0034d0e0"
-dependencies = [
- "anyhow",
- "cranelift-codegen",
-]
-
-[[package]]
-name = "cranelift-native"
-version = "0.84.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bba027cc41bf1d0eee2ddf16caba2ee1be682d0214520fff0129d2c6557fda89"
-dependencies = [
- "cranelift-codegen",
- "libc",
- "target-lexicon",
-]
-
-[[package]]
-name = "crc32fast"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
-[[package]]
-name = "criterion"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
-dependencies = [
- "anes",
- "cast",
- "ciborium",
- "clap",
- "criterion-plot",
- "is-terminal",
- "itertools",
- "num-traits",
- "once_cell",
- "oorandom",
- "plotters",
- "rayon",
- "regex",
- "serde",
- "serde_derive",
- "serde_json",
- "tinytemplate",
- "walkdir",
-]
-
-[[package]]
-name = "criterion-plot"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
-dependencies = [
- "cast",
- "itertools",
-]
-
-[[package]]
-name = "crossbeam"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2801af0d36612ae591caa9568261fddce32ce6e08a7275ea334a06a4ad021a2c"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-epoch",
- "crossbeam-queue",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2dd04ddaf88237dc3b8d8f9a3c1004b506b54b3313403944054d23c0870c521"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-deque"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "715e8152b692bba2d374b53d4875445368fdf21a94751410af607a5ac677d1fc"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-epoch",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01a9af1f4c2ef74bb8aa1f7e19706bc72d03598c8a570bb5de72243c7a9d9d5a"
-dependencies = [
- "autocfg",
- "cfg-if 1.0.0",
- "crossbeam-utils",
- "memoffset 0.7.1",
- "scopeguard",
-]
-
-[[package]]
-name = "crossbeam-queue"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1cfb3ea8a53f37c40dea2c7bedcbd88bdfae54f5e2175d6ecaff1c988353add"
-dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fb766fa798726286dbbb842f174001dab8abc7b627a1dd86e0b7222a95d929f"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
-[[package]]
-name = "crossterm"
-version = "0.23.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2102ea4f781910f8a5b98dd061f4c2023f479ce7bb1236330099ceb5a93cf17"
-dependencies = [
- "bitflags 1.3.2",
- "crossterm_winapi",
- "libc",
- "mio",
- "parking_lot",
- "signal-hook 0.3.14",
- "signal-hook-mio",
- "winapi",
-]
-
-[[package]]
-name = "crossterm_winapi"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ae1b35a484aa10e07fe0638d02301c5ad24de82d310ccbd2f3693da5f09bf1c"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "csscolorparser"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb2a7d3066da2de787b7f032c736763eb7ae5d355f81a68bab2675a96008b0bf"
-dependencies = [
- "lab",
- "phf 0.11.2",
-]
-
-[[package]]
-name = "cxx"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc831ee6a32dd495436e317595e639a587aa9907bef96fe6e6abc290ab6204e9"
-dependencies = [
- "cc",
- "cxxbridge-flags",
- "cxxbridge-macro",
- "link-cplusplus",
-]
-
-[[package]]
-name = "cxx-build"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94331d54f1b1a8895cd81049f7eaaaef9d05a7dcb4d1fd08bf3ff0806246789d"
-dependencies = [
- "cc",
- "codespan-reporting",
- "once_cell",
- "proc-macro2",
- "quote",
- "scratch",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "cxxbridge-flags"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48dcd35ba14ca9b40d6e4b4b39961f23d835dbb8eed74565ded361d93e1feb8a"
-
-[[package]]
-name = "cxxbridge-macro"
-version = "1.0.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81bbeb29798b407ccd82a3324ade1a7286e0d29851475990b612670f6f5124d2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "dashmap"
-version = "5.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "907076dfda823b0b36d2a1bb5f90c96660a5bbcd7729e10727f07858f22c4edc"
-dependencies = [
- "cfg-if 1.0.0",
- "hashbrown 0.12.3",
- "lock_api",
- "once_cell",
- "parking_lot_core",
-]
-
-[[package]]
-name = "deltae"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ef311e2c0a388b9ba56c839ac68d33b92d18ce7104d0acc4375cb479e2b9a53"
-
-[[package]]
-name = "digest"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "digest"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8168378f4e5023e7218c89c891c0fd8ecdb5e5e4f18cb78f38cf245dd021e76f"
-dependencies = [
- "block-buffer 0.10.3",
- "crypto-common",
-]
-
-[[package]]
-name = "dirs"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
-dependencies = [
- "dirs-sys",
-]
-
-[[package]]
-name = "dirs-next"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
-dependencies = [
- "cfg-if 1.0.0",
- "dirs-sys-next",
-]
-
-[[package]]
-name = "dirs-sys"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
-dependencies = [
- "libc",
- "redox_users",
- "winapi",
-]
-
-[[package]]
-name = "dirs-sys-next"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
-dependencies = [
- "libc",
- "redox_users",
- "winapi",
-]
-
-[[package]]
-name = "downcast-rs"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ea835d29036a4087793836fa931b08837ad5e957da9e23886b29586fb9b6650"
-
-[[package]]
-name = "either"
-version = "1.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
-
-[[package]]
-name = "encoding_rs"
-version = "0.8.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071a31f4ee85403370b58aca746f01041ede6f0da2730960ad001edc2b71b394"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
-[[package]]
-name = "endian-type"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
-
-[[package]]
-name = "env_logger"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0"
-dependencies = [
- "humantime",
- "is-terminal",
- "log",
- "regex",
- "termcolor",
-]
-
-[[package]]
-name = "errno"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
-dependencies = [
- "errno-dragonfly",
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "errno"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3e13f66a2f95e32a39eaa81f6b95d42878ca0e1db0c7543723dfe12557e860"
-dependencies = [
- "libc",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "error-code"
-version = "2.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64f18991e7bf11e7ffee451b5318b5c1a73c52d0d0ada6e5a3017c8c1ced6a21"
-dependencies = [
- "libc",
- "str-buf",
-]
-
-[[package]]
-name = "fallible-iterator"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
-
-[[package]]
-name = "fallible-streaming-iterator"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
-
-[[package]]
-name = "fastrand"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
-dependencies = [
- "instant",
-]
-
-[[package]]
-name = "fd-lock"
-version = "3.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ef1a30ae415c3a691a4f41afddc2dbcd6d70baf338368d85ebc1e8ed92cedb9"
-dependencies = [
- "cfg-if 1.0.0",
- "rustix 0.36.8",
- "windows-sys 0.45.0",
-]
-
-[[package]]
-name = "filedescriptor"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7199d965852c3bac31f779ef99cbb4537f80e952e2d6aa0ffeb30cce00f4f46e"
-dependencies = [
- "libc",
- "thiserror",
- "winapi",
-]
-
-[[package]]
-name = "finl_unicode"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fcfdc7a0362c9f4444381a9e697c79d435fe65b52a37466fc2c1184cee9edc6"
-
-[[package]]
-name = "fixedbitset"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
-
-[[package]]
-name = "flate2"
-version = "1.0.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b9429470923de8e8cbd4d2dc513535400b4b3fef0319fb5c4e1f520a7bef743"
-dependencies = [
- "crc32fast",
- "miniz_oxide",
-]
-
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
-dependencies = [
- "foreign-types-shared",
-]
-
-[[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
-
-[[package]]
-name = "form_urlencoded"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
-dependencies = [
- "percent-encoding",
-]
-
-[[package]]
-name = "futures"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-channel"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
-dependencies = [
- "futures-core",
- "futures-sink",
-]
-
-[[package]]
-name = "futures-core"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
-
-[[package]]
-name = "futures-executor"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
-dependencies = [
- "futures-core",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-io"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
-
-[[package]]
-name = "futures-macro"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "futures-sink"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
-
-[[package]]
-name = "futures-task"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
-
-[[package]]
-name = "futures-util"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite",
- "pin-utils",
- "slab",
-]
-
-[[package]]
-name = "fxhash"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
-dependencies = [
- "byteorder",
-]
-
-[[package]]
-name = "generational-arena"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1d3b771574f62d0548cee0ad9057857e9fc25d7a3335f140c84f6acd0bf601"
-dependencies = [
- "cfg-if 0.1.10",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff49e947297f3312447abdca79f45f4738097cc82b06e72054d2223f601f1b9"
-dependencies = [
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "wasi",
-]
-
-[[package]]
-name = "gimli"
-version = "0.27.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c80984affa11d98d1b88b66ac8853f143217b399d3c74116778ff8fdb4ed2e"
-
-[[package]]
-name = "h2"
-version = "0.3.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f9f29bc9dda355256b2916cf526ab02ce0aeaaaf2bad60d65ef3f12f11dd0f4"
-dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http",
- "indexmap",
- "slab",
- "tokio",
- "tokio-util",
- "tracing",
-]
-
-[[package]]
-name = "half"
-version = "1.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7"
-
-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-dependencies = [
- "ahash 0.7.6",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
-dependencies = [
- "ahash 0.8.6",
- "serde",
-]
-
-[[package]]
-name = "hashlink"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69fe1fcf8b4278d860ad0548329f892a3631fb63f82574df68275f34cdbe0ffa"
-dependencies = [
- "hashbrown 0.12.3",
-]
-
-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-
-[[package]]
-name = "hermit-abi"
-version = "0.1.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "856b5cb0902c2b6d65d5fd97dfa30f9b70c7538e770b98eab5ed52d8db923e01"
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "http"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399"
-dependencies = [
- "bytes",
- "fnv",
- "itoa",
-]
-
-[[package]]
-name = "http-body"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
-dependencies = [
- "bytes",
- "http",
- "pin-project-lite",
-]
-
-[[package]]
-name = "http-range-header"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bfe8eed0a9285ef776bb792479ea3834e8b94e13d615c2f66d03dd50a435a29"
-
-[[package]]
-name = "httparse"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
-
-[[package]]
-name = "httpdate"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
-
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
-[[package]]
-name = "hyper"
-version = "0.14.24"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e011372fa0b68db8350aa7a248930ecc7839bf46d8485577d69f117a75f164c"
-dependencies = [
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "httparse",
- "httpdate",
- "itoa",
- "pin-project-lite",
- "socket2",
- "tokio",
- "tower-service",
- "tracing",
- "want",
-]
-
-[[package]]
-name = "hyper-tls"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
-dependencies = [
- "bytes",
- "hyper",
- "native-tls",
- "tokio",
- "tokio-native-tls",
-]
-
-[[package]]
-name = "iana-time-zone"
-version = "0.1.53"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64c122667b287044802d6ce17ee2ddf13207ed924c712de9a66a5814d5b64765"
-dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "iana-time-zone-haiku",
- "js-sys",
- "wasm-bindgen",
- "winapi",
-]
-
-[[package]]
-name = "iana-time-zone-haiku"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0703ae284fc167426161c2e3f1da3ea71d94b21bedbcc9494e92b28e334e3dca"
-dependencies = [
- "cxx",
- "cxx-build",
-]
-
-[[package]]
-name = "idna"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "im-lists"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "280cfba4e434565a1275d357b3561ca98265e3715de9406eabd6198f7137fd21"
-
-[[package]]
-name = "im-rc"
-version = "15.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe"
-dependencies = [
- "bitmaps",
- "rand_core",
- "rand_xoshiro",
- "sized-chunks",
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "indexmap"
-version = "1.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
-dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
-]
-
-[[package]]
-name = "instant"
-version = "0.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
-[[package]]
-name = "io-lifetimes"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1abeb7a0dd0f8181267ff8adc397075586500b81b28a73e8a0208b00fc170fb3"
-dependencies = [
- "libc",
- "windows-sys 0.45.0",
-]
-
-[[package]]
-name = "ioctl-rs"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7970510895cee30b3e9128319f2cefd4bde883a39f38baa279567ba3a7eb97d"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "ipnet"
-version = "2.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30e22bd8629359895450b59ea7a776c850561b96a3b1d31321c1949d9e6c9146"
-
-[[package]]
-name = "is-terminal"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b"
-dependencies = [
- "hermit-abi 0.3.0",
- "rustix 0.38.13",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"
-
-[[package]]
-name = "js-sys"
-version = "0.3.61"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "lab"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf36173d4167ed999940f804952e6b08197cae5ad5d572eb4db150ce8ad5d58f"
-
-[[package]]
-name = "lasso"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4644821e1c3d7a560fe13d842d13f587c07348a1a05d3a797152d41c90c56df2"
-dependencies = [
- "dashmap",
- "hashbrown 0.13.2",
- "serde",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "libc"
-version = "0.2.147"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
-
-[[package]]
-name = "libloading"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f"
-dependencies = [
- "cfg-if 1.0.0",
- "winapi",
-]
-
-[[package]]
-name = "libm"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "348108ab3fba42ec82ff6e9564fc4ca0247bdccdc68dd8af9764bbc79c3c8ffb"
-
-[[package]]
-name = "libsqlite3-sys"
-version = "0.25.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29f835d03d717946d28b1d1ed632eb6f0e24a299388ee623d0c23118d3e8a7fa"
-dependencies = [
- "cc",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "link-cplusplus"
-version = "1.0.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd207c9c713c34f95a097a5b029ac2ce6010530c7b49d7fea24d977dede04f5"
-dependencies = [
- "cc",
-]
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f051f77a7c8e6957c0696eac88f26b0117e54f52d3fc682ab19397a8812846a4"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da2479e8c062e40bf0066ffa0bc823de0a9368974af99c9f6df941d2c231e03f"
-
-[[package]]
-name = "lock_api"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if 1.0.0",
-]
-
-[[package]]
-name = "lsp-types"
-version = "0.94.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c66bfd44a06ae10647fe3f8214762e9369fd4248df1350924b4ef9e770a85ea1"
-dependencies = [
- "bitflags 1.3.2",
- "serde",
- "serde_json",
- "serde_repr",
- "url",
-]
-
-[[package]]
-name = "mach"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "matchit"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b87248edafb776e59e6ee64a79086f65890d3510f2c656c000bf2a7e8a0aea40"
-
-[[package]]
-name = "memchr"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
-
-[[package]]
-name = "memmem"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a64a92489e2744ce060c349162be1c5f33c6969234104dbd99ddb5feb08b8c15"
-
-[[package]]
-name = "memoffset"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "memoffset"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de893c32cde5f383baa4c04c5d6dbdd735cfd4a794b0debdb2bb1b421da5ff4"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "mime"
-version = "0.3.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
-
-[[package]]
-name = "minimad"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fed1b13e2000bd8e238d97a97de6fc30224f89a08b0aa5aaa09ed1bd68ba2fa1"
-dependencies = [
- "once_cell",
-]
-
-[[package]]
-name = "miniz_oxide"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
-dependencies = [
- "adler",
-]
-
-[[package]]
-name = "mio"
-version = "0.8.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2"
-dependencies = [
- "libc",
- "log",
- "wasi",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "native-tls"
-version = "0.2.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
-dependencies = [
- "lazy_static",
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework",
- "security-framework-sys",
- "tempfile",
-]
-
-[[package]]
-name = "nibble_vec"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43"
-dependencies = [
- "smallvec",
-]
-
-[[package]]
-name = "nix"
-version = "0.24.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
-dependencies = [
- "bitflags 1.3.2",
- "cfg-if 1.0.0",
- "libc",
- "memoffset 0.6.5",
-]
-
-[[package]]
-name = "nix"
-version = "0.25.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f346ff70e7dbfd675fe90590b92d59ef2de15a8779ae305ebcbfd3f0caf59be4"
-dependencies = [
- "autocfg",
- "bitflags 1.3.2",
- "cfg-if 1.0.0",
- "libc",
- "memoffset 0.6.5",
- "pin-utils",
-]
-
-[[package]]
-name = "nom"
-version = "5.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08959a387a676302eebf4ddbcbc611da04285579f76f88ee0506c63b1a61dd4b"
-dependencies = [
- "memchr",
- "version_check",
-]
-
-[[package]]
-name = "nom8"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae01545c9c7fc4486ab7debaf2aad7003ac19431791868fb2e8066df97fad2f8"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "num"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43db66d1170d347f9a065114077f7dccb00c1b9478c89384490a3425279a4606"
-dependencies = [
- "num-bigint",
- "num-complex",
- "num-integer",
- "num-iter",
- "num-rational",
- "num-traits",
-]
-
-[[package]]
-name = "num-bigint"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
- "serde",
-]
-
-[[package]]
-name = "num-complex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02e0d21255c828d6f128a1e41534206671e8c3ea0c62f32291e808dc82cff17d"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-derive"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
-dependencies = [
- "autocfg",
- "num-traits",
-]
-
-[[package]]
-name = "num-iter"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252"
-dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-rational"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0"
-dependencies = [
- "autocfg",
- "num-bigint",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
-dependencies = [
- "autocfg",
- "libm",
-]
-
-[[package]]
-name = "num_cpus"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
-dependencies = [
- "hermit-abi 0.2.6",
- "libc",
-]
-
-[[package]]
-name = "object"
-version = "0.31.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bda667d9f2b5051b8833f59f3bf748b28ef54f850f4fcb389a252aa383866d1"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
-
-[[package]]
-name = "oorandom"
-version = "11.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
-
-[[package]]
-name = "opaque-debug"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
-
-[[package]]
-name = "openssl"
-version = "0.10.45"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b102428fd03bc5edf97f62620f7298614c45cedf287c271e7ed450bbaf83f2e1"
-dependencies = [
- "bitflags 1.3.2",
- "cfg-if 1.0.0",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-macros",
- "openssl-sys",
-]
-
-[[package]]
-name = "openssl-macros"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "openssl-probe"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
-
-[[package]]
-name = "openssl-sys"
-version = "0.9.80"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23bbbf7854cd45b83958ebe919f0e8e516793727652e27fda10a8384cfc790b7"
-dependencies = [
- "autocfg",
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "ordered-float"
-version = "3.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fc2dbde8f8a79f2102cc474ceb0ad68e3b80b85289ea62389b60e66777e4213"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "os_str_bytes"
-version = "6.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b7820b9daea5457c9f21c69448905d723fbd21136ccf521748f23fd49e723ee"
-
-[[package]]
-name = "parking_lot"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9069cbb9f99e3a5083476ccb29ceb1de18b9118cafa53e90c9551235de2b9521"
-dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-sys 0.45.0",
-]
-
-[[package]]
-name = "paste"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f746c4065a8fa3fe23974dd82f15431cc8d40779821001404d10d2e79ca7d79"
-
-[[package]]
-name = "percent-encoding"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
-
-[[package]]
-name = "pest"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f73935e4d55e2abf7f130186537b19e7a4abc886a0252380b59248af473a3fc9"
-dependencies = [
- "thiserror",
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aef623c9bbfa0eedf5a0efba11a5ee83209c326653ca31ff019bec3a95bfff2b"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3e8cba4ec22bada7fc55ffe51e2deb6a0e0db2d0b7ab0b103acc80d2510c190"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a01f71cb40bd8bb94232df14b946909e14660e33fc05db3e50ae2a82d7ea0ca0"
-dependencies = [
- "once_cell",
- "pest",
- "sha2 0.10.6",
-]
-
-[[package]]
-name = "phf"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabbf1ead8a5bcbc20f5f8b939ee3f5b0f6f281b6ad3468b84656b658b455259"
-dependencies = [
- "phf_shared 0.10.0",
-]
-
-[[package]]
-name = "phf"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc"
-dependencies = [
- "phf_macros",
- "phf_shared 0.11.2",
-]
-
-[[package]]
-name = "phf_codegen"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8d39688d359e6b34654d328e262234662d16cc0f60ec8dcbe5e718709342a5a"
-dependencies = [
- "phf_generator",
- "phf_shared 0.11.2",
-]
-
-[[package]]
-name = "phf_generator"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0"
-dependencies = [
- "phf_shared 0.11.2",
- "rand",
-]
-
-[[package]]
-name = "phf_macros"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b"
-dependencies = [
- "phf_generator",
- "phf_shared 0.11.2",
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096"
-dependencies = [
- "siphasher",
-]
-
-[[package]]
-name = "phf_shared"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b"
-dependencies = [
- "siphasher",
-]
-
-[[package]]
-name = "pin-project"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc"
-dependencies = [
- "pin-project-internal",
-]
-
-[[package]]
-name = "pin-project-internal"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "pin-project-lite"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
-
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
-[[package]]
-name = "pkg-config"
-version = "0.3.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
-
-[[package]]
-name = "plotters"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2538b639e642295546c50fcd545198c9d64ee2a38620a628724a3b266d5fbf97"
-dependencies = [
- "num-traits",
- "plotters-backend",
- "plotters-svg",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "plotters-backend"
-version = "0.3.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "193228616381fecdc1224c62e96946dfbc73ff4384fba576e052ff8c1bea8142"
-
-[[package]]
-name = "plotters-svg"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9a81d2759aae1dae668f783c308bc5c8ebd191ff4184aaa1b37f65a6ae5a56f"
-dependencies = [
- "plotters-backend",
-]
-
-[[package]]
-name = "portable-pty"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "806ee80c2a03dbe1a9fb9534f8d19e4c0546b790cde8fd1fea9d6390644cb0be"
-dependencies = [
- "anyhow",
- "bitflags 1.3.2",
- "downcast-rs",
- "filedescriptor",
- "lazy_static",
- "libc",
- "log",
- "nix 0.25.1",
- "serial",
- "shared_library",
- "shell-words",
- "winapi",
- "winreg",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
-
-[[package]]
-name = "pretty"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "563c9d701c3a31dfffaaf9ce23507ba09cbe0b9125ba176d15e629b0235e9acc"
-dependencies = [
- "arrayvec",
- "typed-arena",
- "unicode-segmentation",
-]
-
-[[package]]
-name = "proc-macro-error"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
-dependencies = [
- "proc-macro-error-attr",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
-dependencies = [
- "proc-macro2",
- "quote",
- "version_check",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.70"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39278fbbf5fb4f646ce651690877f89d1c5811a3d4acb27700c1cb3cdb78fd3b"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "proptest"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29f1b898011ce9595050a68e60f90bad083ff2987a695a42357134c8381fba70"
-dependencies = [
- "bit-set",
- "bitflags 1.3.2",
- "byteorder",
- "lazy_static",
- "num-traits",
- "quick-error 2.0.1",
- "rand",
- "rand_chacha",
- "rand_xorshift",
- "regex-syntax",
- "rusty-fork",
- "tempfile",
- "unarray",
-]
-
-[[package]]
-name = "quick-error"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
-
-[[package]]
-name = "quick-error"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a993555f31e5a609f617c12db6250dedcac1b0a85076912c436e6fc9b2c8e6a3"
-
-[[package]]
-name = "quickscope"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d47bcfc3e13850589cf9338a02b6dfb5aebb3748a0f93a392e8df91d6193b6b"
-dependencies = [
- "indexmap",
- "smallvec",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9ab9c7eadfd8df19006f1cf1a4aed13540ed5cbc047010ece5826e10825488"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "radix_fmt"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ce082a9940a7ace2ad4a8b7d0b1eac6aa378895f18be598230c5f2284ac05426"
-
-[[package]]
-name = "radix_trie"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
-dependencies = [
- "endian-type",
- "nibble_vec",
-]
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rand_xorshift"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d25bf25ec5ae4a3f1b92f929810509a2f53d7dca2f50b794ff57e3face536c8f"
-dependencies = [
- "rand_core",
-]
-
-[[package]]
-name = "rand_xoshiro"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
-dependencies = [
- "rand_core",
-]
-
-[[package]]
-name = "rayon"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db3a213adf02b3bcfd2d3846bb41cb22857d131789e01df434fb7e7bc0759b7"
-dependencies = [
- "either",
- "rayon-core",
-]
-
-[[package]]
-name = "rayon-core"
-version = "1.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "356a0625f1954f730c0201cdab48611198dc6ce21f4acff55089b5a78e6e835b"
-dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "num_cpus",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "redox_users"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
-dependencies = [
- "getrandom",
- "redox_syscall",
- "thiserror",
-]
-
-[[package]]
-name = "regalloc2"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "904196c12c9f55d3aea578613219f493ced8e05b3d0c6a42d11cb4142d8b4879"
-dependencies = [
- "fxhash",
- "log",
- "slice-group-by",
- "smallvec",
-]
-
-[[package]]
-name = "regex"
-version = "1.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.6.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
-
-[[package]]
-name = "region"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877e54ea2adcd70d80e9179344c97f93ef0dffd6b03e1f4529e6e83ab2fa9ae0"
-dependencies = [
- "bitflags 1.3.2",
- "libc",
- "mach",
- "winapi",
-]
-
-[[package]]
-name = "remove_dir_all"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "repr_offset"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb1070755bd29dffc19d0971cab794e607839ba2ef4b69a9e6fbc8733c1b72ea"
-dependencies = [
- "tstr",
-]
-
-[[package]]
-name = "reqwest"
-version = "0.11.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21eed90ec8570952d53b772ecf8f206aa1ec9a3d76b2521c56c42973f2d91ee9"
-dependencies = [
- "base64 0.21.0",
- "bytes",
- "encoding_rs",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "hyper",
- "hyper-tls",
- "ipnet",
- "js-sys",
- "log",
- "mime",
- "native-tls",
- "once_cell",
- "percent-encoding",
- "pin-project-lite",
- "serde",
- "serde_json",
- "serde_urlencoded",
- "tokio",
- "tokio-native-tls",
- "tower-service",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "winreg",
-]
-
-[[package]]
-name = "ring"
-version = "0.16.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
-dependencies = [
- "cc",
- "libc",
- "once_cell",
- "spin",
- "untrusted",
- "web-sys",
- "winapi",
-]
-
-[[package]]
-name = "ropey"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93411e420bcd1a75ddd1dc3caf18c23155eda2c090631a85af21ba19e97093b5"
-dependencies = [
- "smallvec",
- "str_indices",
-]
-
-[[package]]
-name = "rusqlite"
-version = "0.28.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01e213bc3ecb39ac32e81e51ebe31fd888a940515173e3a18a35f8c6e896422a"
-dependencies = [
- "bitflags 1.3.2",
- "fallible-iterator",
- "fallible-streaming-iterator",
- "hashlink",
- "libsqlite3-sys",
- "smallvec",
-]
-
-[[package]]
-name = "rustc-demangle"
-version = "0.1.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
-
-[[package]]
-name = "rustc_version"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
-dependencies = [
- "semver 1.0.16",
-]
-
-[[package]]
-name = "rustix"
-version = "0.36.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f43abb88211988493c1abb44a70efa56ff0ce98f233b7b276146f1f3f7ba9644"
-dependencies = [
- "bitflags 1.3.2",
- "errno 0.2.8",
- "io-lifetimes",
- "libc",
- "linux-raw-sys 0.1.4",
- "windows-sys 0.45.0",
-]
-
-[[package]]
-name = "rustix"
-version = "0.38.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7db8590df6dfcd144d22afd1b83b36c21a18d7cbc1dc4bb5295a8712e9eb662"
-dependencies = [
- "bitflags 2.4.1",
- "errno 0.3.5",
- "libc",
- "linux-raw-sys 0.4.10",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "rustls"
-version = "0.20.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fff78fc74d175294f4e83b28343315ffcfb114b156f0185e9741cb5570f50e2f"
-dependencies = [
- "log",
- "ring",
- "sct",
- "webpki",
-]
-
-[[package]]
-name = "rustls-native-certs"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0167bac7a9f490495f3c33013e7722b53cb087ecbe082fb0c6387c96f634ea50"
-dependencies = [
- "openssl-probe",
- "rustls-pemfile",
- "schannel",
- "security-framework",
-]
-
-[[package]]
-name = "rustls-pemfile"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d194b56d58803a43635bdc398cd17e383d6f71f9182b9a192c127ca42494a59b"
-dependencies = [
- "base64 0.21.0",
-]
-
-[[package]]
-name = "rustversion"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5583e89e108996506031660fe09baa5011b9dd0341b89029313006d1fb508d70"
-
-[[package]]
-name = "rusty-fork"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb3dcc6e454c328bb824492db107ab7c0ae8fcffe4ad210136ef014458c1bc4f"
-dependencies = [
- "fnv",
- "quick-error 1.2.3",
- "tempfile",
- "wait-timeout",
-]
-
-[[package]]
-name = "rustyline"
-version = "10.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1e83c32c3f3c33b08496e0d1df9ea8c64d39adb8eb36a1ebb1440c690697aef"
-dependencies = [
- "bitflags 1.3.2",
- "cfg-if 1.0.0",
- "clipboard-win",
- "dirs-next",
- "fd-lock",
- "libc",
- "log",
- "memchr",
- "nix 0.25.1",
- "radix_trie",
- "scopeguard",
- "unicode-segmentation",
- "unicode-width",
- "utf8parse",
- "winapi",
-]
-
-[[package]]
-name = "rustyline-derive"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "107c3d5d7f370ac09efa62a78375f94d94b8a33c61d8c278b96683fb4dbf2d8d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "ryu"
-version = "1.0.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"
-
-[[package]]
-name = "same-file"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "schannel"
-version = "0.1.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "713cfb06c7059f3588fb8044c0fad1d09e3c01d225e25b9220dbfdcf16dbb1b3"
-dependencies = [
- "windows-sys 0.42.0",
-]
-
-[[package]]
-name = "scopeguard"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
-
-[[package]]
-name = "scratch"
-version = "1.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddccb15bcce173023b3fedd9436f882a0739b8dfb45e4f6b6002bee5929f61b2"
-
-[[package]]
-name = "sct"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
-dependencies = [
- "ring",
- "untrusted",
-]
-
-[[package]]
-name = "security-framework"
-version = "2.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a332be01508d814fed64bf28f798a146d73792121129962fdf335bb3c49a4254"
-dependencies = [
- "bitflags 1.3.2",
- "core-foundation",
- "core-foundation-sys",
- "libc",
- "security-framework-sys",
-]
-
-[[package]]
-name = "security-framework-sys"
-version = "2.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31c9bb296072e961fcbd8853511dd39c2d8be2deb1e17c6860b1d30732b323b4"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
-[[package]]
-name = "semver"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
-dependencies = [
- "semver-parser",
-]
-
-[[package]]
-name = "semver"
-version = "1.0.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "semver-parser"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7"
-dependencies = [
- "pest",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.193"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.193"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.108"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serde_path_to_error"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26b04f22b563c91331a10074bda3dd5492e3cc39d56bd557e91c0af42b6c7341"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_repr"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f0a21fba416426ac927b1691996e82079f8b6156e920c85345f135b2e9ba2de"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "serde_spanned"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0efd8caf556a6cebd3b285caf480045fcc1ac04f6bd786b09a6f11af30c4fcf4"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_urlencoded"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
-dependencies = [
- "form_urlencoded",
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serial"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1237a96570fc377c13baa1b88c7589ab66edced652e43ffb17088f003db3e86"
-dependencies = [
- "serial-core",
- "serial-unix",
- "serial-windows",
-]
-
-[[package]]
-name = "serial-core"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f46209b345401737ae2125fe5b19a77acce90cd53e1658cda928e4fe9a64581"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "serial-unix"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f03fbca4c9d866e24a459cbca71283f545a37f8e3e002ad8c70593871453cab7"
-dependencies = [
- "ioctl-rs",
- "libc",
- "serial-core",
- "termios 0.2.2",
-]
-
-[[package]]
-name = "serial-windows"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c6d3b776267a75d31bbdfd5d36c0ca051251caafc285827052bc53bcdc8162"
-dependencies = [
- "libc",
- "serial-core",
-]
-
-[[package]]
-name = "sha1"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
-dependencies = [
- "cfg-if 1.0.0",
- "cpufeatures",
- "digest 0.10.6",
-]
-
-[[package]]
-name = "sha2"
-version = "0.9.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d58a1e1bf39749807d89cf2d98ac2dfa0ff1cb3faa38fbb64dd88ac8013d800"
-dependencies = [
- "block-buffer 0.9.0",
- "cfg-if 1.0.0",
- "cpufeatures",
- "digest 0.9.0",
- "opaque-debug",
-]
-
-[[package]]
-name = "sha2"
-version = "0.10.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
-dependencies = [
- "cfg-if 1.0.0",
- "cpufeatures",
- "digest 0.10.6",
-]
-
-[[package]]
-name = "shared_library"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a9e7e0f2bfae24d8a5b5a66c5b257a83c7412304311512a0c054cd5e619da11"
-dependencies = [
- "lazy_static",
- "libc",
-]
-
-[[package]]
-name = "shell-words"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24188a676b6ae68c3b2cb3a01be17fbf7240ce009799bb56d5b1409051e78fde"
-
-[[package]]
-name = "signal-hook"
-version = "0.1.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e31d442c16f047a671b5a71e2161d6e68814012b7f5379d269ebd915fac2729"
-dependencies = [
- "libc",
- "signal-hook-registry",
-]
-
-[[package]]
-name = "signal-hook"
-version = "0.3.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a253b5e89e2698464fc26b545c9edceb338e18a89effeeecfea192c3025be29d"
-dependencies = [
- "libc",
- "signal-hook-registry",
-]
-
-[[package]]
-name = "signal-hook-mio"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "29ad2e15f37ec9a6cc544097b78a1ec90001e9f71b81338ca39f430adaca99af"
-dependencies = [
- "libc",
- "mio",
- "signal-hook 0.3.14",
-]
-
-[[package]]
-name = "signal-hook-registry"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "siphasher"
-version = "0.3.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de"
-
-[[package]]
-name = "sized-chunks"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e"
-dependencies = [
- "bitmaps",
- "typenum",
-]
-
-[[package]]
-name = "slab"
-version = "0.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4614a76b2a8be0058caa9dbbaf66d988527d86d003c11a94fbd335d7661edcef"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "slice-group-by"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03b634d87b960ab1a38c4fe143b508576f075e7c978bfad18217645ebfdfa2ec"
-
-[[package]]
-name = "smallvec"
-version = "1.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
-
-[[package]]
-name = "socket2"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
-dependencies = [
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "spin"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
-
-[[package]]
-name = "steel-core"
-version = "0.5.0"
-dependencies = [
- "abi_stable",
- "anyhow",
- "async-ffi",
- "bincode",
- "chrono",
- "codespan-reporting",
- "cranelift",
- "cranelift-jit",
- "cranelift-module",
- "criterion",
- "env_logger",
- "futures-task",
- "futures-util",
- "fxhash",
- "im-lists",
- "im-rc",
- "lasso",
- "log",
- "num",
- "once_cell",
- "pretty",
- "proptest",
- "quickscope",
- "radix_fmt",
- "rand",
- "reqwest",
- "rusqlite",
- "serde",
- "serde_derive",
- "serde_json",
- "smallvec",
- "steel-derive",
- "steel-gen",
- "steel-parser",
- "termimad",
- "url",
- "weak-table",
- "which",
-]
-
-[[package]]
-name = "steel-derive"
-version = "0.4.0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "steel-doc"
-version = "0.5.0"
-dependencies = [
- "steel-core",
-]
-
-[[package]]
-name = "steel-gen"
-version = "0.2.0"
-dependencies = [
- "codegen",
- "serde",
- "serde_derive",
-]
-
-[[package]]
-name = "steel-interpreter"
-version = "0.5.0"
-dependencies = [
- "clap",
- "env_logger",
- "log",
- "once_cell",
- "serde",
- "steel-core",
- "steel-derive",
- "steel-doc",
- "steel-repl",
-]
-
-[[package]]
-name = "steel-language-server"
-version = "0.5.0"
-dependencies = [
- "dashmap",
- "env_logger",
- "log",
- "once_cell",
- "ropey",
- "serde",
- "serde_json",
- "steel-core",
- "tokio",
- "tower-lsp",
-]
-
-[[package]]
-name = "steel-parser"
-version = "0.4.0"
-dependencies = [
- "lasso",
- "num-bigint",
- "once_cell",
- "pretty",
- "serde",
- "serde_derive",
-]
-
-[[package]]
-name = "steel-pty"
-version = "0.1.0"
-dependencies = [
- "abi_stable",
- "futures",
- "log",
- "portable-pty",
- "steel-core",
- "strip-ansi-escapes",
- "termwiz",
- "tokio",
-]
-
-[[package]]
-name = "steel-repl"
-version = "0.5.0"
-dependencies = [
- "colored",
- "rustyline",
- "rustyline-derive",
- "steel-core",
- "steel-parser",
-]
-
-[[package]]
-name = "steel-sys-info"
-version = "0.5.0"
-dependencies = [
- "abi_stable",
- "steel-core",
- "sys-info",
-]
-
-[[package]]
-name = "steel-toml"
-version = "0.5.0"
-dependencies = [
- "abi_stable",
- "steel-core",
- "toml",
-]
-
-[[package]]
-name = "steel-values"
-version = "0.1.0"
-
-[[package]]
-name = "steel-webrequests"
-version = "0.1.0"
-dependencies = [
- "abi_stable",
- "steel-core",
- "ureq",
-]
-
-[[package]]
-name = "steel-webserver"
-version = "0.1.0"
-dependencies = [
- "abi_stable",
- "axum",
- "crossbeam",
- "serde_json",
- "steel-core",
- "tokio",
-]
-
-[[package]]
-name = "steel-websockets"
-version = "0.1.0"
-dependencies = [
- "abi_stable",
- "steel-core",
- "tungstenite",
-]
-
-[[package]]
-name = "str-buf"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e08d8363704e6c71fc928674353e6b7c23dcea9d82d7012c8faf2a3a025f8d0"
-
-[[package]]
-name = "str_indices"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9557cb6521e8d009c51a8666f09356f4b817ba9ba0981a305bd86aee47bd35c"
-
-[[package]]
-name = "strip-ansi-escapes"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "011cbb39cf7c1f62871aea3cc46e5817b0937b49e9447370c93cacbe93a766d8"
-dependencies = [
- "vte",
-]
-
-[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
-name = "syn"
-version = "1.0.107"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.39"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23e78b90f2fcf45d3e842032ce32e3f2d1545ba6636271dcbf24fa306d87be7a"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "sync_wrapper"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
-
-[[package]]
-name = "sys-info"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b3a0d0aba8bf96a0e1ddfdc352fc53b3df7f39318c71854910c3c4b024ae52c"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "target-lexicon"
-version = "0.12.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9410d0f6853b1d94f0e519fb95df60f29d2c1eff2d921ffdf01a4c8a3b54f12d"
-
-[[package]]
-name = "tempfile"
-version = "3.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
-dependencies = [
- "cfg-if 1.0.0",
- "fastrand",
- "libc",
- "redox_syscall",
- "remove_dir_all",
- "winapi",
-]
-
-[[package]]
-name = "termcolor"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "termimad"
-version = "0.21.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d86d19aafb932e65acc333b49cb0bd7d9c650a94fe3f2550ce91aea00f582a86"
-dependencies = [
- "coolor",
- "crossbeam",
- "crossterm",
- "minimad",
- "thiserror",
- "unicode-width",
-]
-
-[[package]]
-name = "terminfo"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da31aef70da0f6352dbcb462683eb4dd2bfad01cf3fc96cf204547b9a839a585"
-dependencies = [
- "dirs",
- "fnv",
- "nom",
- "phf 0.11.2",
- "phf_codegen",
-]
-
-[[package]]
-name = "termios"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5d9cf598a6d7ce700a4e6a9199da127e6819a61e64b68609683cc9a01b5683a"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "termios"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "411c5bf740737c7918b8b1fe232dca4dc9f8e754b8ad5e20966814001ed0ac6b"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "termwiz"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9509a978a10fcbace4991deae486ae10885e0f4c2c465123e08c9714a90648fa"
-dependencies = [
- "anyhow",
- "base64 0.21.0",
- "bitflags 1.3.2",
- "filedescriptor",
- "finl_unicode",
- "fixedbitset",
- "hex",
- "lazy_static",
- "libc",
- "log",
- "memmem",
- "nix 0.24.3",
- "num-derive",
- "num-traits",
- "ordered-float",
- "pest",
- "pest_derive",
- "phf 0.10.1",
- "regex",
- "semver 0.11.0",
- "sha2 0.9.9",
- "signal-hook 0.1.17",
- "siphasher",
- "terminfo",
- "termios 0.3.3",
- "thiserror",
- "ucd-trie",
- "unicode-segmentation",
- "vtparse",
- "wezterm-bidi",
- "wezterm-color-types",
- "wezterm-dynamic",
- "winapi",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.38"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a9cd18aa97d5c45c6603caea1da6628790b37f7a34b6ca89522331c5180fed0"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.38"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fb327af4685e4d03fa8cbcf1716380da910eeb2bb8be417e7f9fd3fb164f36f"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "tinytemplate"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
-dependencies = [
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "tinyvec"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
-[[package]]
-name = "tokio"
-version = "1.29.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "532826ff75199d5833b9d2c5fe410f29235e25704ee5f0ef599fb51c21f4a4da"
-dependencies = [
- "autocfg",
- "backtrace",
- "bytes",
- "libc",
- "mio",
- "num_cpus",
- "parking_lot",
- "pin-project-lite",
- "signal-hook-registry",
- "socket2",
- "tokio-macros",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "tokio-macros"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "tokio-native-tls"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d995660bd2b7f8c1568414c1126076c13fbb725c40112dc0120b78eb9b717b"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
-[[package]]
-name = "tokio-util"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bb2e075f03b3d66d8d8785356224ba688d2906a371015e225beeb65ca92c740"
-dependencies = [
- "bytes",
- "futures-core",
- "futures-sink",
- "pin-project-lite",
- "tokio",
- "tracing",
-]
-
-[[package]]
-name = "toml"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "772c1426ab886e7362aedf4abc9c0d1348a979517efedfc25862944d10137af0"
-dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ab8ed2edee10b50132aed5f331333428b011c99402b5a534154ed15746f9622"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.19.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f35c303ea3e062b6131be4de16debe23860b9d3f2396658f13b7af1987fb473"
-dependencies = [
- "indexmap",
- "nom8",
- "serde",
- "serde_spanned",
- "toml_datetime",
-]
-
-[[package]]
-name = "tower"
-version = "0.4.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
-dependencies = [
- "futures-core",
- "futures-util",
- "pin-project",
- "pin-project-lite",
- "tokio",
- "tower-layer",
- "tower-service",
- "tracing",
-]
-
-[[package]]
-name = "tower-http"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f873044bf02dd1e8239e9c1293ea39dad76dc594ec16185d0a1bf31d8dc8d858"
-dependencies = [
- "bitflags 1.3.2",
- "bytes",
- "futures-core",
- "futures-util",
- "http",
- "http-body",
- "http-range-header",
- "pin-project-lite",
- "tower",
- "tower-layer",
- "tower-service",
-]
-
-[[package]]
-name = "tower-layer"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
-
-[[package]]
-name = "tower-lsp"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4ba052b54a6627628d9b3c34c176e7eda8359b7da9acd497b9f20998d118508"
-dependencies = [
- "async-trait",
- "auto_impl",
- "bytes",
- "dashmap",
- "futures",
- "httparse",
- "lsp-types",
- "memchr",
- "serde",
- "serde_json",
- "tokio",
- "tokio-util",
- "tower",
- "tower-lsp-macros",
- "tracing",
-]
-
-[[package]]
-name = "tower-lsp-macros"
-version = "0.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84fd902d4e0b9a4b27f2f440108dc034e1758628a9b702f8ec61ad66355422fa"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "tower-service"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
-
-[[package]]
-name = "tracing"
-version = "0.1.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
-dependencies = [
- "cfg-if 1.0.0",
- "log",
- "pin-project-lite",
- "tracing-attributes",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-attributes"
-version = "0.1.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
-
-[[package]]
-name = "tracing-core"
-version = "0.1.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
-dependencies = [
- "once_cell",
-]
-
-[[package]]
-name = "try-lock"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
-
-[[package]]
-name = "tstr"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cca3264971090dec0feef3b455a3c178f02762f7550cf4592991ac64b3be2d7e"
-dependencies = [
- "tstr_proc_macros",
-]
-
-[[package]]
-name = "tstr_proc_macros"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e78122066b0cb818b8afd08f7ed22f7fdbc3e90815035726f0840d0d26c0747a"
-
-[[package]]
-name = "tungstenite"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30ee6ab729cd4cf0fd55218530c4522ed30b7b6081752839b68fcec8d0960788"
-dependencies = [
- "base64 0.13.1",
- "byteorder",
- "bytes",
- "http",
- "httparse",
- "log",
- "rand",
- "rustls",
- "rustls-native-certs",
- "sha1",
- "thiserror",
- "url",
- "utf-8",
- "webpki",
-]
-
-[[package]]
-name = "typed-arena"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6af6ae20167a9ece4bcb41af5b80f8a1f1df981f6391189ce00fd257af04126a"
-
-[[package]]
-name = "typenum"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
-
-[[package]]
-name = "unarray"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54675592c1dbefd78cbd98db9bacd89886e1ca50692a0692baefffdeb92dd58"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "84a22b9f218b40614adcb3f4ff08b703773ad44fa9423e4e0d346d5db86e4ebc"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
-name = "unicode-segmentation"
-version = "1.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
-
-[[package]]
-name = "unicode-width"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
-
-[[package]]
-name = "untrusted"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
-
-[[package]]
-name = "ureq"
-version = "2.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "338b31dd1314f68f3aabf3ed57ab922df95ffcd902476ca7ba3c4ce7b908c46d"
-dependencies = [
- "base64 0.13.1",
- "flate2",
- "log",
- "once_cell",
- "rustls",
- "serde",
- "serde_json",
- "url",
- "webpki",
- "webpki-roots",
-]
-
-[[package]]
-name = "url"
-version = "2.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
-dependencies = [
- "form_urlencoded",
- "idna",
- "percent-encoding",
- "serde",
-]
-
-[[package]]
-name = "utf-8"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
-
-[[package]]
-name = "utf8parse"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "936e4b492acfd135421d8dca4b1aa80a7bfc26e702ef3af710e0752684df5372"
-
-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
-
-[[package]]
-name = "version_check"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
-
-[[package]]
-name = "vte"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cbce692ab4ca2f1f3047fcf732430249c0e971bfdd2b234cf2c47ad93af5983"
-dependencies = [
- "arrayvec",
- "utf8parse",
- "vte_generate_state_changes",
-]
-
-[[package]]
-name = "vte_generate_state_changes"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d257817081c7dffcdbab24b9e62d2def62e2ff7d00b1c20062551e6cccc145ff"
-dependencies = [
- "proc-macro2",
- "quote",
-]
-
-[[package]]
-name = "vtparse"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d9b2acfb050df409c972a37d3b8e08cdea3bddb0c09db9d53137e504cfabed0"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "wait-timeout"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "walkdir"
-version = "2.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
-dependencies = [
- "same-file",
- "winapi",
- "winapi-util",
-]
-
-[[package]]
-name = "want"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
-dependencies = [
- "log",
- "try-lock",
-]
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.84"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
-dependencies = [
- "cfg-if 1.0.0",
- "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.84"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
-dependencies = [
- "bumpalo",
- "log",
- "once_cell",
- "proc-macro2",
- "quote",
- "syn 1.0.107",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-futures"
-version = "0.4.34"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454"
-dependencies = [
- "cfg-if 1.0.0",
- "js-sys",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.84"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.84"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.84"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
-
-[[package]]
-name = "weak-table"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "323f4da9523e9a669e1eaf9c6e763892769b1d38c623913647bfdc1532fe4549"
-
-[[package]]
-name = "web-sys"
-version = "0.3.61"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "webpki"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
-dependencies = [
- "ring",
- "untrusted",
-]
-
-[[package]]
-name = "webpki-roots"
-version = "0.22.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b6c71e40d7d2c34a5106301fb632274ca37242cd0c9d3e64dbece371a40a2d87"
-dependencies = [
- "webpki",
-]
-
-[[package]]
-name = "wezterm-bidi"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1560382cf39b0fa92473eae4d5b3772f88c63202cbf5a72c35db72ba99e66c36"
-dependencies = [
- "log",
- "wezterm-dynamic",
-]
-
-[[package]]
-name = "wezterm-color-types"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c6e7a483dd2785ba72705c51e8b1be18300302db2a78368dac9bc8773857777"
-dependencies = [
- "csscolorparser",
- "deltae",
- "lazy_static",
- "wezterm-dynamic",
-]
-
-[[package]]
-name = "wezterm-dynamic"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75e78c0cc60a76de5d93f9dad05651105351e151b6446ab305514945d7588aa"
-dependencies = [
- "log",
- "ordered-float",
- "strsim",
- "thiserror",
- "wezterm-dynamic-derive",
-]
-
-[[package]]
-name = "wezterm-dynamic-derive"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c9f5ef318442d07b3d071f9f43ea40b80992f87faee14bb4d017b6991c307f0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.107",
-]
-
-[[package]]
-name = "which"
-version = "4.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2441c784c52b289a054b7201fc93253e288f094e2f4be9058343127c4226a269"
-dependencies = [
- "either",
- "libc",
- "once_cell",
-]
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-util"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows-sys"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.1",
- "windows_aarch64_msvc 0.42.1",
- "windows_i686_gnu 0.42.1",
- "windows_i686_msvc 0.42.1",
- "windows_x86_64_gnu 0.42.1",
- "windows_x86_64_gnullvm 0.42.1",
- "windows_x86_64_msvc 0.42.1",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.45.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
-dependencies = [
- "windows-targets 0.42.1",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets 0.48.1",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e2522491fbfcd58cc84d47aeb2958948c4b8982e9a2d8a2a35bbaed431390e7"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.1",
- "windows_aarch64_msvc 0.42.1",
- "windows_i686_gnu 0.42.1",
- "windows_i686_msvc 0.42.1",
- "windows_x86_64_gnu 0.42.1",
- "windows_x86_64_gnullvm 0.42.1",
- "windows_x86_64_msvc 0.42.1",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.48.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05d4b17490f70499f20b9e791dcf6a299785ce8af4d709018206dc5b4953e95f"
-dependencies = [
- "windows_aarch64_gnullvm 0.48.0",
- "windows_aarch64_msvc 0.48.0",
- "windows_i686_gnu 0.48.0",
- "windows_i686_msvc 0.48.0",
- "windows_x86_64_gnu 0.48.0",
- "windows_x86_64_gnullvm 0.48.0",
- "windows_x86_64_msvc 0.48.0",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c9864e83243fdec7fc9c5444389dcbbfd258f745e7853198f365e3c4968a608"
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c8b1b673ffc16c47a9ff48570a9d85e25d265735c503681332589af6253c6c7"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de3887528ad530ba7bdbb1faa8275ec7a1155a45ffa57c37993960277145d640"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf4d1122317eddd6ff351aa852118a2418ad4214e6613a50e0191f7004372605"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1040f221285e17ebccbc2591ffdc2d44ee1f9186324dd3e84e99ac68d699c45"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "628bfdf232daa22b0d64fdb62b09fcc36bb01f05a3939e20ab73aaf9470d0463"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "447660ad36a13288b1db4d4248e857b510e8c3a225c822ba4fb748c0aafecffd"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
-
-[[package]]
-name = "winreg"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.7.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d6f15f7ade05d2a4935e34a457b936c23dc70a05cc1d97133dc99e7a3fe0f0e"
-dependencies = [
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.7.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbbad221e3f78500350ecbd7dfa4e63ef945c05f4c61cb7f4d3f84cd0bba649b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.39",
-]
diff --git a/Cargo.toml b/Cargo.toml
deleted file mode 100644
index 7c8196aeb..000000000
--- a/Cargo.toml
+++ /dev/null
@@ -1,46 +0,0 @@
-[package]
-name = "steel-interpreter"
-version.workspace = true
-authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
-edition = "2021"
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/mattwparas/steel"
-description = "Steel repl and command line interface"
-
-include = ["/src/**/*", "/Cargo.toml", "/README.md", "LICENSE*"]
-
-[workspace.package]
-version = "0.5.0"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[[bin]]
-name = "steel"
-path = "src/main.rs"
-
-[workspace.dependencies]
-# This has to line up with the workspace version above
-steel-core = { path = "./crates/steel-core", version = "0.5.0", features = ["web", "sqlite", "dylibs", "markdown"] }
-
-[dependencies]
-once_cell = "1.17.0"
-steel-core = { workspace = true } 
-steel-derive = { path = "./crates/steel-derive", version = "0.4.0"}
-steel-repl = { path = "./crates/steel-repl", version = "0.5.0" }
-env_logger = "0.10.0"
-log = "0.4.17"
-clap = { version = "4.1.4", features = ["derive"] }
-steel-doc = { path = "./crates/steel-doc", version = "0.5.0"}
-
-[dev-dependencies]
-serde = { version = "1.0.152", features = ["derive"] }
-
-[workspace]
-members = [
-    ".",
-    "crates/*",
-]
-
-[profile.release]
-# debug = false
-debug = true
-lto = true
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
deleted file mode 100644
index 261eeb9e9..000000000
--- a/LICENSE-APACHE
+++ /dev/null
@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/LICENSE-MIT b/LICENSE-MIT
deleted file mode 100644
index 24d539f06..000000000
--- a/LICENSE-MIT
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2020 Matthew Paras
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/README.md b/README.md
deleted file mode 100644
index 070e3ae32..000000000
--- a/README.md
+++ /dev/null
@@ -1,449 +0,0 @@
-# Steel
-<div align="center">
-    <img width="150px" src="images/styled.png">
-</div>
-
-<div align="center">
-
-An embeddable and extensible scheme dialect built in Rust.
-
-![Actions Status](https://github.com/mattwparas/steel/workflows/Build/badge.svg) 
-[![Coverage Status](https://coveralls.io/repos/github/mattwparas/steel/badge.svg?branch=master)](https://coveralls.io/github/mattwparas/steel?branch=master)
-[![Discord Chat](https://img.shields.io/discord/1152443024715034675.svg?logo=discord&label=discord)](https://discord.gg/WwFRXdN6HU)
-
-
-<a href="https://mattwparas.github.io/steel-playground/dev">
-    <b>Try it on the Playground</b>
-</a>
-
-
-</div>
-
-## Getting Started
-
-This github repository contains a cli interpreter. To try it out on the online playground, go to the [Steel playground](https://mattwparas.github.io/steel-playground/dev). To get started using a repl with the crates, make sure you first have rust installed.
-
-Then, clone the repo and run the following command:
-
-```bash
-cargo run
-```
-
-This will launch a REPL instance that looks something like this:
-
-<p align="center">
-  <img src="images/repl.gif" width="100%">
-</p>
-
-### Packages
-
-If you would like to install and use packages, please set the `STEEL_HOME` environment variable. This will be the location that packages get installed to. Steel currently does not assume any default.
-
-## About
-
-`Steel` is an embeddable scheme interpreter, with a standalone cli included as well. Inspired largely by Racket, the language seeks to be ergonomic scheme variant helpful for embedding in applications, or to be used on its own with high performance functions implemented in Rust. The language implementation itself contains a fairly powerful macro system based on the `syntax-rules` style and a bytecode virtual machine. At the moment, it is not explicitly compliant with any individual scheme specification.
-
-> **Warning**
-> The API is unstable with no guarantees, and may change at any time while pre 1.0. There are undoubtedly bugs that exist, and any major bug reports will be addressed quickly. That being said, I do use it as a daily driver for many scripting tasks myself.
-
-## Features
-
-* Limited `syntax-rules` style macros are supported
-* Easy integration with Rust functions and structs
-* Easily call a script from rust or via a separate file
-* Efficient - common functions and data structures are optimized for performance (`map`, `filter`, etc)
-* Higher order Contracts
-* Built in immutable data structures include:
-  * lists
-  * vectors
-  * hashmaps
-  * hashsets
-
-## Contracts
-
-Inspired by Racket's higher order contracts, `Steel` implements\* higher order contracts to enable design by contract, made easy with a `define/contract` macro for easier ergonomics. Racket makes use of a concept known as _blame_ which seeks to identify the violating party - `Steel` does not quite have fully fleshed out blame but that is a work in progress. Here are some examples:
-
-```scheme
-;; Simple flat contracts
-(define/contract (test x y)
-    (->/c even? even? odd?)
-    (+ x y 1))
-
-(test 2 2) ;; => 5
-
-(define/contract (test-violation x y)
-    (->/c even? even? odd?)
-    (+ x y 1))
-
-(test-violation 1 2) ;; contract violation
-
-```
-
-Contracts are implemented as _values_, so they are bound to functions. This enables the use of contract checking on functions themselves since functions can be passed around:
-
-```scheme
-;; Higher order contracts, check on application
-(define/contract (higher-order func y)
-    (->/c (->/c even? odd?) even? even?)
-    (+ 1 (func y)))
-
-(higher-order (lambda (x) (+ x 1)) 2) ;; => 4
-
-(define/contract (higher-order-violation func y)
-    (->/c (->/c even? odd?) even? even?)
-    (+ 1 (func y)))
-
-(higher-order-violation (lambda (x) (+ x 2)) 2) ;; contract violation
-```
-
-Contracts on functions do not get checked until they are applied, so a function returning a _contracted_ function won't cause a violation until that function is actually used:
-
-```scheme
-;; More higher order contracts, get checked on application
-(define/contract (output)
-    (->/c (->/c string? int?))
-    (lambda (x) 10))
-
-(define/contract (accept func)
-    (->/c (->/c string? int?) string?)
-    "cool cool cool")
-
-(accept (output)) ;; => "cool cool cool"
-
-;; different contracts on the argument
-(define/contract (accept-violation func)
-    (->/c (->/c string? string?) string?)
-    (func "applesauce")
-    "cool cool cool")
-
-(accept-violation (output)) ;; contract violation
-
-;; generates a function
-(define/contract (generate-closure)
-    (->/c (->/c string? int?))
-    (lambda (x) 10))
-
-;; calls generate-closure which should result in a contract violation
-(define/contract (accept-violation)
-    (->/c (->/c string? string?))
-    (generate-closure))
-
-((accept-violation) "test") ;; contract violation
-```
-
-Perhaps a more nuanced case:
-
-```scheme
-(define/contract (output)
-    (->/c (->/c string? int?))
-    (lambda (x) 10.2))
-
-(define/contract (accept)
-    (->/c (->/c string? number?))
-    (output))
-
-
-((accept) "test") ;; contract violation 10.2 satisfies number? but _not_ int?
-```
-
-\* Very much a work in progress
-
-## Transducers
-
-Inspired by clojure's transducers, `Steel` has a similar object that is somewhere half way in between transducers and iterators. Consider the following:
-
-```scheme
-
-(mapping (lambda (x) (+ x 1))) ;; => <#iterator>
-(filtering even?) ;; => <#iterator>
-(taking 15) ;; => <#iterator>
-
-(compose 
-    (mapping add1)
-    (filtering odd?)
-    (taking 15)) ;; => <#iterator>
-```
-
-Each of these expressions emit an `<#iterator>` object, which means they're compatible with  `transduce`. `transduce` takes a transducer (i.e. `<#iterator>`) and a collection that can be iterated (`list`, `vector`, `stream`, `hashset`, `hashmap`, `string`, `struct`) and applies the transducer.
-
-```scheme
-;; Accepts lists
-(transduce (list 1 2 3 4 5) (mapping (lambda (x) (+ x 1))) (into-list)) ;; => '(2 3 4 5 6)
-
-;; Accepts vectors
-(transduce (vector 1 2 3 4 5) (mapping (lambda (x) (+ x 1))) (into-vector)) ;; '#(2 3 4 5 6)
-
-;; Even accepts streams!
-(define (integers n)
-    (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(transduce (integers 0) (taking 5) (into-list)) ;; => '(0 1 2 3 4)
-```
-
-Transduce accepts a reducer function as well. Above we used `into-list` and `into-vector`, but below we can use any arbitrary reducer:
-
-```scheme
-;; (-> transducer reducing-function initial-value iterable)
-(transduce (list 0 1 2 3) (mapping (lambda (x) (+ x 1))) (into-reducer + 0)) ;; => 10
-```
-
-Compose just combines the iterator functions and lets us avoid intermediate allocation. The composition works left to right - it chains each value through the functions and then accumulates into the output type. See the following:
-
-```scheme
-(define xf 
-    (compose 
-        (mapping add1)
-        (filtering odd?)
-        (taking 5)))
-
-(transduce (range 0 100) xf (into-list)) ;; => '(1 3 5 7 9)
-```
-
-## Syntax Choices
-
-`Steel` is mildly opinionated in that there a few ways to define variables and functions. These choices are fairly arbitrary except for the shorthand function syntax, which I borrowed from Racket. `defn` and `fn` were really encouraged by me wanting to type less characters.
-
-```scheme
-
-;; All of the following are equivalent
-(define (foo x) (+ x 1))
-(define foo (lambda (x) (+ x 1)))
-(defn (foo x) (+ x 1))
-(defn foo (lambda (x) (+ x 1)))
-
-;; All of the following are equivalent
-(lambda (x) (+ x 1))
-(λ (x) (+ x 1))
-(fn (x) (+ x 1))
-```
-
-## Modules
-
-In order to support a growing codebase, Steel has module support for projects spanning multiple files. Steel files can `provide` values (with contracts attached) and `require` modules from other files:
-
-```scheme
-;; main.scm
-(require "provide.scm")
-
-(even->odd 10)
-
-
-;; provide.scm
-(provide 
-    (contract/out even->odd (->/c even? odd?))
-    no-contract
-    flat-value)
-
-(define (even->odd x) 
-    (+ x 1))
-
-(define (accept-number x) (+ x 10))
-
-(define (no-contract) "cool cool cool")
-(define flat-value 15)
-
-(displayln "Calling even->odd with some bad inputs but its okay")
-(displayln (even->odd 1))
-```
-
-Here we can see if we were to run `main` that it would include the contents of `provide`, and only provided values would be accessible from `main`. The contract is attached at the contract boundary, so inside the `provide` module, you can violate the contract, but outside the module the contract will be applied.
-
-A few notes on modules:
-* Cyclical dependencies are not allowed
-* Modules will be only compiled once and used across multiple files. If `A` requires `B` and `C`, and `B` requires `C`, `C` will be compiled once and shared between `A` and `B`. 
-* Modules will be recompiled when changed, and any dependent files will also be recompiled as necessary
-
-## Performance
-
-Preliminary benchmarks show the following on my machine:
-
-| Benchmark | Steel    | Python   |
-| --------- | -------- | -------- |
-| (fib 28)  | 63.383ms | 65.10 ms |
-| (ack 3 3) | 0.303 ms | 0.195 ms |
-
-## Examples of embedding Rust values in the virtual machine
-
-Rust values, types, and functions are easily embedded into Steel. Using the `register_fn` call, you can embed functions easily:
-
-```rust
-use steel_vm::engine::Engine;
-use steel_vm::register_fn::RegisterFn;
-
-fn external_function(arg1: usize, arg2: usize) -> usize {
-    arg1 + arg2
-}
-
-fn option_function(arg1: Option<String>) -> Option<String> {
-    arg1
-}
-
-fn result_function(arg1: Option<String>) -> Result<String, String> {
-    if let Some(inner) = arg1 {
-        Ok(inner)
-    } else {
-        Err("Got a none".to_string())
-    }
-}
-
-pub fn main() {
-    let mut vm = Engine::new();
-
-    // Here we can register functions
-    // Any function can accept parameters that implement `FromSteelVal` and
-    // return values that implement `IntoSteelVal`
-    vm.register_fn("external-function", external_function);
-
-    // See the docs for more information about `FromSteelVal` and `IntoSteelVal`
-    // but we can see even functions that accept/return Option<T> or Result<T,E>
-    // can be registered
-    vm.register_fn("option-function", option_function);
-
-    // Result values will map directly to errors in the VM and bubble back up
-    vm.register_fn("result-function", result_function);
-
-    vm.run(
-        r#"
-        (define foo (external-function 10 25))
-        (define bar (option-function "applesauce"))
-        (define baz (result-function "bananas"))
-    "#,
-    )
-    .unwrap();
-
-    let foo = vm.extract::<usize>("foo").unwrap();
-    println!("foo: {}", foo);
-    assert_eq!(35, foo);
-
-    // Can also extract a value by specifying the type on the variable
-    let bar: String = vm.extract("bar").unwrap();
-    println!("bar: {}", bar);
-    assert_eq!("applesauce".to_string(), bar);
-
-    let baz: String = vm.extract("baz").unwrap();
-    println!("baz: {}", baz);
-    assert_eq!("bananas".to_string(), baz);
-}
-```
-
-We can also embed structs themselves:
-
-```rust
-use steel_vm::engine::Engine;
-use steel_vm::register_fn::RegisterFn;
-
-use steel_derive::Steel;
-
-// In order to register a type with Steel,
-// it must implement Clone, Debug, and Steel
-#[derive(Clone, Debug, Steel, PartialEq)]
-pub struct ExternalStruct {
-    foo: usize,
-    bar: String,
-    baz: f64,
-}
-
-impl ExternalStruct {
-    pub fn new(foo: usize, bar: String, baz: f64) -> Self {
-        ExternalStruct { foo, bar, baz }
-    }
-
-    // Embedding functions that take self by value
-    pub fn method_by_value(self) -> usize {
-        self.foo
-    }
-
-    pub fn method_by_reference(&self) -> usize {
-        self.foo
-    }
-
-    // Setters should update the value and return a new instance (functional set)
-    pub fn set_foo(mut self, foo: usize) -> Self {
-        self.foo = foo;
-        self
-    }
-}
-
-pub fn main() {
-    let mut vm = Engine::new();
-
-    // Registering a type gives access to a predicate for the type
-    vm.register_type::<ExternalStruct>("ExternalStruct?");
-
-    // Structs in steel typically have a constructor that is the name of the struct
-    vm.register_fn("ExternalStruct", ExternalStruct::new);
-
-    // register_fn can be chained
-    vm.register_fn("method-by-value", ExternalStruct::method_by_value)
-        .register_fn("method-by-reference", ExternalStruct::method_by_reference)
-        .register_fn("set-foo", ExternalStruct::set_foo);
-
-    let external_struct = ExternalStruct::new(1, "foo".to_string(), 12.4);
-
-    // Registering an external value is fallible if the conversion fails for some reason
-    // For instance, registering an Err(T) is fallible. However, most implementation outside of manual
-    // ones should not fail
-    vm.register_external_value("external-struct", external_struct)
-        .unwrap();
-
-    let output = vm
-        .run(
-            r#"
-            (define new-external-struct (set-foo external-struct 100))
-            (define get-output (method-by-value external-struct))
-            (define second-new-external-struct (ExternalStruct 50 "bananas" 72.6))
-            "last-result"
-        "#,
-        )
-        .unwrap();
-
-    let new_external_struct = vm.extract::<ExternalStruct>("new-external-struct").unwrap();
-    println!("new_external_struct: {:?}", new_external_struct);
-    assert_eq!(
-        ExternalStruct::new(100, "foo".to_string(), 12.4),
-        new_external_struct
-    );
-
-    // Can also extract a value by specifying the type on the variable
-    let get_output: usize = vm.extract("get-output").unwrap();
-    println!("get_output: {}", get_output);
-    assert_eq!(1, get_output);
-
-    let second_new_external_struct: ExternalStruct =
-        vm.extract("second-new-external-struct").unwrap();
-    println!(
-        "second_new_external_struct: {:?}",
-        second_new_external_struct
-    );
-    assert_eq!(
-        ExternalStruct::new(50, "bananas".to_string(), 72.6),
-        second_new_external_struct
-    );
-
-    // We also get the output of the VM as the value of every expression run
-    // we can inspect the results just by printing like so
-    println!("{:?}", output);
-}
-```
-
-See the examples folder for more examples on embedding values and interacting with the outside world.
-
-
-## License
-
-Licensed under either of
-
- * Apache License, Version 2.0
-   ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license
-   ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
-
-at your option.
-
-## Contribution
-
-Unless you explicitly state otherwise, any contribution intentionally submitted
-for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
-dual licensed as above, without any additional terms or conditions.
-
-See [CONTRIBUTING.md](./CONTRIBUTING.md).
diff --git a/benchmarks/ack/ack.lua b/benchmarks/ack/ack.lua
deleted file mode 100644
index e0f080a5c..000000000
--- a/benchmarks/ack/ack.lua
+++ /dev/null
@@ -1,15 +0,0 @@
--- Computes values of Ackermann function
--- See: http://en.wikipedia.org/wiki/Ackermann_function
-
--- m : a nonnegative integer
--- n : a nonnegative integer
--- return : the value of Ackermann(m, n)
-function ackermann(m, n)
-    if m == 0 then return n + 1 end
-    if n == 0 then return ackermann(m-1,1) end
-    return ackermann(m-1, ackermann(m, n-1))
-  end
-
-for i=1, 50 do
-  ackermann(3, 3)
-end
\ No newline at end of file
diff --git a/benchmarks/ack/ack.py b/benchmarks/ack/ack.py
deleted file mode 100644
index 68811d328..000000000
--- a/benchmarks/ack/ack.py
+++ /dev/null
@@ -1,10 +0,0 @@
-def ack1(M, N):
-    return (
-        (N + 1)
-        if M == 0
-        else (ack1(M - 1, 1) if N == 0 else ack1(M - 1, ack1(M, N - 1)))
-    )
-
-
-for i in range(50):
-    ack1(3, 3)
diff --git a/benchmarks/ack/ack.scm b/benchmarks/ack/ack.scm
deleted file mode 100644
index 6a298bfab..000000000
--- a/benchmarks/ack/ack.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-(define (ackermann m n)
-  (cond [(equal? m 0) (+ n 1)]
-        [(equal? n 0) (ackermann (- m 1) 1)]
-        [else (ackermann (- m 1) (ackermann m (- n 1)))]))
-
-(define (loop x)
-  (if (equal? x 100)
-      #true
-      (begin
-        (ackermann 3 3)
-        (loop (+ x 1)))))
-
-
-(loop 50)
diff --git a/benchmarks/bench.scm b/benchmarks/bench.scm
deleted file mode 100644
index e11824416..000000000
--- a/benchmarks/bench.scm
+++ /dev/null
@@ -1,62 +0,0 @@
-(define print displayln)
-
-(define (build-release)
-  (~> (command "cargo" '("build" "--release")) (spawn-process) (Ok->value) (wait)))
-
-(define (run-bench args)
-  (~> (command "hyperfine" args) (spawn-process) (Ok->value) (wait)))
-
-(define *interpreter-map* (hash "py" "python3.10" "scm" "../target/release/steel" "lua" "lua"))
-
-(define (extension->interpreter ext)
-  (hash-get *interpreter-map* ext))
-
-(define (combine-interpreter-and-path interpreter path)
-  (string-append (string-append interpreter " ") path))
-
-(define (path->command-fragment path)
-  (define interpreter (~> path (path->extension) (extension->interpreter)))
-  (if (list? interpreter)
-      (map (lambda (interp) (combine-interpreter-and-path interp path)) interpreter)
-      (combine-interpreter-and-path interpreter path)))
-
-(define (directory->bench-command dir)
-  (flatten (map path->command-fragment (read-dir dir))))
-
-(define (bench-group dir . options)
-  (run-bench (append (filter (lambda (x) (not (ends-with? x ".lua"))) (directory->bench-command dir))
-                     options)))
-
-(define *benches*
-  '(("startup" "--warmup" "10" "--min-runs" "100") ("map" "--warmup" "10")
-                                                   ("ack" "--warmup" "10")
-                                                   ("fib" "--warmup" "10" "--min-runs" "40")
-                                                   ("bin-trees" "--warmup" "10")))
-
-(define (main)
-  (print "Building steel for release...")
-  (build-release)
-  (print "Running benches...")
-  (transduce *benches*
-             (mapping (lambda (args)
-                        (newline)
-                        (apply bench-group args)))
-             (into-list))
-
-  ; (bench-group "bin-trees")
-  (print "Done"))
-
-(main)
-
-; (define (main)
-;     (displayln "Building steel for release...")
-;     (build-release)
-;     (displayln "Running benches...")
-;     (run-bench "../target/release/steel startup/startup.scm" "python3.10 startup/startup.py" "--warmup" "10" "--min-runs" "100")
-;     (run-bench "../target/release/steel fib/fib.scm" "python3.10 fib/fib.py" "--warmup" "10" "--min-runs" "40")
-;     ; (run-bench '("../target/release/steel fib/fib.scm" "python3 fib/fib.py" "lua fib/fib.lua" "--warmup" "10" "--min-runs" "40"))
-;     ; (run-bench '("../target/release/steel ack/ack.scm" "python3 ack/ack.py" "lua ack/ack.lua" "--warmup" "10" "--min-runs" "40"))
-;     ; (run-bench '("../target/release/steel bin-trees/bin-trees.scm" "python3 bin-trees/bin_trees.py" "--warmup" "5"))
-;     (displayln "Done"))
-
-; (main)
diff --git a/benchmarks/bin-trees/bin-trees.py b/benchmarks/bin-trees/bin-trees.py
deleted file mode 100644
index 61a1f2047..000000000
--- a/benchmarks/bin-trees/bin-trees.py
+++ /dev/null
@@ -1,40 +0,0 @@
-import sys
-
-
-def make_tree(depth):
-    if not depth:
-        return None, None
-    depth -= 1
-    return make_tree(depth), make_tree(depth)
-
-
-def check_tree(node):
-    (left, right) = node
-    if not left:
-        return 1
-    return 1 + check_tree(left) + check_tree(right)
-
-
-min_depth = 4
-max_depth = max(min_depth + 2, 12)
-stretch_depth = max_depth + 1
-
-print(
-    "stretch tree of depth %d\t check:" % stretch_depth,
-    check_tree(make_tree(stretch_depth)),
-)
-
-long_lived_tree = make_tree(max_depth)
-
-iterations = 2**max_depth
-
-for depth in range(min_depth, stretch_depth, 2):
-
-    check = 0
-    for i in range(1, iterations + 1):
-        check += check_tree(make_tree(depth))
-
-    print("%d\t trees of depth %d\t check:" % (iterations, depth), check)
-    iterations //= 4
-
-print("long lived tree of depth %d\t check:" % max_depth, check_tree(long_lived_tree))
diff --git a/benchmarks/bin-trees/bin-trees.scm b/benchmarks/bin-trees/bin-trees.scm
deleted file mode 100644
index ede6271ab..000000000
--- a/benchmarks/bin-trees/bin-trees.scm
+++ /dev/null
@@ -1,64 +0,0 @@
-; #lang racket/base
-
-;;; The Computer Language Benchmarks Game
-;;; https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
-
-;;; Derived from the Chicken variant by Sven Hartrumpf
-;;; contributed by Matthew Flatt
-;;; *reset*
-
-; (require racket/cmdline)
-
-(struct node (left val right))
-
-;; Instead of (define-struct leaf (val)):
-(define (leaf val)
-  (node #f val #f))
-(define (leaf? l)
-  (not (node-left l)))
-(define (leaf-val l)
-  node-val)
-
-(define (make item d)
-  (if (= d 0)
-      (leaf item)
-      (let ([item2 (* item 2)] [d2 (- d 1)]) (node (make (- item2 1) d2) item (make item2 d2)))))
-
-(define (check t)
-  (if (leaf? t) 1 (+ 1 (+ (check (node-left t)) (check (node-right t))))))
-
-(define (iterate n m d sum)
-  (if (equal? n m) sum (iterate (+ n 1) m d (+ sum (check (make n d))))))
-
-(define (max x y)
-  (if (> x y) x y))
-
-(define (loop d end max-depth min-depth)
-  (if (>= d end)
-      void
-      (begin
-        (let ([iterations (arithmetic-shift 1 (+ (- max-depth d) min-depth))])
-          (displayln iterations " trees of depth " d " check: " (iterate 0 iterations d 0)))
-        (loop (+ 2 d) end max-depth min-depth))))
-
-(define (main n)
-  (let* ([min-depth 4] [max-depth (max (+ min-depth 2) n)])
-    (let ([stretch-depth (+ max-depth 1)])
-      (displayln "stretch tree of depth " stretch-depth " check: " (check (make 0 stretch-depth))))
-    (let ([long-lived-tree (make 0 max-depth)])
-      ; (begin
-      ; (define end )
-
-      (loop 4 (add1 max-depth) max-depth min-depth)
-
-      ; )
-
-      (displayln "long lived tree of depth " max-depth " check: " (check long-lived-tree)))))
-
-(main 12)
-
-; (main 21)
-; (main 21)
-
-; (command-line #:args (n)
-;               (main (string->number n)))
diff --git a/benchmarks/fib/fib.lua b/benchmarks/fib/fib.lua
deleted file mode 100644
index 9101c3c5e..000000000
--- a/benchmarks/fib/fib.lua
+++ /dev/null
@@ -1,9 +0,0 @@
-function fibonacci(n)
-    if n<=2 then
-        return 1
-    else
-        return fibonacci(n-1) + fibonacci(n-2)
-    end
-end
-
-fibonacci(28)
\ No newline at end of file
diff --git a/benchmarks/fib/fib.py b/benchmarks/fib/fib.py
deleted file mode 100644
index ae96d1e64..000000000
--- a/benchmarks/fib/fib.py
+++ /dev/null
@@ -1,7 +0,0 @@
-def fib(n):
-    if n <= 2:
-        return 1
-    return fib(n - 1) + fib(n - 2)
-
-
-fib(30)
diff --git a/benchmarks/fib/fib.scm b/benchmarks/fib/fib.scm
deleted file mode 100644
index cdafaefa2..000000000
--- a/benchmarks/fib/fib.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(define (fib n) 
-    (if (<= n 2) 
-        1
-        (+ (fib (- n 1)) (fib (- n 2)))))
-
-(fib 30)
\ No newline at end of file
diff --git a/benchmarks/map/map.py b/benchmarks/map/map.py
deleted file mode 100644
index 4ab083655..000000000
--- a/benchmarks/map/map.py
+++ /dev/null
@@ -1,3 +0,0 @@
-lst = [x + 1 for x in range(0, 10000)]
-
-print(len(lst))
diff --git a/benchmarks/map/map.scm b/benchmarks/map/map.scm
deleted file mode 100644
index 7039533b9..000000000
--- a/benchmarks/map/map.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-(define lst (map (lambda (x) (+ x 1)) (range 0 10000)))
-
-(displayln (length lst))
\ No newline at end of file
diff --git a/benchmarks/recursive/map.scm b/benchmarks/recursive/map.scm
deleted file mode 100644
index 894b67b41..000000000
--- a/benchmarks/recursive/map.scm
+++ /dev/null
@@ -1,23 +0,0 @@
-(define (map func lst)
-  (if (empty? lst)
-    '()
-    (cons (func (first lst)) (map func (rest lst)))))
-
-;; To do the tail recursion modulo cons, we'd need a special op code for tail recursive cons, where
-;; the second argument to cons is recursive with respect to itself
-;; 
-;; So in this case:
-;; (cons (func (first lst)) (map func (rest lst)))
-;;                          ^^^^ is the recursive call to itself, which occurs in the second position
-;; 
-;; This can be lifted up into something like this:
-(define (map2 func lst)
-  (define (map2-trmc func lst accum)
-    (if (empty? lst)
-        accum
-        (map2-trmc func (cdr lst) (begin (vector-push! accum (func (first lst)))
-                                         accum))
-    
-    ))
-  (mutable-vector->list (map2-trmc func lst (mutable-vector))))
-
diff --git a/benchmarks/startup/startup.lua b/benchmarks/startup/startup.lua
deleted file mode 100644
index 442659b88..000000000
--- a/benchmarks/startup/startup.lua
+++ /dev/null
@@ -1 +0,0 @@
-print("Hello world!")
\ No newline at end of file
diff --git a/benchmarks/startup/startup.py b/benchmarks/startup/startup.py
deleted file mode 100644
index f1a18139c..000000000
--- a/benchmarks/startup/startup.py
+++ /dev/null
@@ -1 +0,0 @@
-print("Hello world!")
diff --git a/benchmarks/startup/startup.scm b/benchmarks/startup/startup.scm
deleted file mode 100644
index dba7be1b8..000000000
--- a/benchmarks/startup/startup.scm
+++ /dev/null
@@ -1 +0,0 @@
-(displayln "Hello world!")
\ No newline at end of file
diff --git a/build.sh b/build.sh
deleted file mode 100644
index 3a83e2956..000000000
--- a/build.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-cd crates/
-
-cd steel-sys-info && cargo-steel-lib && cd ..
-
-# cd steel-toml && cargo-steel-lib && cd ..
-# cd steel-webserver && cargo-steel-lib && cd ..
-# cd example-dylib && cargo-steel-lib && cd ..
-
-cargo build
-
-cd ..
\ No newline at end of file
diff --git a/cogs/clos/clos.scm b/cogs/clos/clos.scm
deleted file mode 100644
index 040ddf74d..000000000
--- a/cogs/clos/clos.scm
+++ /dev/null
@@ -1,223 +0,0 @@
-;; ---------------------------- Class Object definitions --------------------------------------------
-
-(struct Class-Object (name parents interfaces fields methods) #:mutable #:transparent)
-(struct Interface (name methods))
-(struct Class-Instance (class-object fields) #:transparent)
-
-(define (list-subset? left right)
-  (hashset-subset? (list->hashset left) (list->hashset right)))
-
-;; Classes contain:
-;; A name, which is required to be a symbol (string should also work, but for now a symbol simplifies this)
-;; The parents are a list of class objects -> we don't want classes pointing to arbitrary objects
-;; The fields are represented by a list of symbols, to refer to using the get-slot method
-;; The methods in theory could be anything, as long as they're functions.
-;;
-;; Here we don't restrict the hash map of symbol -> function, but rather will restrict it on the
-;; function when adding the methods.
-(define/contract (Class name parents interfaces fields methods)
-  (->/c symbol? (listof Class-Object?) (listof Interface?) (listof symbol?) hash? Class-Object?)
-  (unless (list-subset?
-           ;; Collect the list of required methods for the given interfaces
-           (transduce interfaces (flat-mapping Interface-methods) (into-list))
-           ;; Extract the methods that have been defined concretely on this class at construction
-           (hash-keys->list methods))
-    (error! "Not all required methods are implemented for the given interfaces"))
-
-  (Class-Object name
-                parents
-                interfaces
-                ;; Explicitly go collect the fields to flatten into this class given the
-                ;; class hierarchy
-                (combine-local-and-parent-fields fields parents)
-                methods))
-
-(define (Make-Class name
-                    #:fields (fields '())
-                    #:methods (methods '())
-                    #:parents (parents '())
-                    #:interfaces (interfaces '()))
-  (Class name parents interfaces fields methods))
-
-(define (contains-duplicates? lst)
-  (not (equal? (hashset-length (apply hashset lst)) (length lst))))
-
-;; Flatten the incoming list
-(define (flatten lst)
-  (transduce lst (flattening) (into-list)))
-
-(define (collect-fields list-of-class-objects)
-  (transduce list-of-class-objects (flat-mapping Class-Object-fields) (into-list)))
-
-(define (combine-local-and-parent-fields local-fields list-of-class-objects)
-  (let ([appended (append local-fields (collect-fields list-of-class-objects))])
-    (if (contains-duplicates? appended) (error! "Class field is unresolvable") appended)))
-
-;; -----------------------------------------------------------------------------------------------------
-
-;; Add a method to a class
-;; This can also occur in the root definition of the object in the hash, but the contract
-;; won't be checked there at the moment TODO
-(define/contract (define-method class-object name method)
-  (->/c Class-Object? symbol? function? any/c)
-  (let ([methods (Class-Object-methods class-object)])
-    (set-Class-Object-methods! class-object (hash-insert methods name method))))
-
-(define (resolve-parent-method class-object name)
-  (let ([possible-methods (map (lambda (x) (get-method x name)) (Class-Object-parents class-object))])
-    (if (equal? 1 (length possible-methods))
-        (car possible-methods)
-        (error! "Unable to resolve the method on the class instance"))))
-
-;; Attempt to resolve the method on the class object via the class hierarchy
-;; This checks the current class object, and then attempt to resolve the method upwards, returning the first
-;; one that it finds. If there are multiple candidates, we bail and error out since we can't determine
-;; which method we intended to call.
-(define/contract (get-method class-object name)
-  (->/c Class-Object? symbol? function?)
-  (let ([local-method (-> class-object (Class-Object-methods) (hash-try-get name))])
-    ;; If _this_ class object contains the method, then we return this method
-    ;; This way we always select the correct method in the class hierarchy
-    (if local-method
-        local-method
-        ;; Otherwise, attempt to resolve the method on the parents
-        ;; For now, methods are just a hashmap from name -> method
-        (resolve-parent-method class-object name))))
-
-;; Attempt to resolve the method on the parent class to this class objects
-(define/contract (get-super-method class-object name)
-  (->/c Class-Object? symbol? function?)
-  (resolve-parent-method class-object name))
-
-(define/contract (position? lst value)
-  (->/c list? any/c integer?)
-  (define list-length (length lst))
-  (define (loop lst idx)
-    (cond
-      [(= idx list-length)
-       =>
-       (error! "Value not a member of the list")]
-      [(equal? value (list-ref lst idx))
-       =>
-       idx]
-      [else
-       =>
-       (loop lst (+ idx 1))]))
-  (loop lst 0))
-
-;; Map the given field name to an index in the class' slot
-(define/contract (%get-slot-idx class-object field-name)
-  (->/c Class-Object? symbol? integer?)
-  (-> class-object (Class-Object-fields) (position? field-name)))
-
-;; This returns whatever value is found in the slot
-;; This _could_ be any value. TODO: find a way to bind a contract to a slot
-(define/contract (get-slot class-instance field-name)
-  (->/c Class-Instance? symbol? any/c)
-  (mut-vector-ref (Class-Instance-fields class-instance)
-                  (%get-slot-idx (Class-Instance-class-object class-instance) field-name)))
-
-;; Sets the slot in the class instance found a `field-name` to `value`
-;; TODO: make the contract be dependent to have the result match the value's contract
-(define/contract (set-slot! class-instance field-name value)
-  (->/c Class-Instance? symbol? any/c any/c)
-  (vector-set! (Class-Instance-fields class-instance)
-               ;; Get the slot index -> maps the field name to the index in the vector
-               (%get-slot-idx (Class-Instance-class-object class-instance) field-name)
-               value))
-
-;; Instances should be represented in memory (for now) just as tagged vectors
-;; Each of the fields will be zero'd out
-(define/contract (%allocate-instance class-object)
-  (->/c Class-Object? Class-Instance?)
-  ;; We can just use a normal vector here, not a mutable vector
-  ;; Reference to the class object here
-  (Class-Instance class-object
-                  ;; Fields as a mutable vector
-                  ;; Name resolution should be done via %get-slot method
-                  (apply mutable-vector (map (lambda (x) void) (Class-Object-fields class-object)))))
-
-;; Get the method on the class object denoted by the method name
-;; and call it given the arguments here
-;; TODO: figure out contracts for multi arity functions
-(define (call class-instance method-name . args)
-  (apply (get-method (Class-Instance-class-object class-instance) method-name)
-         ;; The instance is always an implicit first argument, and as such gets
-         ;; cons onto the first of the arguments to call the function
-         (cons class-instance args)))
-
-;; Same as above, calls the method on the nearest parent object
-(define (call-super class-instance method-name . args)
-  (apply (get-super-method (Class-Instance-class-object class-instance) method-name)
-         (cons class-instance args)))
-
-(define/contract (class-instance-name class-instance)
-  (->/c Class-Instance? symbol?)
-  (Class-Object-name (Class-Instance-class-object class-instance)))
-
-;; TODO -> check if object implements interface
-;; (define/contract (class-implements-Interface? class-instance interface)
-;;   (->/c Class-Object? Interface? boolean?)
-;;   (member? interface
-;;
-
-;; ------------------- Examples --------------------------
-
-;; Base object for everything in the class hierarchy
-(define Object
-  (Class 'Object
-         '()
-         '()
-         '()
-         (hash 'println
-               (lambda (self)
-                 (displayln (-> "#<"
-                                (string-append (symbol->string (class-instance-name self)))
-                                (string-append ">")))))))
-
-;; Define the class object for Animal
-;; Is a child of the Object base class
-(define Animal
-  (Class 'Animal
-         (list Object)
-         '()
-         '(name color weight)
-         (hash 'get-weight (lambda (self) (get-slot self 'weight)))))
-
-;; Dog inherits from Animal, adds on the 'good-boy? field
-(define Dog (Class 'Dog (list Animal) '() '(good-boy?) (hash)))
-
-;; TODO: Once keyword arguments are a thing, classes could be defined like so:
-;; (define Dog (Class #:name 'Dog
-;;                    #:parents (list Animal)
-;;                    #:interfaces '()
-;;                    #:fields '(good-boy?)
-;;                    #:methods (hash)))
-
-;; Allocates a new instance of a dog - here all of the fields are default to #<void>
-(define sherman (%allocate-instance Dog))
-;; Set the weight to be 25 -> this is set in the instance, and all fields are flattened on construction
-(set-slot! sherman 'weight 25)
-;; This will traverse upwards on the methods to find the method
-(call sherman 'println)
-;; This should find the method on the parent class
-(call sherman 'get-weight)
-;; Explicitly call the method on the super
-(call-super sherman 'get-weight)
-;; Setting a slot since the default allocation of the instance sets everything to void
-(set-slot! sherman 'good-boy? #true)
-
-(define Stinky (Interface 'Stinky '(smelly icky)))
-
-(define Worm
-  (Class 'Worm
-         (list Dog)
-         (list Stinky)
-         '()
-         (hash 'smelly (lambda (self) "Smelly!") 'icky (lambda (self) "Icky!"))))
-
-(define New-Worm
-  (Make-Class 'Worm
-              #:parents (list Dog)
-              #:interfaces (list Stinky)
-              #:methods (hash 'smelly (lambda (self) "Smelly!") 'icky (lambda (self) "Icky!"))))
diff --git a/cogs/clos/cog.scm b/cogs/clos/cog.scm
deleted file mode 100644
index e4b785e5c..000000000
--- a/cogs/clos/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/clos)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/collections/cog.scm b/cogs/collections/cog.scm
deleted file mode 100644
index 73aa112b9..000000000
--- a/cogs/collections/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/collections)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '(steel/test))
\ No newline at end of file
diff --git a/cogs/collections/dll.scm b/cogs/collections/dll.scm
deleted file mode 100644
index 9b9e46003..000000000
--- a/cogs/collections/dll.scm
+++ /dev/null
@@ -1,72 +0,0 @@
-(provide dllist
-         dllink
-         insert-between
-         insert-before
-         insert-after
-         insert-head
-         insert-tail
-         remove-link
-         dllist-elements
-         dllist-head
-         dllist-tail
-         dllink-content
-         dllink-prev
-         dllink-next)
-
-(struct dllist (head tail) #:mutable #:transparent)
-(struct dllink (content prev next) #:mutable #:transparent)
-
-(define (insert-between dlist before after data)
-  ; Insert a fresh link containing DATA after existing link
-  ; BEFORE if not nil and before existing link AFTER if not nil
-  (define new-link (dllink data before after))
-  (if before (set-dllink-next! before new-link) (set-dllist-head! dlist new-link))
-  (if after (set-dllink-prev! after new-link) (set-dllist-tail! dlist new-link))
-  new-link)
-
-(define (insert-before dlist dlink data)
-  ; Insert a fresh link containing DATA before existing link DLINK
-  (insert-between dlist (dllink-prev dlink) dlink data))
-
-(define (insert-after dlist dlink data)
-  ; Insert a fresh link containing DATA after existing link DLINK
-  (insert-between dlist dlink (dllink-next dlink) data))
-
-(define (insert-head dlist data)
-  ; Insert a fresh link containing DATA at the head of DLIST
-  (insert-between dlist #f (dllist-head dlist) data))
-
-(define (insert-tail dlist data)
-  ; Insert a fresh link containing DATA at the tail of DLIST
-  (insert-between dlist (dllist-tail dlist) #f data))
-
-(define (remove-link dlist dlink)
-  ; Remove link DLINK from DLIST and return its content
-  (let ([before (dllink-prev dlink)] [after (dllink-next dlink)])
-    (if before (set-dllink-next! before after) (set-dllist-head! dlist after))
-    (if after (set-dllink-prev! after before) (set-dllist-tail! dlist before))))
-
-(define (dllist-elements dlist)
-  ; Returns the elements of DLIST as a list
-  (define (extract-values dlink acc)
-    (if dlink (extract-values (dllink-next dlink) (cons (dllink-content dlink) acc)) acc))
-  (reverse (extract-values (dllist-head dlist) '())))
-
-(define (run)
-  (let ([dlist (dllist #f #f)])
-    (insert-head dlist 1)
-    (displayln dlist)
-    (insert-tail dlist 4)
-    (displayln dlist)
-    (insert-after dlist (dllist-head dlist) 2)
-    (displayln dlist)
-    (let* ([next-to-last (insert-before dlist (dllist-tail dlist) 3)]
-           [bad-link (insert-before dlist next-to-last 42)])
-      (remove-link dlist bad-link))
-    (displayln dlist)
-    (displayln (dllist-elements dlist))
-    (displayln dlist)))
-
-(define (loop)
-  (run)
-  (loop))
diff --git a/cogs/collections/iterators.scm b/cogs/collections/iterators.scm
deleted file mode 100644
index 4224ec690..000000000
--- a/cogs/collections/iterators.scm
+++ /dev/null
@@ -1,33 +0,0 @@
-(struct StreamIterator
-        (iter-instance stream-empty-function stream-first-function stream-next-function))
-
-(struct IntoIterator (iter-object next-function) #:prop:procedure 1)
-
-;; Use the builtin "iterator finished" symbol
-(define ITERATOR-FINISHED (load-from-module! %-builtin-module-steel/meta '#%iterator-finished))
-
-(define (iter-finished? value)
-  (eq? value ITERATOR-FINISHED))
-
-(define (iter-next into-iterator)
-  (into-iterator (IntoIterator-iter-object into-iterator)))
-
-;; Generically get the iterator
-(define (into-iter obj)
-  ;; Check if this is a builtin type - if so, delegate to the underlying iterator
-  (define maybe-builtin-iterator (value->iterator obj))
-
-  (if maybe-builtin-iterator
-      (IntoIterator maybe-builtin-iterator iter-next!)
-      ((#%struct-property-ref obj '#:prop:into-iter) obj)))
-
-;; Call value for each thing
-(define (iter-for-each iter func)
-
-  (define next-value (iter-next iter))
-
-  (if (iter-finished? next-value)
-      void
-      (begin
-        (func next-value)
-        (iter-for-each iter func))))
diff --git a/cogs/collections/mhash.scm b/cogs/collections/mhash.scm
deleted file mode 100644
index 0b92f2aa1..000000000
--- a/cogs/collections/mhash.scm
+++ /dev/null
@@ -1,22 +0,0 @@
-(require-builtin #%private/steel/mhash as private.)
-
-(struct mutable-hash (inner) #:mutable)
-
-(define (mhash-set! mhash key value)
-  (private.mhash-set! (mutable-hash-inner mhash) key value))
-
-(define (mhash-ref mhash key)
-  (private.mhash-ref (mutable-hash-inner mhash) key))
-
-(define (mhash)
-  (mutable-hash (private.mhash)))
-
-(define (loop)
-  (define my-hash (mhash))
-
-  (mhash-set! my-hash 'foo 'bar)
-  (mhash-set! my-hash 'bar 'foo)
-
-  (mhash-set! my-hash 'baz my-hash)
-
-  (loop))
diff --git a/cogs/collections/mpair.scm b/cogs/collections/mpair.scm
deleted file mode 100644
index 8b4208e8a..000000000
--- a/cogs/collections/mpair.scm
+++ /dev/null
@@ -1,83 +0,0 @@
-;; Compatible layer for R7RS Mutable pairs.
-
-(struct mcons (mcar mcdr)
-  #:mutable
-  #:printer (lambda (obj printer)
-              (if (mlist? obj)
-
-                  (begin
-                    (simple-display "'")
-                    (printer (mcons->list obj)))
-
-                  (begin
-                    (simple-display "'(")
-                    (printer (mcons-mcar obj))
-                    (simple-display " . ")
-                    (printer (mcons-mcdr obj))
-                    (simple-display ")")))))
-
-(define set-car! set-mcons-mcar!)
-(define set-cdr! set-mcons-mcdr!)
-
-;; Mutable cons!
-(define (mcons->list mutable-cons)
-
-  (define (loop mutable-cons builder)
-
-    (if (not (mcons? (dbg! (mcons-mcdr mutable-cons))))
-
-        (#%prim.cons (mcons-mcar mutable-cons) builder)
-
-        (loop (mcons-mcdr mutable-cons) (#%prim.cons (mcons-mcar mutable-cons) builder))))
-
-  (reverse (loop mutable-cons '())))
-
-(define (mlist? cell)
-  (define next (mcons-mcdr cell))
-
-  (or (mcons? next) (null? next)))
-
-(define (pair? x)
-  (or (mcons? x) (#%prim.pair? x)))
-
-(define (cons a b #:mutable [mutable #false])
-  (cond
-    [mutable (mcons a b)]
-    [(list? b) (#%prim.cons a b)]
-    [(mcons? b) (mcons a b)]
-    [else (#%prim.cons a b)]))
-
-(define (car a)
-  (if (mcons? a) (mcons-mcar a) (#%prim.car a)))
-
-(define (cdr a)
-  (if (mcons? a) (mcons-mcdr a) (#%prim.cdr a)))
-
-; (cons 10 20 #:mutable #true)
-
-;; Can make a loop, and garbage collection solves it!
-; (define (loop)
-
-;   (define my-cons (mcons 10 (mcons 20 (mcons 30 void))))
-
-;   ;; Make a cycle!
-;   (set-car! my-cons my-cons)
-
-;   (loop))
-
-;; TODO: Fix this error - probably just need to not roll back, and when encountering a new value,
-;; just fill the open slot / skip the slot in the global environment / fill it with a poisoned
-;; value.
-;  > :load cogs/collections/mpair.scm
-; => '(10 . 20)
-; λ (cogs/collections/mpair.scm) > (cons 10 20 #:mutable)
-; Unable to locate source and span information for this error: Error: ArityMismatch: Missing keyword argument!
-; λ (cogs/collections/mpair.scm) > (cons 10 20 #:mutable #true)
-; => '(10 . 20)
-; λ (cogs/collections/mpair.scm) > (define my-pair (cons 10 20 #:mutable))
-; Unable to locate source and span information for this error: Error: ArityMismatch: Missing keyword argument!
-; λ (cogs/collections/mpair.scm) > (define my-pair (cons 10 20 #:mutable #true))
-; thread 'main' panicked at 'assertion failed: `(left == right)`
-;   left: `999`,
-;  right: `1000`', crates/steel-core/src/env.rs:59:13
-; note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
diff --git a/cogs/collections/tests.scm b/cogs/collections/tests.scm
deleted file mode 100644
index dee70d2e6..000000000
--- a/cogs/collections/tests.scm
+++ /dev/null
@@ -1,72 +0,0 @@
-(require "dll.scm")
-(require "steel/tests/unit-test.scm"
-         (for-syntax "steel/tests/unit-test.scm"))
-
-(define __dll-module 'dll-module)
-
-(provide __dll-module)
-
-(define (run)
-  (let ([dlist (dllist #f #f)])
-    (insert-head dlist 1)
-    (displayln dlist)
-    (insert-tail dlist 4)
-    (displayln dlist)
-    (insert-after dlist (dllist-head dlist) 2)
-    (displayln dlist)
-    (let* ([next-to-last (insert-before dlist (dllist-tail dlist) 3)]
-           [bad-link (insert-before dlist next-to-last 42)])
-      (remove-link dlist bad-link))
-    (displayln dlist)
-    (displayln (dllist-elements dlist))
-    (displayln dlist)))
-
-(test-module "dll-tests"
-             (check-equal? "creating dll with cycle works"
-                           #true
-                           (begin
-                             (run)
-                             #true)))
-
-;; Testing deep collections
-(struct ConsCell (car cdr) #:mutable #:transparent)
-
-(define (build-list x)
-  (cond
-    [(equal? x 100000) void]
-    [else (ConsCell x (build-list (+ x 1)))]))
-
-(define (build-nested-list x y)
-  (cond
-    [(equal? x y) void]
-    [else (ConsCell x (build-nested-list (+ x 1) y))]))
-
-(define (build-hashmap-chain x)
-  (if (equal? x 100000) (hash 'a x) (hash 'a (build-hashmap-chain (+ x 1)))))
-
-(define (build-list-chain x)
-  (if (equal? x 10000) (list x) (list x (build-list-chain (+ x 1)))))
-
-; (define (test-depth)
-
-;   (define (build-deep-hash x)
-;     (if (equal? x 100000) (hash x x) (hash (build-deep-hash (+ x 1)) x)))
-
-;   (define m (build-deep-hash 0))
-;   (define o (build-deep-hash 0))
-
-;   (equal? m o))
-
-(test-module "deep recursive data structures"
-             ; (check-equal? "deep hash structures" #true (test-depth))
-             (check-equal? "dropping deep list doesn't panic"
-                           #true
-                           (let ([foo (build-nested-list 0 100000)]) #true))
-             (check-equal? "dropping deep built in list doesn't panic"
-                           #true
-                           (let ([foo (build-list-chain 0)])
-
-                             #true))
-             (check-equal? "dropping deep hashmap chain does't panic"
-                           #true
-                           (let ([foo (build-hashmap-chain 0)]) #true)))
diff --git a/cogs/colors/cog.scm b/cogs/colors/cog.scm
deleted file mode 100644
index a4690e92f..000000000
--- a/cogs/colors/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/colors)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
diff --git a/cogs/colors/colors.scm b/cogs/colors/colors.scm
deleted file mode 100644
index 34ff79ba3..000000000
--- a/cogs/colors/colors.scm
+++ /dev/null
@@ -1,49 +0,0 @@
-(require "srfi/srfi-28/format.scm")
-
-(provide display-color
-         displayln-color)
-
-(define (terminal-command command)
-  (format "~a~a" #\u001B command))
-
-(define (terminal-reset)
-  (terminal-command "[0m"))
-
-(define (terminal-colors bg fg bold? underline?)
-  (terminal-command (format "[~a;~a~a~am"
-                            (case bg
-                              [(black) "40"]
-                              [(red) "41"]
-                              [(green) "42"]
-                              [(yellow) "43"]
-                              [(blue) "44"]
-                              [(magenta) "45"]
-                              [(cyan) "46"]
-                              [(white) "47"]
-                              [(default) "49"])
-                            (case fg
-                              [(black) "30"]
-                              [(red) "31"]
-                              [(green) "32"]
-                              [(yellow) "33"]
-                              [(blue) "34"]
-                              [(magenta) "35"]
-                              [(cyan) "36"]
-                              [(white) "37"]
-                              [(default) "39"])
-                            (if bold? ";1" "")
-                            (if underline? ";4" ""))))
-
-(define (output-color output-method datum #:fg fg #:bg bg)
-  (terminal-colors bg fg #f #f)
-  (output-method datum)
-  (display (terminal-reset)))
-
-(define (display-color datum #:fg [fg 'default] #:bg [bg 'default])
-  (output-color display datum #:fg fg #:bg bg))
-
-(define (displayln-color datum #:fg [fg 'default] #:bg [bg 'default])
-  (display (terminal-colors bg fg #f #f))
-  (display datum)
-  (display (terminal-reset))
-  (newline))
diff --git a/cogs/command-line/args.scm b/cogs/command-line/args.scm
deleted file mode 100644
index 12ea233a0..000000000
--- a/cogs/command-line/args.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-
-;; Basic command line parsing into a hashmap, until I figure out how to
-;; dynamically deconstruct the arg list into a struct
-(define (parse-args arg-list)
-    (error "todo!"))
\ No newline at end of file
diff --git a/cogs/command-line/cog.scm b/cogs/command-line/cog.scm
deleted file mode 100644
index 4adf6089e..000000000
--- a/cogs/command-line/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/command-line)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/contract-checker/check.scm b/cogs/contract-checker/check.scm
deleted file mode 100644
index fa2ddd367..000000000
--- a/cogs/contract-checker/check.scm
+++ /dev/null
@@ -1 +0,0 @@
-; ()
\ No newline at end of file
diff --git a/cogs/contracts/cog.scm b/cogs/contracts/cog.scm
deleted file mode 100644
index f66256f77..000000000
--- a/cogs/contracts/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/contracts)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '(steel/test))
\ No newline at end of file
diff --git a/cogs/contracts/contract-test.scm b/cogs/contracts/contract-test.scm
deleted file mode 100644
index 5cc6aa219..000000000
--- a/cogs/contracts/contract-test.scm
+++ /dev/null
@@ -1,46 +0,0 @@
-(require "steel/tests/unit-test.scm"
-         (for-syntax "steel/tests/unit-test.scm"))
-
-(provide foo)
-
-(define/contract (foo x y)
-  (->/c even? odd? odd?)
-  (+ x y))
-
-(define/contract (simple-higher-order x func)
-  (->/c odd? (->/c odd? even?) even?)
-  (func x))
-
-(define (any? x)
-  (displayln "***** CHECKING ANY? *****")
-  #true)
-
-(define (int-checker? x)
-  (displayln "***** CHECKING INT? ******")
-  (int? x))
-(define (number-checker? x)
-  (displayln "***** CHECKING NUMBER? ******")
-  (number? x))
-
-(define level1
-  (bind/c (make-function/c (make-function/c (FlatContract number-checker? 'number-checker?)))
-          (lambda ()
-            (lambda ()
-              (displayln "@@@@@@@@@@ CALLING FUNCTION @@@@@@@@@@@")
-              10))
-          'level1))
-
-(define level2
-  (bind/c (make-function/c (make-function/c (FlatContract int-checker? 'int-checker)))
-          (lambda () (level1))
-          'level2))
-
-(define level3
-  (bind/c (make-function/c (make-function/c (FlatContract any? 'any?))) (lambda () (level2)) 'level3))
-
-(test-module
- "check-basic-contract-checking"
- (check-equal? "basic contract" (foo 10 21) 31)
- (check-err? "Should raise a contract violation" (foo 11 10) 21)
- (check-equal? "higher order contract works" (simple-higher-order 11 (lambda (x) (+ x 1))) 12)
- (check-equal? "Multiple levels of contracts apply" ((level3)) 10))
diff --git a/cogs/contracts/contract.scm b/cogs/contracts/contract.scm
deleted file mode 100644
index 84d1c4f0c..000000000
--- a/cogs/contracts/contract.scm
+++ /dev/null
@@ -1,415 +0,0 @@
-(provide make-function-contract
-         make-contract
-         bind-contract-to-function
-         FlatContract
-         FlatContract?
-         FlatContract-predicate
-         FlatContract-name
-         FunctionContract
-         FunctionContract?
-         FunctionContract-pre-conditions
-         FunctionContract-post-condition
-         contract->string
-         (for-syntax ->c)
-         (for-syntax define/c))
-
-;; struct definitions
-(struct FlatContract (predicate name) #:prop:procedure 0)
-;; Contract Attachment - use this for understanding where something happened
-(struct ContractAttachmentLocation (type name))
-
-;; Function Contract - keep track of preconditions and post conditions, where
-;; the contract was attached, and a pointer to the parent contract. Can probably
-;; replace parent with just a list of the parents since it can be shared
-;; directly
-(struct FunctionContract (pre-conditions post-condition contract-attachment-location parents))
-
-(struct DependentPair (argument-name arguments thunk thunk-name))
-
-(struct DependentContract
-        (arg-positions pre-conditions post-condition contract-attachment-location parent))
-
-;; TODO: Raise error with contract violation directly attached, if possible
-;;
-(struct ContractViolation (error-message))
-
-(struct ContractedFunction (contract function name))
-
-;; Alias the name for clarity
-(define make-flat-contract FlatContract)
-
-;;#|
-;;   Testing out a multi line comment...
-;; |#
-(define (new-FunctionContract #:pre-conditions pre-conditions
-                              #:post-condition post-condition
-                              #:contract-attachment-location (contract-attachment-location void)
-                              ;; TODO: so this parents business isn't even practical
-                              ;; -> it can get removed safely, maybe revisited later
-                              #:parents (parents '()))
-  (FunctionContract pre-conditions post-condition contract-attachment-location parents))
-
-;; Formats a contract nicely as a string
-(define (contract->string contract)
-  (cond
-    [(FlatContract? contract)
-     =>
-     (symbol->string (FlatContract-name contract))]
-    [(FunctionContract? contract)
-     =>
-     (to-string "(->"
-                (apply to-string
-                       (transduce (FunctionContract-pre-conditions contract)
-                                  (mapping contract->string)
-                                  (into-list)))
-                (contract->string (FunctionContract-post-condition contract))
-                ")")]
-    [else
-     =>
-     (error! "Unexpected value found in contract:" contract)]))
-
-;; Given a list, splits off the last argument, returns as a pair
-(define (split-last lst)
-  (define (loop accum lst)
-    (if (empty? (cdr lst)) (list (reverse accum) (car lst)) (loop (cons (car lst) accum) (cdr lst))))
-  (loop '() lst))
-
-;;@doc
-;; Creates a `FunctionContract` from the list of conditions, splitting out the
-;; preconditions and the postconditions
-(define make-function-contract
-  (lambda conditions
-    (%plain-let ((split (split-last conditions)))
-                (FunctionContract (first split) (second split) void '()))))
-
-;; Applies a flat contract to the given argument
-(define (apply-flat-contract flat-contract arg)
-  ; ((FlatContract-predicate flat-contract) arg)
-  (if (flat-contract arg)
-      #true
-      (ContractViolation
-       (to-string "Contract violation: found in the application of a flat contract for"
-                  (FlatContract-name flat-contract)
-                  ": the given input:"
-                  arg
-                  "resulted in a contract violation"))))
-
-;; ; (define (apply-parents parent name function arguments span)
-;; ;   (if (void? parent)
-;; ;       #true
-;; ;       (begin
-;; ;         (displayln "Applying parent contract")
-;; ;         (apply-function-contract (ContractedFunction-contract parent)
-;; ;                                  name
-;; ;                                  function
-;; ;                                  arguments
-;; ;                                  span)
-
-;; ;         (apply-parents (FunctionContract-parent parent) name function arguments span))))
-
-;; Call a contracted function
-(define (apply-contracted-function contracted-function arguments span)
-  ; (displayln "Passed in span: " span)
-  (define span (if span span '(0 0 0)))
-  (apply-function-contract (ContractedFunction-contract contracted-function)
-                           (ContractedFunction-name contracted-function)
-                           (ContractedFunction-function contracted-function)
-                           arguments
-                           span))
-
-;;@doc
-;; Verifies the arguments against the FunctionContract, and then produces
-;; a new list of arguments, with any arguments wrapped in function contracts if they happen
-;; to be higher order
-(define (verify-preconditions self-contract arguments name span)
-  (unless (equal? (length arguments) (length (FunctionContract-pre-conditions self-contract)))
-    (error-with-span span
-                     "Arity mismatch, function expected "
-                     (length (FunctionContract-pre-conditions self-contract))
-                     "Found: "
-                     (length arguments)))
-
-  (transduce
-   arguments
-   (zipping (FunctionContract-pre-conditions self-contract))
-   (enumerating)
-   (mapping
-    (lambda (x)
-      (let ([i (first x)] [arg (first (second x))] [contract (second (second x))])
-
-        (cond
-          [(FlatContract? contract)
-           =>
-
-           (let ([result (apply-flat-contract contract arg)])
-             (if (ContractViolation? result)
-                 (error-with-span span
-                                  "This function call caused an error"
-                                  "- it occured in the domain position:"
-                                  i
-                                  ", with the contract: "
-                                  (contract->string contract)
-                                  (ContractViolation-error-message result)
-                                  ", blaming "
-                                  (ContractAttachmentLocation-name
-                                   (FunctionContract-contract-attachment-location self-contract))
-                                  "(callsite)")
-                 arg))]
-          [(FunctionContract? contract)
-           =>
-           (if (ContractedFunction? arg)
-               (let ([pre-parent (ContractedFunction-contract arg)])
-                 (let ([parent (new-FunctionContract
-                                #:pre-conditions (FunctionContract-pre-conditions pre-parent)
-                                #:post-condition (FunctionContract-post-condition pre-parent)
-                                #:contract-attachment-location
-                                (ContractAttachmentLocation 'DOMAIN (ContractedFunction-name arg))
-                                #:parents (FunctionContract-parents pre-parent))])
-                   (let ([fc (new-FunctionContract
-                              #:pre-conditions (FunctionContract-pre-conditions contract)
-                              #:post-condition (FunctionContract-post-condition contract)
-                              #:contract-attachment-location
-                              (ContractAttachmentLocation 'DOMAIN (ContractedFunction-name arg))
-                              #:parents (cons parent (FunctionContract-parents parent)))])
-
-                     (bind-contract-to-function fc arg name span))))
-               (bind-contract-to-function contract arg name span))]
-          [else
-           =>
-           (error! "Unexpected value in pre conditions: " contract)]))))
-   (into-list)))
-
-(define (apply-function-contract contract name function arguments span)
-  ;; Check that each of the arguments abides by the
-  (let ([validated-arguments (verify-preconditions contract arguments name span)])
-
-    (let ([output (with-handler (lambda (err) (raise-error err))
-                                (apply function validated-arguments))]
-
-          [self-contract contract]
-          [self-contract-attachment-location (FunctionContract-contract-attachment-location contract)]
-          [contract (FunctionContract-post-condition contract)])
-
-      (cond
-        [(FlatContract? contract)
-         =>
-
-         (let ([result (apply-flat-contract contract output)])
-           (if (ContractViolation? result)
-               (let ([blame-location (if (void? self-contract-attachment-location)
-                                         name
-                                         self-contract-attachment-location)])
-
-                 (cond
-                   [(void? blame-location)
-                    =>
-                    (error-with-span
-                     span
-                     "this function call resulted in an error - occured in the range position of this contract: "
-                     (contract->string self-contract)
-                     (ContractViolation-error-message result)
-                     "blaming: None - broke its own contract")]
-
-                   [else
-                    =>
-                    (error-with-span
-                     span
-                     "this function call resulted in an error - occurred in the range position of this contract: "
-                     (contract->string self-contract)
-                     (ContractViolation-error-message result)
-                     "blaming: "
-                     blame-location)]))
-
-               output))]
-        [(FunctionContract? contract)
-         =>
-
-         (define original-function output)
-
-         (if (FunctionContract? (get-contract-struct output))
-
-             ;; TODO: Come back to this and understand what the heck its doing
-             ;; Figured it out -> its never actually a contracted function, because we're wrapping
-             ;; it directly in a normal function type.
-             (begin
-               (define output (get-contract-struct output))
-               (define pre-parent contract)
-               (define contract-attachment-location
-                 (ContractAttachmentLocation 'RANGE
-                                             (ContractAttachmentLocation-name
-                                              self-contract-attachment-location)))
-               (define parent
-                 (new-FunctionContract #:pre-conditions (FunctionContract-pre-conditions pre-parent)
-                                       #:post-condition (FunctionContract-post-condition pre-parent)
-                                       #:contract-attachment-location contract-attachment-location
-                                       #:parents (FunctionContract-parents pre-parent)))
-               (define fc
-                 (new-FunctionContract #:pre-conditions (FunctionContract-pre-conditions contract)
-                                       #:post-condition (FunctionContract-post-condition contract)
-                                       #:contract-attachment-location contract-attachment-location
-                                       #:parents (cons parent (FunctionContract-parents pre-parent))))
-
-               (bind-contract-to-function fc original-function name span))
-             (bind-contract-to-function contract output name span))]
-        [else
-         =>
-         (error! "Unhandled value in post condition: " contract)]))))
-
-(define (bind-contract-to-function contract function name . span)
-  (define post-condition (FunctionContract-post-condition contract))
-
-  (let ([updated-preconditions
-         (transduce
-          (FunctionContract-pre-conditions contract)
-          (mapping (lambda (c)
-                     (cond
-                       [(FlatContract? c)
-                        =>
-                        c]
-                       [(FunctionContract? c)
-                        =>
-                        (FunctionContract (FunctionContract-pre-conditions c)
-                                          (FunctionContract-post-condition c)
-                                          (ContractAttachmentLocation 'DOMAIN name)
-                                          (FunctionContract-parents c))]
-                       [else
-                        =>
-                        (error "Unexpected value found in bind-contract-to-function preconditions: "
-                               c)])))
-          (into-list))]
-
-        [updated-postcondition
-         (cond
-           [(FlatContract? post-condition)
-            =>
-            post-condition]
-           [(FunctionContract? post-condition)
-            =>
-
-            (FunctionContract (FunctionContract-pre-conditions post-condition)
-                              (FunctionContract-post-condition post-condition)
-                              (ContractAttachmentLocation 'RANGE name)
-                              (FunctionContract-parents post-condition))]
-           [else
-            =>
-
-            (error "Unexpected value found in bind-contract-to-function post condition: "
-                   post-condition)])])
-
-    (let ([contracted-function
-           (ContractedFunction (FunctionContract updated-preconditions
-                                                 updated-postcondition
-                                                 ;  void
-                                                 ;  (ContractAttachmentLocation 'TOPLEVEL name)
-                                                 ;  void
-                                                 (ContractAttachmentLocation 'TOPLEVEL name)
-                                                 (if (get-contract-struct function)
-                                                     (cons (get-contract-struct function)
-                                                           (FunctionContract-parents contract))
-                                                     (FunctionContract-parents contract)))
-                               function
-                               name)])
-
-      (let ([resulting-lambda-function
-             (lambda args
-
-               (apply-contracted-function
-                contracted-function
-                args
-                ; span
-                ; (current-function-span)
-                (if span (car span) (current-function-span))
-                ;          (begin (displayln ("Current span: " (current-function-span)))
-                ;          (current-function-span)))
-                ))])
-        (attach-contract-struct! resulting-lambda-function
-                                 (ContractedFunction-contract contracted-function))
-        resulting-lambda-function))))
-
-(define (make-contract contract name)
-  (cond
-    [(FlatContract? contract) contract]
-    [(FunctionContract? contract) contract]
-    [else
-     =>
-     (FlatContract contract name)]))
-
-(define-syntax ->c
-  (syntax-rules ()
-    [(->c r) (make-function-contract (make-contract r 'r))]
-    [(->c a b) (make-function-contract (make-contract a 'a) (make-contract b 'b))]
-    [(->c a b c)
-     (make-function-contract (make-contract a 'a) (make-contract b 'b) (make-contract c 'c))]
-    [(->c a b c d)
-     (make-function-contract (make-contract a 'a)
-                             (make-contract b 'b)
-                             (make-contract c 'c)
-                             (make-contract d 'd))]
-    [(->c a b c d e)
-     (make-function-contract (make-contract a 'a)
-                             (make-contract b 'b)
-                             (make-contract c 'c)
-                             (make-contract d 'd)
-                             (make-contract e 'e))]
-    [(->c a b c d e f)
-     (make-function-contract (make-contract a 'a)
-                             (make-contract b 'b)
-                             (make-contract c 'c)
-                             (make-contract d 'd)
-                             (make-contract e 'e)
-                             (make-contract f 'f))]
-    [(->c a b c d e f g)
-     (make-function-contract (make-contract a 'a)
-                             (make-contract b 'b)
-                             (make-contract c 'c)
-                             (make-contract d 'd)
-                             (make-contract e 'e)
-                             (make-contract f 'f)
-                             (make-contract g 'g))]
-    [(->c a b c d e f g h)
-     (make-function-contract (make-contract a 'a)
-                             (make-contract b 'b)
-                             (make-contract c 'c)
-                             (make-contract d 'd)
-                             (make-contract e 'e)
-                             (make-contract f 'f)
-                             (make-contract g 'g)
-                             (make-contract h 'h))]
-    [(->c a b c d e f g h i)
-     (make-function-contract (make-contract a 'a)
-                             (make-contract b 'b)
-                             (make-contract c 'c)
-                             (make-contract d 'd)
-                             (make-contract e 'e)
-                             (make-contract f 'f)
-                             (make-contract g 'g)
-                             (make-contract h 'h)
-                             (make-contract i 'i))]))
-
-;; Macro for basic usage of contracts
-(define-syntax define/c
-  (syntax-rules ()
-    [(define/c (name args ...)
-       contract
-       body ...)
-     (begin
-       (define name
-         (lambda (args ...)
-           body ...))
-       (set! name (bind-contract-to-function contract name 'name))
-       void)
-     ;  (define name (bind/c contract (lambda (args ...) body ...) 'name))
-     ]
-    [(define/c name
-       contract
-       expr)
-     (define name
-       ((bind-contract-to-function (make-function-contract (make-contract contract 'contract))
-                                   (lambda () expr))))]))
-
-(provide (for-syntax contract/out/test))
-
-(define-syntax contract/out/test
-  (syntax-rules ()
-    [(contract/out/test name contract)
-     (%require-ident-spec name (bind-contract-to-function contract name 'name))]))
diff --git a/cogs/contracts/types.scm b/cogs/contracts/types.scm
deleted file mode 100644
index c6629a6a9..000000000
--- a/cogs/contracts/types.scm
+++ /dev/null
@@ -1,111 +0,0 @@
-(require "contract.scm"
-         (for-syntax "contract.scm"))
-
-(provide contract?
-         listof
-         hashof
-         non-empty-listof
-         </c
-         >/c
-         <=/c
-         >=/c
-         any/c
-         and/c
-         or/c)
-
-(define (loop pred lst)
-  (cond
-    [(null? lst) #t]
-    [(pred (car lst)) (loop pred (cdr lst))]
-    [else #f]))
-
-;; Contract combinators
-(define (listof pred)
-  (make-contract (lambda (lst)
-                   (cond
-                     [(null? lst) #t]
-                     [(list? lst) (loop pred lst)]
-                     [else #f]))
-                 (list 'listof (contract-or-procedure-name pred))))
-
-(define (hashof key-pred value-pred)
-  (make-contract
-   (lambda (hashmap)
-     ;; For hashof - we want to assert that both all of the keys and all of the values abide by
-     ;; a specific predicate
-     (and ((listof key-pred) (hash-keys->list hashmap))
-          ((listof value-pred) (hash-values->list hashmap))))
-   (list 'hashof (contract-or-procedure-name key-pred) (contract-or-procedure-name value-pred))))
-
-(define (contract-or-procedure-name x)
-  (cond
-    [(FlatContract? x) (FlatContract-name x)]
-    [(FunctionContract? x) (string->symbol (contract->string x))]
-    [else
-     (let ([lookup (function-name x)]) (if (string? lookup) (string->symbol lookup) '#<function>))]))
-
-;; Like listof, however requires that the list is non empty as well
-(define (non-empty-listof pred)
-  (make-contract (lambda (lst)
-                   (cond
-                     [(null? lst)
-                      (displayln "getting here?")
-                      #f]
-                     [(list? lst) (loop pred lst)]
-                     [else #f]))
-                 (list 'non-empty-listof (contract-or-procedure-name pred))))
-
-;; Contracts for <
-(define (</c n)
-  (make-contract (fn (x) (< x n)) (list '</c n)))
-
-;; Contracts for >
-(define (>/c n)
-  (make-contract (fn (x) (> x n)) (list '>/c n)))
-
-;; Contracts for <=
-(define (<=/c n)
-  (make-contract (fn (x) (<= x n)) (list '<=/c n)))
-
-;; Contracts for >=
-(define (>=/c n)
-  (make-contract (fn (x) (>= x n)) (list '>=/c n)))
-
-;; Satisfies any single value
-(define (any/c x)
-  (make-contract (fn (x) #t) 'any/c))
-
-;; produces a function compatible with contract definitions
-(define (and/c x y)
-  (make-contract (lambda (z) (and (x z) (y z))) (list 'and/c x y)))
-
-;; produces a function compatible with contract definitions
-(define (or/c x y)
-  (make-contract (lambda (z) (or (x z) (y z))) (list 'or/c x y)))
-
-(define combinators (hashset listof non-empty-listof </c >/c <=/c >=/c any/c and/c or/c))
-
-(define (contract? predicate-or-contract)
-  (cond
-    [(function? predicate-or-contract)
-     (or (equal? (arity? predicate-or-contract) 1)
-         (hashset-contains? combinators predicate-or-contract))]
-    [else
-     =>
-     #f]))
-
-;; TODO: Come back to this - I think I need to be very specific about the then-contract and else-contract
-;; and how they get applied
-; (define (if/c predicate then-contract else-contract)
-;     (make-contract
-;         (lambda (x) (if (predicate x)
-;                         (then-contract predicate)
-;                         (else-contract predicate)))
-;         (list 'if/c then-contract else-contract)))
-
-; (define (type/c type contract)
-;     (and/c
-
-; )
-
-; (define (int/c ))
diff --git a/cogs/coop/cog.scm b/cogs/coop/cog.scm
deleted file mode 100644
index b2fc5d202..000000000
--- a/cogs/coop/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/coop)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/coop/threads.scm b/cogs/coop/threads.scm
deleted file mode 100644
index ca4445b5a..000000000
--- a/cogs/coop/threads.scm
+++ /dev/null
@@ -1,79 +0,0 @@
-; *thread-queue* : list[continuation]
-(define *thread-queue* '())
-
-; halt : continuation
-(define halt #f)
-
-; current-continuation : -> continuation
-(define (current-continuation)
-  (call/cc (lambda (cc) (cc cc))))
-
-; spawn : (-> anything) -> void
-(define (spawn thunk)
-  (let ([cc (current-continuation)])
-    (if (continuation? cc)
-        (set! *thread-queue* (append *thread-queue* (list cc)))
-        (begin
-          (thunk)
-          (quit)))))
-
-; yield : value -> void
-(define (yield)
-  (let ([cc (current-continuation)])
-    (if (and (continuation? cc) (pair? *thread-queue*))
-        (let ([next-thread (car *thread-queue*)])
-          (set! *thread-queue* (append (cdr *thread-queue*) (list cc)))
-          (next-thread 'resume))
-        void)))
-
-; quit : -> ...
-(define (quit)
-  (if (pair? *thread-queue*)
-      (let ([next-thread (car *thread-queue*)])
-        (set! *thread-queue* (cdr *thread-queue*))
-        (next-thread 'resume))
-      (halt)))
-
-; start-threads : -> ...
-(define (start-threads)
-  (let ([cc (current-continuation)])
-    ; (displayln cc)
-    (if cc
-        (begin
-          ; (displayln cc)
-          (set! halt
-                (lambda ()
-                  ; (inspect-bytecode cc)
-                  ; (displayln cc)
-                  (cc #f)))
-          ;   (displayln cc)
-          (if (null? *thread-queue*)
-              void
-              (begin
-                (let ([next-thread (car *thread-queue*)])
-                  (set! *thread-queue* (cdr *thread-queue*))
-                  (next-thread 'resume)))))
-        void)))
-
-;; Example cooperatively threaded program
-(define counter 10)
-
-(define (make-thread-thunk name)
-  (define (loop)
-    (when (< counter 0)
-      (quit))
-    (display "in thread ")
-    (display name)
-    (display "; counter = ")
-    (display counter)
-    (newline)
-    (set! counter (- counter 1))
-    (yield)
-    (loop))
-  loop)
-
-(spawn (make-thread-thunk 'a))
-(spawn (make-thread-thunk 'b))
-(spawn (make-thread-thunk 'c))
-
-(start-threads)
diff --git a/cogs/dispatch.scm b/cogs/dispatch.scm
deleted file mode 100644
index 634b8dbef..000000000
--- a/cogs/dispatch.scm
+++ /dev/null
@@ -1,80 +0,0 @@
-(require "contracts/contract.scm"
-         (for-syntax "contracts/contract.scm")
-         "contracts/types.scm")
-
-(require "logging/log.scm")
-
-; (provide apples)
-
-;;@doc
-;; Apples are a tasty fruit
-(define/c (apples x)
-  (->c even? odd?)
-  (+ x 1))
-
-; (define/c (bananas y)
-;   (->c even? odd?)
-;   (+ y 1))
-
-; (dbg! (apples 10))
-; (dbg! (bananas 10))
-
-; (dbg! (equal? (get-contract-struct apples)
-;               (get-contract-struct bananas)))
-
-; (dbg! (get-contract-struct apples))
-; (dbg! (get-contract-struct bananas))
-
-
-; (define (function-contract-equal? l r)
-;   (and (equal? (FunctionContract-pre-conditions l)
-;                (FunctionContract-pre-conditions r))
-;        (equal? (FunctionContract-post-condition l)
-;                (FunctionContract-post-condition r))))
-
-; (dbg! (function-contract-equal?
-;        (get-contract-struct apples)
-;        (get-contract-struct bananas)))
-
-; (dbg! (->c even? odd?))
-
-
-
-; (define (transform-doc expr comment)
-;   (if (equal? (car expr) 'define)
-;       `(begin 
-;           (define ,(concat-symbols '__doc- (second expr)) comment)
-;           ,expr
-;        )
-;        (displayln "didn't work!")))
-
-
-; (dbg! (transform-doc '(define x 100) "this is the value that is associated with 100"))
-
-
-;;@doc
-;;
-;; Seeing if a comment will show up in the repl.
-;; 
-;; perhaps introduce some markdown:
-;; 
-;; ```scheme
-;; (list 10 20 30 40)
-;; ```
-(define x 100)
-
-;;@doc
-;; Hello world!
-(define y 20)
-
-; (displayln __doc-apples)
-; (displayln __doc-x)
-; (displayln __doc-y)
-
-(define/c (applesauce lst)
-    (->c (listof int?) (listof number?))
-    (map (fn (x) (+ x 0.1)) lst))
-
-;;@doc
-;; A fun little doc
-(struct FooBarBaz (a b c))
\ No newline at end of file
diff --git a/cogs/download.scm b/cogs/download.scm
deleted file mode 100644
index 142ae495f..000000000
--- a/cogs/download.scm
+++ /dev/null
@@ -1,70 +0,0 @@
-;; Download a package from git - These should be stored in a reasonable location, probably under the
-;; $STEEL_HOME directory.
-
-(require-builtin steel/process)
-(require "steel/result")
-
-;; Sources!
-(define (append-with-separator path dir-name)
-  (if (ends-with? path "/") (string-append path dir-name) (string-append path "/" dir-name)))
-
-(define (path-from-steel-home dir)
-  (~> "STEEL_HOME" (env-var) (append-with-separator dir)))
-
-(define *COG_DIR* (path-from-steel-home "cogs"))
-(define *NATIVE_SOURCES_DIR* (path-from-steel-home "sources"))
-
-;; Most likely should use gix here instead of shelling out to git?
-;; Use the sha to pin to a specific commit, if interested
-(define (git-clone package-name https-address installation-dir #:sha (*sha* void))
-  (define resulting-path (string-append installation-dir "/" package-name))
-  ;; Git clone command, run against specific directory. For now we're going to
-  ;; naively install them all into the same spot.
-  (~> (command "git" (list "clone" https-address resulting-path)) (spawn-process) (Ok->value) (wait))
-  ;; If we have a SHA, check out that commit
-  (when (not (void? *sha*))
-    (~> (command "git" (list "checkout" *sha*))
-        (in-directory resulting-path)
-        (spawn-process)
-        (Ok->value)
-        (wait)))
-
-  resulting-path)
-
-;; Run the process in the given directory
-(define (in-directory command directory)
-  (set-current-dir! command directory)
-  command)
-
-;; Run the cargo-steel-lib installer in the target directory
-(define (run-dylib-installation target-directory)
-  (~> (command "cargo-steel-lib" '())
-      (in-directory target-directory)
-      (spawn-process)
-      (Ok->value)
-      (wait)))
-
-;; TODO: steps
-;; - git clone to temporary directory (or site-packages style thing, something)
-;; Probably install native dylibs to their own native section
-;; Then, run the installation script.
-
-;; Install to the im-lists directory. What we probably have to do is install it to some
-;; temporary location, parse the module name, and move it back out. Unless - we do something
-;; like the org name, but I don't love that.
-; (git-clone "im-lists" "https://github.com/mattwparas/im-lists.git" *NATIVE_SOURCES_DIR*)
-
-;; Download and install the library!
-; (define (download-and-install-library library-name git-url)
-;   (~> (git-clone library-name git-url *NATIVE_SOURCES_DIR*)
-;       (run-dylib-installation installation-directory)))
-
-;; TODO: Publish steel in its currently form, extremely experimental.
-;; Once steel is in a stable position, dylibs can reference the dependency by version
-;; on crates.io
-
-;;
-; (git-clone "helix-configuration"
-;            "https://github.com/mattwparas/helix-config.git"
-;            *COG_DIR*
-;            #:sha "ae01ad7a3e7a48dad0ddbe8b812ab162aba31732")
diff --git a/cogs/dump.txt b/cogs/dump.txt
deleted file mode 100644
index aecdfb94e..000000000
--- a/cogs/dump.txt
+++ /dev/null
@@ -1,338 +0,0 @@
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__hash -> #%prim.hash
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__#%vtable-update-entry! -> #%prim.#%vtable-update-entry!
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__void -> #%prim.void
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list-ref -> #%prim.list-ref
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list-ref -> #%prim.list-ref
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list-ref -> #%prim.list-ref
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list-ref -> #%prim.list-ref
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__make-struct-type -> #%prim.make-struct-type
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list -> #%prim.list
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__void -> #%prim.void
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__null? -> #%prim.null?
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list? -> #%prim.list?
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__append -> #%prim.append
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__car -> #%prim.car
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__cdr -> #%prim.cdr
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list -> #%prim.list
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__= -> #%prim.=
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__length -> #%prim.length
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__push-back -> #%prim.push-back
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty? -> #%prim.empty?
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list -> #%prim.list
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__< -> #%prim.<
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__cons -> #%prim.cons
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__equal? -> #%prim.equal?
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__cons -> #%prim.cons
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__rest -> #%prim.rest
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__cons -> #%prim.cons
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__rest -> #%prim.rest
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__push-back -> #%prim.push-back
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty? -> #%prim.empty?
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list -> #%prim.list
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__rest -> #%prim.rest
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__< -> #%prim.<
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__cons -> #%prim.cons
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__rest -> #%prim.rest
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__equal? -> #%prim.equal?
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__cons -> #%prim.cons
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__rest -> #%prim.rest
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__rest -> #%prim.rest
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__cons -> #%prim.cons
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__rest -> #%prim.rest
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__string->list -> #%prim.string->list
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__< -> #%prim.<
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__= -> #%prim.=
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__length -> #%prim.length
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__first -> #%prim.first
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__rest -> #%prim.rest
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__cons -> #%prim.cons
-MUTATED IDENT TO BE: mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__list->string -> #%prim.list->string
-(define ##__lifted_pure_function78793
-  (λ (struct-type-descriptor
-      constructor-proto
-      predicate-proto
-      getter-proto)
-    (begin
-     (set! mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__struct:trie
-            struct-type-descriptor)
-          (#%prim.#%vtable-update-entry!
-             struct-type-descriptor
-             #false
-             mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#_____trie-options___)
-          (set! mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-            constructor-proto)
-          (set! mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie?
-            predicate-proto)
-          (set! mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-            (λ (this)
-              (getter-proto this 0)))
-          (set! mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-children
-            (λ (this)
-              (getter-proto this 1)))
-          (set! mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-end-word?
-            (λ (this)
-              (getter-proto this 2)))
-          (set! mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-word-up-to
-            (λ (this)
-              (getter-proto this 3)))
-          #%prim.void)))
-
-(begin
- (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#_____trie-options___
-        (#%prim.hash
-           (quote
-             #:mutable)
-           #false
-           (quote
-             #:transparent)
-           #false
-           (quote
-             #:fields)
-           (quote
-             (char children end-word? word-up-to))
-           (quote
-             #:printer)
-           #false
-           (quote
-             #:name)
-           (quote
-             trie)))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-        (quote
-          unintialized))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__struct:trie
-        (quote
-          uninitialized))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie?
-        (quote
-          uninitialized))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-        (quote
-          uninitialized))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-children
-        (quote
-          uninitialized))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-end-word?
-        (quote
-          uninitialized))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-word-up-to
-        (quote
-          uninitialized))
-      (let ((prototypes (#%prim.make-struct-type
-             (quote
-               trie)
-             4)))
-        (##__lifted_pure_function78793
-           (#%prim.list-ref prototypes 0)
-           (#%prim.list-ref prototypes 1)
-           (#%prim.list-ref prototypes 2)
-           (#%prim.list-ref prototypes 3)))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty
-        (quote
-          ()))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty-trie
-        (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-           #%prim.void
-           mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty
-           #false
-           mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__flatten
-        (λ (lst)
-          (if (#%prim.null? lst)
-            mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty
-            (if (#%prim.list? lst)
-              (#%prim.append
-                 (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__flatten
-                    (#%prim.car lst))
-                 (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__flatten
-                    (#%prim.cdr lst)))
-              (#%prim.list lst)))))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__create-children
-        (λ (char-list lst prefix-chars)
-          (if (#%prim.= (#%prim.length char-list) 1)
-            (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__handle-last-letter
-               char-list
-               lst
-               prefix-chars)
-            (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__handle-intern-letter
-               char-list
-               lst
-               prefix-chars))))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__handle-last-letter
-        (λ (char-list lst prefix-chars)
-          (let ((char (#%prim.first char-list)))
-            (let ((next-prefix (#%prim.push-back
-                   prefix-chars
-                   char)))
-              (if (#%prim.empty? lst)
-                (#%prim.list
-                   (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-                      char
-                      mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty
-                      #true
-                      next-prefix))
-                (if (#%prim.<
-                     char
-                     (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-                        (#%prim.first lst)))
-                  (#%prim.cons
-                     (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-                        char
-                        mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty
-                        #true
-                        next-prefix)
-                     lst)
-                  (if (#%prim.equal?
-                       char
-                       (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-                          (#%prim.first lst)))
-                    (#%prim.cons
-                       (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-                          char
-                          (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-children
-                             (#%prim.first lst))
-                          #true
-                          next-prefix)
-                       (#%prim.rest lst))
-                    (#%prim.cons
-                       (#%prim.first lst)
-                       (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__create-children
-                          char-list
-                          (#%prim.rest lst)
-                          prefix-chars)))))))))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__handle-intern-letter
-        (λ (char-list lst prefix-chars)
-          (let ((char (#%prim.first char-list)))
-            (let ((next-prefix (#%prim.push-back
-                   prefix-chars
-                   char)))
-              (if (#%prim.empty? lst)
-                (#%prim.list
-                   (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-                      char
-                      (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__create-children
-                         (#%prim.rest char-list)
-                         mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty
-                         next-prefix)
-                      #false
-                      next-prefix))
-                (if (#%prim.<
-                     char
-                     (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-                        (#%prim.first lst)))
-                  (#%prim.cons
-                     (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-                        char
-                        (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__create-children
-                           (#%prim.rest char-list)
-                           mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty
-                           next-prefix)
-                        #false
-                        next-prefix)
-                     lst)
-                  (if (#%prim.equal?
-                       char
-                       (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-                          (#%prim.first lst)))
-                    (#%prim.cons
-                       (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-                          char
-                          (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__create-children
-                             (#%prim.rest char-list)
-                             (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-children
-                                (#%prim.first lst))
-                             next-prefix)
-                          (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-end-word?
-                             (#%prim.first lst))
-                          (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-word-up-to
-                             (#%prim.first lst)))
-                       (#%prim.rest lst))
-                    (#%prim.cons
-                       (#%prim.first lst)
-                       (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__create-children
-                          char-list
-                          (#%prim.rest lst)
-                          prefix-chars)))))))))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__insert
-        (λ (root-trie word)
-          (let ((char-list (#%prim.string->list word)))
-            (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-               (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-                  root-trie)
-               (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__create-children
-                  char-list
-                  (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-children
-                     root-trie)
-                  mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty)
-               (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-end-word?
-                  root-trie)
-               (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-word-up-to
-                  root-trie)))))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie<?
-        (λ (trie-node1 trie-node2)
-          (#%prim.<
-             (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-                trie-node1)
-             (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-char
-                trie-node2))))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__build-trie-from-list-of-words
-        (λ (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-            list-of-words)
-          (if (#%prim.= (#%prim.length list-of-words) 1)
-            (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__insert
-               mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-               (#%prim.first list-of-words))
-            (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__build-trie-from-list-of-words
-               (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__insert
-                  mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie
-                  (#%prim.first list-of-words))
-               (#%prim.rest list-of-words)))))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-sort
-        (λ (list-of-words)
-          (let ((new-trie (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__build-trie-from-list-of-words
-                 mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__empty-trie
-                 list-of-words)))
-            (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__pre-order
-               new-trie))))
-      (define mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__pre-order
-        (λ (trie-node)
-          (if (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-end-word?
-               trie-node)
-            (#%prim.cons
-               (#%prim.list->string
-                  (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-word-up-to
-                     trie-node))
-               (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__flatten
-                  (map
-                     mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__pre-order
-                     (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-children
-                        trie-node))))
-            (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__flatten
-               (map
-                  mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__pre-order
-                  (mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-children
-                     trie-node))))))
-      (define __module-mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__
-        (hash
-           (quote
-             trie-sort)
-           mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__trie-sort)))
-
-(define trie-sort
-  (%proto-hash-get%
-     __module-mangler/home/matt/Documents/steel/cogs/sorting/trie-sort.scm__%#__
-     (quote
-       trie-sort)))
diff --git a/cogs/foo.scm b/cogs/foo.scm
deleted file mode 100644
index aae839562..000000000
--- a/cogs/foo.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-(set-test-mode!)
-
-(require "sorting/tests.scm")
diff --git a/cogs/fs/cog.scm b/cogs/fs/cog.scm
deleted file mode 100644
index 6f27f2b14..000000000
--- a/cogs/fs/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/fs)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/fs/fs.scm b/cogs/fs/fs.scm
deleted file mode 100644
index 8ea2d7690..000000000
--- a/cogs/fs/fs.scm
+++ /dev/null
@@ -1,22 +0,0 @@
-(provide walk-files
-         file->string)
-
-(define (for-each func lst)
-  (if (null? lst)
-      void
-      (begin
-        (func (car lst))
-        (when (null? lst)
-          (return! void))
-        (for-each func (cdr lst)))))
-
-(define (file->string path)
-  (let ([file (open-input-file path)]) (read-port-to-string file)))
-
-;; Walk the file system, applying a function to each file found
-(define/contract (walk-files path func)
-  (->/c string? (->/c string? any/c) any/c)
-  (cond
-    [(is-file? path) (func path)]
-    [(is-dir? path) (for-each (lambda (x) (walk-files x func)) (read-dir path))]
-    [else void]))
diff --git a/cogs/install.scm b/cogs/install.scm
deleted file mode 100644
index db54402f6..000000000
--- a/cogs/install.scm
+++ /dev/null
@@ -1,10 +0,0 @@
-;; TODO:
-;; Parse the arguments from the command line, in this case either grab the path to the directory, or a git url, or the local directory
-;; Parse the cog file, and check the dependencies. If any need to be downloaded, fetch those
-;; Install to $STEEL_HOME/cogs to make it available for anything to download
-;; Version resolution... for now just assume everything is compatible with everything without versions
-;; Storing versions in a manifest would be nice - a project has an associated manifest that pins versions.
-
-(require "installer/package.scm")
-
-(package-installer-main)
diff --git a/cogs/installer/cog.scm b/cogs/installer/cog.scm
deleted file mode 100644
index 2992b06a2..000000000
--- a/cogs/installer/cog.scm
+++ /dev/null
@@ -1,4 +0,0 @@
-(define package-name 'installer)
-(define version "0.1.0")
-
-(define dependencies '())
diff --git a/cogs/installer/package.scm b/cogs/installer/package.scm
deleted file mode 100644
index 81f177ec2..000000000
--- a/cogs/installer/package.scm
+++ /dev/null
@@ -1,97 +0,0 @@
-;; TODO:
-;; Parse the arguments from the command line, in this case either grab the path to the directory, or a git url, or the local directory
-;; Parse the cog file, and check the dependencies. If any need to be downloaded, fetch those
-;; Install to $STEEL_HOME/cogs to make it available for anything to download
-;; Version resolution... for now just assume everything is compatible with everything without versions
-;; Storing versions in a manifest would be nice - a project has an associated manifest that pins versions.
-
-;; Load in contracts for stress testing
-(require "steel/result")
-
-(provide package-installer-main)
-
-(define (append-with-separator path)
-  (if (ends-with? path "/") (string-append path "cogs") (string-append path "/cogs")))
-
-;; Should make this lazy?
-(define *STEEL_HOME* (~> "STEEL_HOME" (env-var) (append-with-separator)))
-
-(define/contract (parse-cog module)
-  (->/c string? list?)
-  (if (is-dir? module)
-      (let ([cog-path (string-append module "/cog.scm")])
-        (if (is-file? cog-path)
-            ;; Update the resulting map with the path to the module
-            (list (hash-insert (parse-cog-file cog-path) 'path module))
-
-            (hash-values->list (discover-cogs module))))
-      (error! "Unable to locate the module " module)))
-
-;; Parses a cog file directly into a hashmap
-(define/contract (parse-cog-file path)
-  (->/c string? hash?)
-  (define contents (let ([file (open-input-file path)]) (read-port-to-string file)))
-  (transduce (read! contents) (mapping cdr) (into-hashmap)))
-
-;; Discover the cogs located at the path, return as a list of hash maps
-(define/contract (discover-cogs path)
-  (->/c string? hash?)
-  (when (not (path-exists? path))
-    (displayln "cogs directory does not exist, creating now...")
-    (create-directory! path))
-  (transduce (read-dir path)
-             (filtering is-dir?)
-             (mapping parse-cog)
-             (flattening)
-             (mapping (lambda (package) (list (hash-get package 'package-name) package)))
-             (into-hashmap)))
-
-;; Given a package spec, install that package directly to the file system
-(define/contract (install-package package)
-  (->/c hash? string?)
-  (define destination
-    (string-append *STEEL_HOME* "/" (symbol->string (hash-get package 'package-name))))
-  (copy-directory-recursively! (hash-get package 'path) destination)
-  destination)
-
-;; Given a package pec, uninstall that package by deleting the contents of the installation
-(define/contract (uninstall-package package)
-  (->/c hash? string?)
-  (define destination
-    (string-append *STEEL_HOME* "/" (symbol->string (hash-get package 'package-name))))
-  (displayln destination))
-
-(define/contract (install-package-and-log cog-to-install)
-  (->/c hash? void?)
-  (let ([output-dir (install-package cog-to-install)])
-    (display "✅ Installed package to: ")
-    (displayln output-dir)
-    (newline)))
-
-(define (check-install-package installed-cogs cog-to-install)
-  (define package-name (hash-get cog-to-install 'package-name))
-  (if (hash-contains? installed-cogs package-name)
-      (begin
-        (displayln "Beginning installation for " package-name)
-        (displayln "    Package already installed...")
-        (displayln "    Overwriting existing package installation...")
-        (install-package-and-log cog-to-install))
-
-      (begin
-        (displayln "Package is not currently installed.")
-        (install-package-and-log cog-to-install))))
-
-(define (parse-cogs-from-command-line)
-  (if (empty? std::env::args) (list (current-directory)) std::env::args))
-
-(define (package-installer-main)
-
-  (define cogs-to-install (parse-cogs-from-command-line))
-
-  ;; Grab the map of installed cogs on the file system.
-  ;; We will check if the cog is already installed before patching over the directory
-  (define installed-cogs (discover-cogs *STEEL_HOME*))
-
-  (transduce cogs-to-install
-             (flat-mapping parse-cog)
-             (into-for-each (lambda (x) (check-install-package installed-cogs x)))))
diff --git a/cogs/lists/cog.scm b/cogs/lists/cog.scm
deleted file mode 100644
index 2a38bfe54..000000000
--- a/cogs/lists/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/lists)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/lists/lists.scm b/cogs/lists/lists.scm
deleted file mode 100644
index 0787775fc..000000000
--- a/cogs/lists/lists.scm
+++ /dev/null
@@ -1,44 +0,0 @@
-(provide split-last
-         flatten
-         for-each)
-
-(define (split-last-loop accum lst)
-  (if (empty? (cdr lst))
-      (list (reverse accum) (car lst))
-      (split-last-loop (cons (car lst) accum) (cdr lst))))
-
-;; @doc
-;; Given a list, splits off the last argument, returns as a pair
-(define (split-last lst)
-  (split-last-loop '() lst))
-
-;;@doc
-;; Flattens the incoming list one level
-;; ```scheme
-;; (flatten (list (list 10 20) (list 30 40))) ;; => '(10 20 30 40)
-;; ```
-(define (flatten lst)
-  (transduce lst (flattening) (into-list)))
-
-;;@doc
-;; Iterate over each item in the lst, calling the function on it.
-;; ```scheme
-;; (for-each displayln (list 1 2 3))
-;; ```
-;; Will print:
-;; ```
-;; 1
-;; 2
-;; 3
-;; ```
-(define (for-each func lst)
-  (if (null? lst)
-      void
-      (begin
-        (func (car lst))
-        (when (null? lst)
-          (return! void))
-        (for-each func (cdr lst)))))
-
-;; Need default arguments here
-; (define (remove v lst [proc ]))
diff --git a/cogs/logging/cog.scm b/cogs/logging/cog.scm
deleted file mode 100644
index 18821f087..000000000
--- a/cogs/logging/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/logging)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/logging/log.scm b/cogs/logging/log.scm
deleted file mode 100644
index 666fb709e..000000000
--- a/cogs/logging/log.scm
+++ /dev/null
@@ -1,43 +0,0 @@
-(require-builtin steel/time)
-
-(provide log!
-         log/info!
-         log/warn!
-         log/debug!
-         log/error!)
-
-(define *info* "INFO")
-(define *warn* "WARN")
-(define *debug* "DEBUG")
-(define *error* "ERROR")
-(define *trace* "TRACE")
-
-;;@doc
-;; Log directly on the specified level the with arguments, as a list
-(define (log! level arg-list)
-  (apply displayln (append (list (local-time/now! "%Y-%m-%dT%H:%M:%S") " [" level "] - ") arg-list)))
-
-;;@doc
-;; Log the arguments using the *info* target, i.e. log on INFO
-(define (log/info! . args)
-  (log! *info* args))
-
-;;@doc
-;; Log the arguments using the *warn* target, i.e. log on WARN
-(define (log/warn! . args)
-  (log! *warn* args))
-
-;;@doc
-;; Log the arguments using the *debug* target, i.e. log on DEBUG
-(define (log/debug! . args)
-  (log! *debug* args))
-
-;;@doc
-;; Log the arguments using the *error* target, i.e. log on ERROR
-(define (log/error! . args)
-  (log! *error* args))
-
-;;@doc
-;; Log the arguments using the *trace* target, i.e. log on TRACE
-(define (log/trace! . args)
-  (log! *trace* args))
diff --git a/cogs/module-tests/export.scm b/cogs/module-tests/export.scm
deleted file mode 100644
index 225870eb9..000000000
--- a/cogs/module-tests/export.scm
+++ /dev/null
@@ -1,38 +0,0 @@
-(provide Applesauce
-         bananas
-         foo-bar-baz
-         new-identifier
-         one-more-identifier
-         another-identifier
-         Applesauce-foo
-         Applesauce-bar
-         Applesauce-baz
-         thing-should-not-escape
-
-         my-fun-contracted-function)
-
-(define (bananas)
-  (error "Hello world"))
-
-(define (foo-bar-baz)
-  10)
-
-(define/contract (my-fun-contracted-function x y)
-  (->/c int? int? int?)
-  (+ x y))
-
-(define new-identifier 100)
-
-(define one-more-identifier 'foo-bar-baz)
-(define another-identifier 100)
-
-(define-syntax thing-should-not-escape
-  (syntax-rules ()
-    [(thing-should-not-escape x) (thing-should-not-escape2 x)]))
-
-(define-syntax thing-should-not-escape2
-  (syntax-rules ()
-    [(thing-should-not-escape x) x]))
-
-;; This should be provided!
-(struct Applesauce (foo bar baz))
diff --git a/cogs/module-tests/import.scm b/cogs/module-tests/import.scm
deleted file mode 100644
index 62943756d..000000000
--- a/cogs/module-tests/import.scm
+++ /dev/null
@@ -1,24 +0,0 @@
-(require (prefix-in export.
-                    (only-in "export.scm"
-                             thing-should-not-escape
-                             Applesauce
-                             bananas
-                             my-fun-contracted-function)))
-
-export.Applesauce
-
-export.bananas
-
-export.my-fun-contracted-function
-
-(export.thing-should-not-escape 10)
-
-;; Dead code analysis would be nice as well
-;; If we can run constant evaluation over the result without actually
-;; taking the const evaluation branches, we can store the
-;; resulting removed spans and just render them in the LSP
-(cond
-  [(list? 10) (displayln "hello world!")]
-  [else
-   =>
-   (displayln "foo bar")])
diff --git a/cogs/other.scm b/cogs/other.scm
deleted file mode 100644
index 748e7d8d4..000000000
--- a/cogs/other.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-; (require "dispatch.scm")
-
-; (apples 10)
-
-;; Lookup multiple keys at a time
-(define (href table . keys)
-  (foldl (lambda (key t) (hash-get t key)) table keys))
diff --git a/cogs/r5rs.scm b/cogs/r5rs.scm
deleted file mode 100644
index 2134641ce..000000000
--- a/cogs/r5rs.scm
+++ /dev/null
@@ -1,587 +0,0 @@
-;; Adapted from https://github.com/ashinn/chibi-scheme/blob/master/tests/r5rs-tests.scm
-;; with the following copyright notice:
-;;
-;; -------------------------------------------------------------------
-;;
-;; Copyright (c) 2009-2021 Alex Shinn
-;; All rights reserved.
-;;
-;; Redistribution and use in source and binary forms, with or without
-;; modification, are permitted provided that the following conditions
-;; are met:
-;; 1. Redistributions of source code must retain the above copyright
-;;    notice, this list of conditions and the following disclaimer.
-;; 2. Redistributions in binary form must reproduce the above copyright
-;;    notice, this list of conditions and the following disclaimer in the
-;;    documentation and/or other materials provided with the distribution.
-;; 3. The name of the author may not be used to endorse or promote products
-;;    derived from this software without specific prior written permission.
-;;
-;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-;; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-;; IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-;; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-;; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-;; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-;;
-;; -------------------------------------------------------------------
-;;
-;; Modified by Matt Paras for use within the Steel test suite
-
-(require "tests/unit-test.scm"
-         (for-syntax "tests/unit-test.scm"))
-
-(set-test-mode!)
-
-(check-equal? "Parsing hex" #x0f 15)
-(check-equal? "Parsing octal" #o0777 511)
-(check-equal? "Parsing binary" #b0110 6)
-
-(check-equal? "filter treats lists as true" (filter (lambda (n) (list 1 2)) (list 1 2)) '(1 2))
-
-(check-equal?
- "Symbols are interned correctly - lists should use the existing symbols that have been interned"
- (eq? 'definitely-hasnt-been-seen-before
-      (let ([_ (#%black-box)]) (car '(definitely-hasnt-been-seen-before))))
- #true)
-
-(check-equal? "addition" 8 ((lambda (x) (+ x x)) 4))
-
-(check-equal? "Variable arity function call" '(3 4 5 6) ((lambda x x) 3 4 5 6))
-
-(check-equal? "Rest arguments" '(5 6) ((lambda (x y . z) z) 3 4 5 6))
-
-(check-equal? "Branching with >" 'yes (if (> 3 2) 'yes 'no))
-
-(check-equal? "Branch with <" 'no (if (> 2 3) 'yes 'no))
-
-(check-equal? "Numeric operations with if" 1 (if (> 3 2) (- 3 2) (+ 3 2)))
-
-(check-equal? "Cond with >"
-              'greater
-              (cond
-                [(> 3 2) 'greater]
-                [(< 3 2) 'less]))
-
-(check-equal? "Cond with equal"
-              'equal
-              (cond
-                [(> 3 3) 'greater]
-                [(< 3 3) 'less]
-                [else 'equal]))
-
-(check-equal? "Case macro"
-              'composite
-              (case (* 2 3)
-                [(2 3 5 7) 'prime]
-                [(1 4 6 8 9) 'composite]))
-
-(check-equal? "Case with chars"
-              'consonant
-              (case (car '(c d))
-                [(a e i o u) 'vowel]
-                [(w y) 'semivowel]
-                [else 'consonant]))
-
-(check-equal? "and true" #t (and (= 2 2) (> 2 1)))
-
-(check-equal? "and false" #f (and (= 2 2) (< 2 1)))
-
-(check-equal? "and returns last in the list" '(f g) (and 1 2 'c '(f g)))
-
-(check-equal? "and defaults to true" #t (and))
-
-(check-equal? "or true on the first" #t (or (= 2 2) (> 2 1)))
-
-(check-equal? "or true on the first, second not true" #t (or (= 2 2) (< 2 1)))
-
-;; TODO
-(skip-compile (check-equal? '(b c) (or (memq 'b '(a b c)) (/ 3 0))))
-
-(check-equal? "basic let" 6 (let ([x 2] [y 3]) (* x y)))
-
-(check-equal? "basic let with multiple levels"
-              35
-              (let ([x 2] [y 3]) (let ([x 7] [z (+ x y)]) (* z x))))
-
-(check-equal? "basic let*" 70 (let ([x 2] [y 3]) (let* ([x 7] [z (+ x y)]) (* z x))))
-
-(check-equal? "interior define"
-              -2
-              (let ()
-                (define x 2)
-                (define f (lambda () (- x)))
-                (f)))
-
-;; TODO: This gets converted into a plain let,
-;; and then somehow the variable name gets overwritten? Maybe during constant propagation?
-(define let*-def 1)
-(let* ()
-  (define let*-def 2)
-  #f)
-(check-equal? "Redefine top level with interior define, stays the same" 1 let*-def)
-
-;; TODO: `do` macro
-(skip-compile
- (check-equal '#(0 1 2 3 4)
-              (do ((vec (make-vector 5)) (i 0 (+ i 1))) ((= i 5) vec) (vector-set! vec i i)))
- (check-equal 25
-              (let ([x '(1 3 5 7 9)]) (do ((x x (cdr x)) (sum 0 (+ sum (car x)))) ((null? x) sum)))))
-
-(check-equal? "named let"
-              '((6 1 3) (-5 -2))
-              (let loop ([numbers '(3 -2 1 6 -5)] [nonneg '()] [neg '()])
-                (cond
-                  [(null? numbers) (list nonneg neg)]
-                  [(>= (car numbers) 0) (loop (cdr numbers) (cons (car numbers) nonneg) neg)]
-                  [(< (car numbers) 0) (loop (cdr numbers) nonneg (cons (car numbers) neg))])))
-
-(check-equal? "simple quasiquote and unquote" '(list 3 4) `(list ,(+ 1 2) 4))
-
-(check-equal? "quasiquote and unquote with more" '(list a 'a) (let ([name 'a]) `(list ,name ',name)))
-
-(check-equal? "unquote splicing" '(a 3 4 5 6 b) `(a ,(+ 1 2) ,@(map abs '(4 -5 6)) b))
-
-(check-equal? "unquote splicing inside quasiquote"
-              '(a 3 `(list ,@(map abs '(4 -5 6)) b))
-              `(a ,(+ 1 2) `(list ,@(map abs '(4 -5 6)) b)))
-
-(check-equal? "unquote splicing with unquote"
-              '(10 5 4 16 9 8)
-              `(10 5 ,(expt 2 2) ,@(map (lambda (n) (expt n 2)) '(4 3)) 8))
-
-(check-equal? "more complex unquote"
-              '(a `(b ,(+ 1 2) ,(foo 4 d) e) f)
-              `(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f))
-
-(check-equal? "double unquote and quote"
-              '(a `(b ,x ,'y d) e)
-              (let ([name1 'x] [name2 'y]) `(a `(b ,,name1 ,',name2 d) e)))
-
-(check-equal? "named quasiquote" '(list 3 4) (quasiquote (list (unquote (+ 1 2)) 4)))
-
-;; TODO: Add eqv?
-(skip-compile (check-equal? #t (eqv? 'a 'a))
-              (check-equal #f (eqv? 'a 'b))
-              (check-equal #t (eqv? '() '()))
-              (check-equal #f (eqv? (cons 1 2) (cons 1 2)))
-              (check-equal #f (eqv? (lambda () 1) (lambda () 2)))
-              (check-equal #t (let ([p (lambda (x) x)]) (eqv? p p))))
-
-(check-equal? "Symbols are interned" #t (eq? 'a 'a))
-
-;; TODO: With constant evaluation, these do end up being the same thing
-(check-equal? "lists don't get interned" #f (eq? (list 'a) (list 'a)))
-
-;; Empty lists are interned
-(check-equal? "Empty lists are interned" #t (eq? '() '()))
-
-(check-equal? "functions are equal" #t (eq? car car))
-
-(check-equal? "Local vars that are constant point to the same object" #t (let ([x '(a)]) (eq? x x)))
-
-(check-equal? "Function objects are eq? via pointer equality" #t (let ([p (lambda (x) x)]) (eq? p p)))
-
-(check-equal? "Value equality for interned symbols" #t (equal? 'a 'a))
-
-(check-equal? "Value equality for interned lists" #t (equal? '(a) '(a)))
-
-(check-equal? "Value equality for nested interned lists" #t (equal? '(a (b) c) '(a (b) c)))
-
-(check-equal? "String equality" #t (equal? "abc" "abc"))
-
-(check-equal? "String inequality" #f (equal? "abc" "abcd"))
-
-(check-equal? "String inequality, first char" #f (equal? "a" "b"))
-
-(check-equal? "Integer equality" #t (equal? 2 2))
-
-;; TODO: Figure these comments ones out
-
-(check-equal? "equality with float and int" #f (equal? 2.0 2))
-
-(check-equal? "numeric equality with float and int" #t (= 1 1.0))
-
-(check-equal? "pointer equality with int and int" #t (eq? 1 1))
-
-(check-equal? "pointer equality with floats" #t (eq? 1.0 1.0))
-
-(check-equal? "numeric equality with float and float" #t (= 1.0 1.0))
-
-(skip-compile (check-equal #f (eqv? 2 2.0))
-              ;; TODO: Add make-vector function
-              (check-equal #t (equal? (make-vector 5 'a) (make-vector 5 'a))))
-
-(check-equal? "max over ints" 4 (max 3 4))
-
-(check-equal? "max with float and int" 4 (max 3.9 4))
-
-(check-equal? "Addition binop" 7 (+ 3 4))
-
-(check-equal? "Addition unary op" 3 (+ 3))
-
-(check-equal? "Addition no args" 0 (+))
-
-(check-equal? "Multiplication one arg, int" 4 (* 4))
-
-(check-equal? "Multiplication no args, int " 1 (*))
-
-(check-equal? "Subtraction binop" -1 (- 3 4))
-
-(check-equal? "Subtract three args" -6 (- 3 4 5))
-
-(check-equal? "Subtraction unary op" -3 (- 3))
-
-(check-equal? "Subtraction, floating point and int" -1.0 (- 3.0 4))
-
-(check-equal? "abs int" 7 (abs -7))
-
-(check-equal? "basic string->number" 100 (string->number "100"))
-(check-equal? "string->number with radix" 256 (string->number "100" 16))
-(check-equal? "string->number with different base" 127 (string->number "177" 8))
-(check-equal? "string->number base 2" 5 (string->number "101" 2))
-(check-equal? "string->number with scientific notation" 100.0 (string->number "1e2"))
-
-(check-equal? "basic number->string" "100" (number->string 100))
-(check-equal? "number->string with different base" "100" (number->string 256 16))
-(check-equal? "number->string base 16 doesn't work" "ff" (number->string 255 16))
-(check-equal? "number->string base 8" "177" (number->string 127 8))
-(check-equal? "number->string base 2" "101" (number->string 5 2))
-
-;; TODO: Adjust the below check-equals
-
-(skip-compile (check-equal 1 (modulo 13 4))
-              (check-equal 1 (remainder 13 4))
-              (check-equal 3 (modulo -13 4))
-              (check-equal -1 (remainder -13 4))
-              (check-equal -3 (modulo 13 -4))
-              (check-equal 1 (remainder 13 -4))
-              (check-equal -1 (modulo -13 -4))
-              (check-equal -1 (remainder -13 -4))
-              (check-equal 4 (gcd 32 -36))
-              (check-equal 288 (lcm 32 -36)))
-
-(check-equal? "integers are truthy" #f (not 3))
-
-(check-equal? "lists are truthy" #f (not (list 3)))
-
-(check-equal? "empty lists are true" #f (not '()))
-
-(check-equal? "empty lists are true, constructor" #f (not (list)))
-
-(check-equal? "ints are not bools" #f (boolean? 0))
-
-(check-equal? "empty list is not a boolean" #f (boolean? '()))
-
-; (check-equal #t (pair? '(a . b)))
-
-(check-equal? "lists are considered pairs" #t (pair? '(a b c)))
-
-(check-equal? "cons onto empty list" '(a) (cons 'a '()))
-
-(check-equal? "cons list onto list" '((a) b c d) (cons '(a) '(b c d)))
-
-(check-equal? "cons string onto list of symbols" '("a" b c) (cons "a" '(b c)))
-
-; (check-equal '(a . 3) (cons 'a 3))
-
-; (check-equal '((a b) . c) (cons '(a b) 'c))
-
-(check-equal? "take the car of a list of symbols" 'a (car '(a b c)))
-
-(check-equal? "take the car, where the car is a list" '(a) (car '((a) b c d)))
-
-; (check-equal 1 (car '(1 . 2)))
-
-(check-equal? "take the cdr of a list" '(b c d) (cdr '((a) b c d)))
-
-; (check-equal 2 (cdr '(1 . 2)))
-
-(check-equal? "Check list predicate" #t (list? '(a b c)))
-
-(check-equal? "Empty list is a list" #t (list? '()))
-
-; (check-equal #f (list? '(a . b)))
-
-; (check-equal #f
-;       (let ([x (list 'a)])
-;         (set-cdr! x x)
-;         (list? x)))
-
-(check-equal? "List constructor" '(a 7 c) (list 'a (+ 3 4) 'c))
-
-(check-equal? "empty list constructor" '() (list))
-
-(check-equal? "length of a flat list" 3 (length '(a b c)))
-
-(check-equal? "length of a non flat list" 3 (length '(a (b) (c d e))))
-
-(check-equal? "empty list has a length of 0" 0 (length '()))
-
-(check-equal? "append two lists" '(x y) (append '(x) '(y)))
-
-(check-equal? "append big list to small list" '(a b c d) (append '(a) '(b c d)))
-
-(check-equal? "append nested lists" '(a (b) (c)) (append '(a (b)) '((c))))
-
-; (check-equal '(a b c . d) (append '(a b) '(c . d)))
-
-;; NOTE: Improper lists are not supported, so this should fail and we should note this in
-;; in the test suite
-; (check-equal? "append to empty list" 'a (append '() 'a))
-
-(check-equal? "reverse list" '(c b a) (reverse '(a b c)))
-
-(check-equal? "reverse nested list" '((e (f)) d (b c) a) (reverse '(a (b c) d (e (f)))))
-
-(check-equal? "simple list-ref" 'c (list-ref '(a b c d) 2))
-
-(skip-compile (check-equal '(a b c) (memq 'a '(a b c)))
-              (check-equal '(b c) (memq 'b '(a b c)))
-              (check-equal #f (memq 'a '(b c d)))
-              (check-equal #f (memq (list 'a) '(b (a) c))))
-
-(check-equal? "simple member" '((a) c) (member (list 'a) '(b (a) c)))
-
-(skip-compile (check-equal '(101 102) (memv 101 '(100 101 102)))
-              (check-equal #f (assq (list 'a) '(((a)) ((b)) ((c)))))
-              (check-equal '(5 7) (assv 5 '((2 3) (5 7) (11 13)))))
-
-(check-equal? "assoc" '((a)) (assoc (list 'a) '(((a)) ((b)) ((c)))))
-
-(check-equal? "symbol predicate" #t (symbol? 'foo))
-
-(check-equal? "symbol predicate from constant list" #t (symbol? (car '(a b))))
-
-(check-equal? "symbol predicate fails on string" #f (symbol? "bar"))
-
-(check-equal? "nil symbol is symbol" #t (symbol? 'nil))
-
-(check-equal? "empty list is not a symbol" #f (symbol? '()))
-
-(check-equal? "symbol->string basic case" "flying-fish" (symbol->string 'flying-fish))
-
-(check-equal? "symbol-string works" "Martin" (symbol->string 'Martin))
-
-(check-equal? "string losslessly moves into symbol and back"
-              "Malvina"
-              (symbol->string (string->symbol "Malvina")))
-
-(check-equal? "string predicate correctly identifies a string" #t (string? "a"))
-
-(check-equal? "string predicate fails on a symbol" #f (string? 'a))
-
-(check-equal? "empty string has a length of 0" 0 (string-length ""))
-
-(check-equal? "string length correctly reported for standard string" 3 (string-length "abc"))
-
-(check-equal? "string indexing into first character" #\a (string-ref "abc" 0))
-
-(check-equal? "string indexing into last character" #\c (string-ref "abc" 2))
-
-(check-equal? "empty substring" "" (substring "abc" 0 0))
-(check-equal? "substring just the first character" "a" (substring "abc" 0 1))
-(check-equal? "substring a larger chunk" "bc" (substring "abc" 1 3))
-
-(check-equal? "Basic functionality of make-string" "aaa" (make-string 3 #\a))
-(check-equal? "make-string with no character" "\0\0\0" (make-string 3))
-(check-equal? "make-string with zero length" "" (make-string 0))
-(check-equal? "make-string with multiple additional characters" "error" (make-string 3 #\a #\b))
-
-(check-equal? "string-equality with constructor, equal" #t (string=? "a" (string #\a)))
-(check-equal? "string-equality with constructor, not equal" #f (string=? "a" (string #\b)))
-(check-equal? "string<, true" #t (string<? "a" "aa"))
-(check-equal? "string<, false" #f (string<? "aa" "a"))
-(check-equal? "string<, same strings" #f (string<? "a" "a"))
-(check-equal? "string <=, true" #t (string<=? "a" "aa"))
-(check-equal? "string <=, same string" #t (string<=? "a" "a"))
-(check-equal? "string>, true" #t (string>? "aa" "a"))
-(check-equal? "string>, false" #f (string>? "a" "aa"))
-(check-equal? "string>, same strings" #f (string>? "a" "a"))
-(check-equal? "string >=, true" #t (string>=? "aa" "a"))
-(check-equal? "string >=, same string" #t (string>=? "a" "a"))
-
-(check-equal? "case-insensitive string-equality with constructor, equal"
-              #t
-              (string-ci=? "A" (string #\a)))
-(check-equal? "case-insensitive string-equality with constructor, not equal"
-              #f
-              (string-ci=? "A" (string #\b)))
-(check-equal? "case-insensitive string<, true" #t (string-ci<? "A" "aa"))
-(check-equal? "case-insensitive string<, false" #f (string-ci<? "AA" "a"))
-(check-equal? "case-insensitive string<, same strings" #f (string-ci<? "A" "a"))
-(check-equal? "case-insensitive string <=, true" #t (string-ci<=? "A" "aa"))
-(check-equal? "case-insensitive string <=, same string" #t (string-ci<=? "A" "a"))
-(check-equal? "case-insensitive string>, true" #t (string-ci>? "aa" "A"))
-(check-equal? "case-insensitive string>, false" #f (string-ci>? "a" "AA"))
-(check-equal? "case-insensitive string>, same strings" #f (string-ci>? "A" "a"))
-(check-equal? "case-insensitive string >=, true" #t (string-ci>=? "aa" "A"))
-(check-equal? "case-insensitive string >=, same string" #t (string-ci>=? "a" "A"))
-
-(check-equal? "make-string creates single character string 'a' correctly" #t (string=? "a" (make-string 1 #\a)))
-(check-equal? "make-string with character 'b' does not create string 'a'" #f (string=? "a" (make-string 1 #\b)))
-
-(check-equal? "string-append with empty string" "abc" (string-append "abc" ""))
-
-(check-equal? "string-append with empty string on the lhs" "abc" (string-append "" "abc"))
-
-(check-equal? "string-append with two non empty strings" "abc" (string-append "a" "bc"))
-
-(skip-compile (check-equal '#(0 ("Sue" "Sue") "Anna")
-                           (let ([vec (vector 0 '(2 2 2 2) "Anna")])
-                             (vector-set! vec 1 '("Sue" "Sue"))
-                             vec))
-              (check-equal '(dah dah didah) (vector->list '#(dah dah didah)))
-              (check-equal '#(dididit dah) (list->vector '(dididit dah))))
-
-(check-equal? "function correctly identified as a procedure" #t (procedure? car))
-
-(check-equal? "symbol correctly identified as NOT as a procedure" #f (procedure? 'car))
-
-(check-equal? "user defined function correctly identified as a procedure"
-              #t
-              (procedure? (lambda (x) (* x x))))
-
-(check-equal? "quoted expression correctly identified as NOT as procedure"
-              #f
-              (procedure? '(lambda (x) (* x x))))
-
-(check-equal? "basic call/cc with native predicate" #t (call-with-current-continuation procedure?))
-
-(check-equal? "basic call/cc with user defined function"
-              7
-              (call-with-current-continuation (lambda (k) (+ 2 5))))
-
-(check-equal? "more complex call/cc with user defined function"
-              3
-              (call-with-current-continuation (lambda (k) (+ 2 5 (k 3)))))
-
-(check-equal? "apply with native function" 7 (apply + (list 3 4)))
-
-(check-equal? "map with user defined function" '(b e h) (map cadr '((a b) (d e) (g h))))
-
-(check-equal? "map with numeric op" '(1 4 27 256 3125) (map (lambda (n) (expt n n)) '(1 2 3 4 5)))
-
-(check-equal? "map with multiple list arguments" '(5 7 9) (map + '(1 2 3) '(4 5 6)))
-
-(check-equal? "force and delay" 3 (force (delay (+ 1 2))))
-
-(check-equal? "force and delay with local variable"
-              '(3 3)
-              (let ([p (delay (+ 1 2))]) (list (force p) (force p))))
-
-(skip-compile (check-equal '#(0 1 4 9 16)
-                           (let ([v (make-vector 5)])
-                             (for-each (lambda (i) (vector-set! v i (* i i))) '(0 1 2 3 4))
-                             v)))
-
-(check-equal? "using else as a variable"
-              'ok
-              (let ([else 1])
-                (cond
-                  [else 'ok]
-                  [#t 'bad])))
-
-(check-equal? "Using an arrow as a variable"
-              'ok
-              (let ([=> 1])
-                (cond
-                  [#t
-                   =>
-                   'ok])))
-
-(check-equal? "Override unquote in a local context" '(,foo) (let ([unquote 1]) `(,foo)))
-(check-equal? "Override unquote-splicing in a local context"
-              '(,@foo)
-              (let ([unquote-splicing 1]) `(,@foo)))
-
-;; TODO: Implement let-syntax
-(skip-compile (check-equal 'ok
-                           (let ()
-                             (let-syntax ()
-                               (define internal-def 'ok))
-                             internal-def))
-              (check-equal 'ok
-                           (let ()
-                             (letrec-syntax ()
-                               (define internal-def 'ok))
-                             internal-def)))
-
-(check-equal? "mutation within local function"
-              '(2 1)
-              ((lambda ()
-                 (let ([x 1])
-                   (let ([y x])
-                     (set! x 2)
-                     (list x y))))))
-
-(check-equal? "multiple levels of let with mutation"
-              '(2 2)
-              ((lambda ()
-                 (let ([x 1])
-                   (set! x 2)
-                   (let ([y x]) (list x y))))))
-
-(check-equal? "local mutation"
-              '(1 2)
-              ((lambda ()
-                 (let ([x 1])
-                   (let ([y x])
-                     (set! y 2)
-                     (list x y))))))
-
-(check-equal? "Multiple mutations inside local context"
-              '(2 3)
-              ((lambda ()
-                 (let ([x 1])
-                   (let ([y x])
-                     (set! x 2)
-                     (set! y 3)
-                     (list x y))))))
-
-; (skip-compile
-(check-equal? "Dynamic wind"
-              '(a b c)
-              (let* ([path '()] [add (lambda (s) (set! path (cons s path)))])
-                (dynamic-wind (lambda () (add 'a)) (lambda () (add 'b)) (lambda () (add 'c)))
-                (reverse path)))
-
-(check-equal? "Dynamic wind more complex"
-              '(connect talk1 disconnect connect talk2 disconnect)
-              (let ([path '()] [c #f])
-                (let ([add (lambda (s) (set! path (cons s path)))])
-                  (dynamic-wind (lambda () (add 'connect))
-                                (lambda ()
-                                  (add (call-with-current-continuation (lambda (c0)
-                                                                         (set! c c0)
-                                                                         'talk1))))
-                                (lambda () (add 'disconnect)))
-                  (if (< (length path) 4) (c 'talk2) (reverse path)))))
-
-; (check-equal 2
-;              (let-syntax ([foo (syntax-rules :::
-;                                  []
-;                                  [(foo ... args :::) (args ::: ...)])])
-;                (foo 3 - 5)))
-; (check-equal
-;  '(5 4 1 2 3)
-;  (let-syntax ([foo (syntax-rules ()
-;                      [(foo args ... penultimate ultimate) (list ultimate penultimate args ...)])])
-;    (foo 1 2 3 4 5)))
-
-; )
-
-;; -------------- Report ------------------
-
-(require "lists/lists.scm")
-(define r5rs-test-stats (get-test-stats))
-
-(displayln "Passed: " (hash-ref r5rs-test-stats 'success-count))
-(displayln "Skipped compilation (expected failure): " (hash-ref r5rs-test-stats 'failed-to-compile))
-(displayln "Failed: " (hash-ref r5rs-test-stats 'failure-count))
-
-(for-each (lambda (x) (displayln "    > " x)) (hash-ref r5rs-test-stats 'failures))
diff --git a/cogs/r7rs.scm b/cogs/r7rs.scm
deleted file mode 100644
index f04878a5b..000000000
--- a/cogs/r7rs.scm
+++ /dev/null
@@ -1,79 +0,0 @@
-;; Adapted from https://github.com/ashinn/chibi-scheme/blob/master/tests/r5rs-tests.scm
-;; with the following copyright notice:
-;;
-;; -------------------------------------------------------------------
-;;
-;; Copyright (c) 2009-2021 Alex Shinn
-;; All rights reserved.
-;;
-;; Redistribution and use in source and binary forms, with or without
-;; modification, are permitted provided that the following conditions
-;; are met:
-;; 1. Redistributions of source code must retain the above copyright
-;;    notice, this list of conditions and the following disclaimer.
-;; 2. Redistributions in binary form must reproduce the above copyright
-;;    notice, this list of conditions and the following disclaimer in the
-;;    documentation and/or other materials provided with the distribution.
-;; 3. The name of the author may not be used to endorse or promote products
-;;    derived from this software without specific prior written permission.
-;;
-;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
-;; IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-;; OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
-;; IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
-;; INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-;; NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-;; DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-;; THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-;; (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-;; THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-;;
-;; -------------------------------------------------------------------
-;;
-;; Modified by Matt Paras for use within the Steel test suite
-
-(require "tests/unit-test.scm"
-         (for-syntax "tests/unit-test.scm"))
-
-(set-test-mode!)
-
-(require "lists/lists.scm")
-
-;;;; Parameters
-
-(define location (make-parameter "here"))
-
-(check-equal? "Simple parameterize"
-              "there"
-              (parameterize ([location "there"])
-                (location))) ;; "there"
-
-(check-equal? "parameter keeps original value" "here" (location)) ;; "here"
-
-(check-equal? "Parameter changes multiple times"
-              (list "in a house" "with a mouse" "in a house")
-              (parameterize ([location "in a house"])
-                (list (location)
-                      (parameterize ([location "with a mouse"])
-                        (location))
-                      (location)))) ;; '("in a house" "with a mouse" "in a house")
-
-(check-equal? "parameter keeps original value after" "here" (location)) ;; "here"
-
-(define (would-you-could-you?)
-  (and (not (equal? (location) "here")) (not (equal? (location) "there"))))
-
-(check-equal? "Parameters refer to the same location" #false (would-you-could-you?))
-
-(check-equal? "Parameters refer to the same location, changed to be the same"
-              #true
-              (parameterize ([location "on a bus"])
-                (would-you-could-you?)))
-
-(define r7rs-test-stats (get-test-stats))
-
-(displayln "Passed: " (hash-ref r7rs-test-stats 'success-count))
-(displayln "Skipped compilation (expected failure): " (hash-ref r7rs-test-stats 'failed-to-compile))
-(displayln "Failed: " (hash-ref r7rs-test-stats 'failure-count))
-
-(for-each (lambda (x) (displayln "    > " x)) (hash-ref r7rs-test-stats 'failures))
diff --git a/cogs/reflection/cogs.scm b/cogs/reflection/cogs.scm
deleted file mode 100644
index 1bdbc2309..000000000
--- a/cogs/reflection/cogs.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/reflection)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/reflection/reflect.scm b/cogs/reflection/reflect.scm
deleted file mode 100644
index d50aa0952..000000000
--- a/cogs/reflection/reflect.scm
+++ /dev/null
@@ -1,32 +0,0 @@
-(provide find-function-pointer reset-modules!)
-
-(define *modules* 'uninitialized)
-
-(define (reset-modules!)
-    (set! *modules* 'uninitialized))
-
-(define (load-modules)
-    (when (symbol? *modules*)
-          (set! *modules* (%list-modules!))))
-
-(define (get-modules!) 
-    (load-modules)
-    *modules*)
-
-;;@doc
-;; Attempts to search for the name of the function from the global module table
-;; If not found, returns #false.
-;; 
-;; This lazily loads the modules - if for whatever reason, a module is loaded _after_ this has been
-;; called, the module table in memory will need to be refreshed using `reset-modules!` 
-(define (find-function-pointer function-ptr)
-    (define found
-        (transduce (get-modules!) 
-                   (mapping (lambda (mod) (%module/lookup-function mod function-ptr))) 
-                   (filtering (lambda (x) (not (boolean? x))))
-                   (into-list)))
-
-    ; found)
-
-    (if found (car found) #f))
-
diff --git a/cogs/require.scm b/cogs/require.scm
deleted file mode 100644
index 18710a30a..000000000
--- a/cogs/require.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-(require "sorting/trie-sort.scm")
-; (require "transducers/transducers.scm")
diff --git a/cogs/slack/cog.scm b/cogs/slack/cog.scm
deleted file mode 100644
index 7e83a8f41..000000000
--- a/cogs/slack/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'slack/websocket)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/slack/main.scm b/cogs/slack/main.scm
deleted file mode 100644
index d3b735ebb..000000000
--- a/cogs/slack/main.scm
+++ /dev/null
@@ -1,25 +0,0 @@
-(require "slack.scm")
-(require "steel/time/time.scm"
-         (for-syntax "steel/time/time.scm"))
-
-(require "steel/logging/log.scm")
-
-(define/contract (process-message body)
-  (->/c hash? any/c)
-  ;   (displayln body)
-
-  (log/info! body)
-
-  (define event-json (-> body (hash-get 'payload) (hash-get 'event)))
-  (define text (hash-try-get event-json 'text))
-  (define channel (hash-get event-json 'channel))
-
-  (when (and text (starts-with? text "!ping"))
-    (time! (send-message channel "pong!"))))
-
-(define (process-message-timed body)
-  (time! (process-message body)))
-
-(define *ws-url* (get-ws-url))
-
-(event-loop *ws-url* (connect-to-slack-socket *ws-url*) process-message-timed)
diff --git a/cogs/slack/slack.scm b/cogs/slack/slack.scm
deleted file mode 100644
index 519ea9620..000000000
--- a/cogs/slack/slack.scm
+++ /dev/null
@@ -1,102 +0,0 @@
-(require-builtin steel/web/requests)
-
-(#%require-dylib "libsteel_websockets"
-                 (only-in ws/message-ping?
-                          ws/message-pong?
-                          ws/message-text
-                          ws/message-text?
-                          ws/message-ping->pong
-                          ws/message->text-payload
-                          ws/connect
-                          ws/read-message!
-                          ws/write-message!))
-
-(require "steel/result")
-(require "steel/logging/log.scm")
-(require-builtin steel/time)
-
-(provide event-loop
-         send-message
-         connect-to-slack-socket
-         get-ws-url)
-
-(define (env-var! var)
-  (let ([e (maybe-get-env-var var)]) (if (Err? e) "TODO" (unwrap-ok e))))
-
-(define client (request/client))
-
-(define *SLACK_API_TOKEN* (env-var! "SLACK_API_TOKEN"))
-(define *SLACK_API_WS_TOKEN* (env-var! "SLACK_API_WS_TOKEN"))
-
-(define *post-message-url* "https://slack.com/api/chat.postMessage")
-(define *ws-connection-url* "https://slack.com/api/apps.connections.open")
-
-(define (send-message channel content)
-  (~> client
-      (client/post *post-message-url*)
-      (request/bearer-auth *SLACK_API_TOKEN*)
-      (request/json (hash 'channel channel 'text content))
-      (request/send)))
-
-(define (get-ws-url)
-  (log/info! "Requesting a websocket url")
-  (~> client
-      (client/post *ws-connection-url*)
-      (request/bearer-auth *SLACK_API_WS_TOKEN*)
-      (request/json (hash))
-      (request/send)
-      (response->json)
-      (hash-get 'url)))
-
-; (define *ws-url* (get-ws-url))
-
-(define (connect-to-slack-socket url)
-  (~> url (ws/connect) (first)))
-
-(define (send-acknowledgement socket body)
-  (ws/write-message! socket
-                     (ws/message-text (value->jsexpr-string (hash 'envelope_id
-                                                                  (hash-get body 'envelope_id))))))
-
-(define (loop url socket message-thunk)
-  (define message
-    (with-handler (lambda (err)
-                    (displayln "Unable to read the message from the socket, retrying connection")
-                    ;; Try to reconnect and see what happens
-                    ;; Probably need to add a sleep here at some point to retry with a backoff
-                    (loop url (connect-to-slack-socket (get-ws-url)) message-thunk))
-                  (ws/read-message! socket)))
-
-  (log/info! message)
-  ;; If its a ping, respond with a pong
-  (cond
-    [(ws/message-ping? message)
-     =>
-     (ws/write-message! socket (ws/message-ping->pong message))
-     (loop url socket message-thunk)]
-    ;; If its a text message, check if its a hello message - otherwise, continue
-    ;; And process the message
-    [(ws/message-text? message)
-     =>
-     (define body (string->jsexpr (ws/message->text-payload message)))
-     (cond
-       [(equal? "hello" (hash-try-get body 'type))
-        =>
-        (loop url socket message-thunk)]
-
-       [(equal? "disconnect" (hash-try-get body 'type))
-        =>
-        (log/info! "Refreshing the connection, sleeping for 500 ms")
-        (time/sleep-ms 500)
-        (loop url (connect-to-slack-socket (get-ws-url)) message-thunk)]
-
-       [else
-        =>
-        (send-acknowledgement socket body)
-        (message-thunk body)
-        (loop url socket message-thunk)])]
-    [else
-     =>
-     (loop url socket message-thunk)]))
-
-(define event-loop loop)
diff --git a/cogs/sorting/cog.scm b/cogs/sorting/cog.scm
deleted file mode 100644
index 14a22cc25..000000000
--- a/cogs/sorting/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/sorting)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/sorting/merge-sort.scm b/cogs/sorting/merge-sort.scm
deleted file mode 100644
index 735e56a27..000000000
--- a/cogs/sorting/merge-sort.scm
+++ /dev/null
@@ -1,49 +0,0 @@
-(provide merge-sort)
-
-;;; -----------------------------------------------------------------
-;;; Merge two lists of numbers which are already in increasing order
-
-(define merge-lists
-  (lambda (l1 l2)
-    (if (null? l1)
-        l2
-        (if (null? l2)
-            l1
-            (if (< (car l1) (car l2))
-                (cons (car l1) (merge-lists (cdr l1) l2))
-                (cons (car l2) (merge-lists (cdr l2) l1)))))))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in even positions
-
-(define even-numbers
-  (lambda (l)
-    (if (null? l)
-        '()
-        (if (null? (cdr l))
-            '()
-            (cons (car (cdr l)) (even-numbers (cdr (cdr l))))))))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in odd positions
-
-(define odd-numbers
-  (lambda (l)
-    (if (null? l)
-        '()
-        (if (null? (cdr l))
-            (list (car l))
-            (cons (car l) (odd-numbers (cdr (cdr l))))))))
-
-;;; ---------------------------------------------------------------------
-;;; Use the procedures above to create a simple and efficient merge-sort
-
-(define merge-sort
-  (lambda (l)
-    (if (null? l)
-        l
-        (if (null? (cdr l))
-            l
-            (merge-lists
-             (merge-sort (odd-numbers l))
-             (merge-sort (even-numbers l)))))))
diff --git a/cogs/sorting/quick-sort.scm b/cogs/sorting/quick-sort.scm
deleted file mode 100644
index f34b5d4ce..000000000
--- a/cogs/sorting/quick-sort.scm
+++ /dev/null
@@ -1,18 +0,0 @@
-(provide quicksort)
-
-;; Current append only accepts 2 arguments, need to make it accept 3
-(define (append-three one two three)
-    (-> one
-        (append two)
-        (append three)))
-
-(define (quicksort l gt?)
-  (if (null? l)
-      '()
-      (append-three (quicksort (filter (lambda (x) (gt? (car l) x)) (cdr l)) gt?)
-              (list (car l))
-              (quicksort (filter (lambda (x) (not (gt? (car l) x))) (cdr l)) gt?))))
-
-; (define output (quicksort '(1 3 5 7 9 8 6 4 2) >))
-
-; (assert! (equal? output '(1 2 3 4 5 6 7 8 9)))
\ No newline at end of file
diff --git a/cogs/sorting/tests.scm b/cogs/sorting/tests.scm
deleted file mode 100644
index 6372b7677..000000000
--- a/cogs/sorting/tests.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-(require "steel/tests/unit-test.scm"
-         (for-syntax "steel/tests/unit-test.scm")
-         "merge-sort.scm"
-         "trie-sort.scm"
-         "quick-sort.scm")
-
-(provide __module__)
-
-(define __module__ "tests")
-
-(test-module "trie-sort-tests"
-             (check-equal? "basic sorting"
-                           (trie-sort (list "zebras" "bananas" "apples" "foo" "bar"))
-                           '("apples" "bananas" "bar" "foo" "zebras")))
diff --git a/cogs/sorting/trie-sort.scm b/cogs/sorting/trie-sort.scm
deleted file mode 100644
index ec83360bd..000000000
--- a/cogs/sorting/trie-sort.scm
+++ /dev/null
@@ -1,87 +0,0 @@
-(provide trie-sort)
-
-(struct trie (char children end-word? word-up-to))
-
-;; Rename functions for the sake of compatibility
-(define empty (list))
-(define empty-trie (trie void empty #f empty))
-
-;; Throw in a mediocre flatten definition
-(define (flatten lst)
-  (cond
-    [(null? lst) empty]
-    [(list? lst) (append (flatten (car lst)) (flatten (cdr lst)))]
-    [else (list lst)]))
-
-;; contract: (listof char?) (listof tries?) integer? -> (listof trie?)
-(define (create-children char-list lst prefix-chars)
-  (cond
-    [(= (length char-list) 1) (handle-last-letter char-list lst prefix-chars)]
-    ;; you are in the middle of the word
-    [else (handle-intern-letter char-list lst prefix-chars)]))
-
-;; contract: (listof char?) (listof trie?) integer? -> (listof trie?)
-(define (handle-last-letter char-list lst prefix-chars)
-  (define char (first char-list))
-  ; (define next-prefix (append prefix-chars (list char)))
-  (define next-prefix (push-back prefix-chars char))
-  (cond
-    ;; children are empty, return list of empty children
-    [(empty? lst) (list (trie char empty #t next-prefix))]
-    ;; less than, put it to the left
-    [(< char (trie-char (first lst))) (cons (trie char empty #t next-prefix) lst)]
-    [(equal? char (trie-char (first lst))) ;; equal, step down a level
-     (cons (trie char (trie-children (first lst)) #t next-prefix) (rest lst))]
-    ;; move to the right
-    [else (cons (first lst) (create-children char-list (rest lst) prefix-chars))]))
-
-;; contract: (listof char?) (listof trie?) integer? -> (listof trie?)
-(define (handle-intern-letter char-list lst prefix-chars)
-  (define char (first char-list))
-  ; (define next-prefix (append prefix-chars (list char)))
-  (define next-prefix (push-back prefix-chars char))
-  (cond
-    [(empty? lst) ;; no children, pop off front and step down
-     (list (trie char (create-children (rest char-list) empty next-prefix) #f next-prefix))]
-    [(< char (trie-char (first lst))) ;; place where it is, pop off front and go
-     (cons (trie char (create-children (rest char-list) empty next-prefix) #f next-prefix) lst)]
-    [(equal? char (trie-char (first lst))) ;; equal, step down
-     (cons (trie char
-                 (create-children (rest char-list) (trie-children (first lst)) next-prefix)
-                 (trie-end-word? (first lst))
-                 (trie-word-up-to (first lst)))
-           (rest lst))]
-    ; move to the right
-    [else (cons (first lst) (create-children char-list (rest lst) prefix-chars))]))
-
-;; contract: trie? string? integer? -> trie?
-(define (insert root-trie word)
-  (define char-list (string->list word))
-  (trie (trie-char root-trie)
-        (create-children char-list (trie-children root-trie) empty)
-        (trie-end-word? root-trie)
-        (trie-word-up-to root-trie)))
-
-;; contract: trie? trie? -> boolean?
-(define (trie<? trie-node1 trie-node2)
-  (< (trie-char trie-node1) (trie-char trie-node2)))
-
-;; contract: trie? (listof string?) -> trie?
-(define (build-trie-from-list-of-words trie list-of-words)
-  (cond
-    [(= (length list-of-words) 1) (insert trie (first list-of-words))]
-    [else (build-trie-from-list-of-words (insert trie (first list-of-words)) (rest list-of-words))]))
-
-;; ------------------ SORTING ---------------------- ;;
-
-(define (trie-sort list-of-words)
-  (define new-trie (build-trie-from-list-of-words empty-trie list-of-words))
-  (pre-order new-trie))
-
-;; THIS ONE WORKS (using con and flatten)
-;; contract: trie? -> (listof string?)
-(define (pre-order trie-node)
-  (if (trie-end-word? trie-node)
-      (cons (list->string (trie-word-up-to trie-node))
-            (flatten (map pre-order (trie-children trie-node))))
-      (flatten (map pre-order (trie-children trie-node)))))
diff --git a/cogs/srfi/cog.scm b/cogs/srfi/cog.scm
deleted file mode 100644
index 88d3a4ce6..000000000
--- a/cogs/srfi/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'srfi)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
diff --git a/cogs/srfi/srfi-28/format.scm b/cogs/srfi/srfi-28/format.scm
deleted file mode 100644
index 00e8c2c8d..000000000
--- a/cogs/srfi/srfi-28/format.scm
+++ /dev/null
@@ -1,56 +0,0 @@
-; Copyright (C) Scott G. Miller (2002). All Rights Reserved.
-;
-; Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
-; the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge
-; publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to
-; do so, subject to the following conditions:
-;
-; The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-;
-; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-; OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-; LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-;
-; Modified for use within Steel by Matthew Paras (2023).
-
-(provide format)
-
-(define format
-  (lambda (format-string . objects)
-    (let ([buffer (open-output-string)])
-      (let loop ([format-list (string->list format-string)] [objects objects])
-        (cond
-          [(null? format-list) (get-output-string buffer)]
-          [(char=? (car format-list) #\~)
-           (if (null? (cdr format-list))
-               (error 'format "Incomplete escape sequence")
-               (case (cadr format-list)
-                 [(#\a)
-                  (if (null? objects)
-                      (error 'format "No value for escape sequence")
-                      (begin
-                        (display (car objects) buffer)
-                        (loop (cddr format-list) (cdr objects))))]
-                 [(#\s)
-                  (if (null? objects)
-                      (error 'format "No value for escape sequence")
-                      (begin
-                        (write (car objects) buffer)
-                        (loop (cddr format-list) (cdr objects))))]
-                 [(#\%)
-                  (newline buffer)
-                  (loop (cddr format-list) objects)]
-                 [(#\~)
-                  (write-char #\~ buffer)
-                  (loop (cddr format-list) objects)]
-                 [else (error 'format "Unrecognized escape sequence")]))]
-          [else
-           (write-char (car format-list) buffer)
-           (loop (cdr format-list) objects)])))))
-
-; (displayln (format "Hello, ~a" "World!"))
-; ; => "Hello, World!"
-
-; (displayln (format "Error, list is too short: ~s~%" '(one "two" 3)))
-; ; => "Error, list is too short: (one \"two\" 3))"
diff --git a/cogs/structs/structs.scm b/cogs/structs/structs.scm
deleted file mode 100644
index b3ff0c0cd..000000000
--- a/cogs/structs/structs.scm
+++ /dev/null
@@ -1,9 +0,0 @@
-
-
-(define (json->struct struct-descriptor struct-constructor json)
-    (define fields (hash-get struct-descriptor '#:fields))
-    (apply struct-constructor (map (lambda (field) (hash-try-get json field)) fields)))
-
-(struct Applesauce (a b c) #:transparent)
-
-(json->struct ___Applesauce-options___ Applesauce (hash 'a 10 'b 20 'c 30))
\ No newline at end of file
diff --git a/cogs/test-runner.scm b/cogs/test-runner.scm
deleted file mode 100644
index dc9c5d881..000000000
--- a/cogs/test-runner.scm
+++ /dev/null
@@ -1,53 +0,0 @@
-(require "steel/fs/fs.scm")
-
-(define shared-engine (Engine::new))
-
-(run! shared-engine "(set-test-mode!)")
-
-;; If the path contains a cog file, respect it
-; (define (parse-cog-file path)
-;   (define contents (let ([file (open-input-file path)]) (read-port-to-string file)))
-;   (transduce (read! contents) (mapping cdr) (into-hashmap)))
-
-(define (read-file-to-string path)
-  (let ([file (open-input-file path)]) (read-port-to-string file)))
-
-(define (expression-contains-provide expr-list)
-  (contains? (λ (expr)
-               (cond
-                 [(and (list? expr) (not (empty? expr)))
-                  (cond
-                    [(equal? 'provide (car expr)) #t]
-                    [(equal? 'begin (car expr)) (expression-contains-provide (cdr expr))]
-                    [else #f])]
-                 [else #f]))
-             expr-list))
-
-;; Open file, read it
-(define (path-contains-provide path)
-  (~> (read-file-to-string path) read! expression-contains-provide))
-
-(define (require-file path)
-  (when (and (ends-with? path ".scm") (path-contains-provide path))
-
-    (displayln "Loading: " path)
-
-    ;; First parse the file and check that it provides something
-    (let ([result (run! shared-engine (list (list 'require path)))])
-
-      (when (Err? result)
-
-        (error result)))))
-
-(define (get-directory-from-args)
-  (if (empty? std::env::args) "." (car std::env::args)))
-
-(walk-files (get-directory-from-args) require-file)
-
-(define test-stats
-  (~> (run! shared-engine '((require "steel/tests/unit-test.scm") (get-test-stats)))
-      (Ok->value)
-      (last)))
-
-(when (not (empty? (hash-get test-stats 'failures)))
-  (error! "There were test failures!"))
diff --git a/cogs/tests/cog.scm b/cogs/tests/cog.scm
deleted file mode 100644
index 8fdb5fadf..000000000
--- a/cogs/tests/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/tests)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/tests/unit-test.scm b/cogs/tests/unit-test.scm
deleted file mode 100644
index 99258e121..000000000
--- a/cogs/tests/unit-test.scm
+++ /dev/null
@@ -1,118 +0,0 @@
-(require "steel/colors/colors.scm")
-
-(provide test
-         (for-syntax check-equal?)
-         (for-syntax check-err?)
-         (for-syntax test-module)
-         get-test-stats
-         (for-syntax check)
-         (for-syntax skip-compile))
-
-(define *SUCCESS-COUNT* 0)
-(define *FAILURE-COUNT* 0)
-
-(define *FAILED-TO-COMPILE* 0)
-
-;; Failed tests
-(define *failures* '())
-
-(define (mark-success)
-  (set! *SUCCESS-COUNT* (+ *SUCCESS-COUNT* 1)))
-
-(define (mark-failed name)
-  (set! *FAILURE-COUNT* (+ *FAILURE-COUNT* 1))
-  (set! *failures* (cons name *failures*)))
-
-(define (mark-skipped)
-  (set! *FAILED-TO-COMPILE* (+ *FAILED-TO-COMPILE* 1)))
-
-(define (print-success name)
-  (display "test > ")
-  (display name)
-  (display " ... ")
-  (displayln-color "Ok" #:fg 'green))
-
-(define (print-failure name)
-  (display "test > ")
-  (display name)
-  (display " ... ")
-  (displayln-color "FAILED" #:fg 'red))
-
-(define-syntax check-equal?
-  (syntax-rules ()
-    [(check-equal? name input expected)
-     (with-handler (lambda (err)
-                     (mark-failed name)
-                     (print-failure name)
-                     (displayln err))
-                   (test name input expected))]))
-
-(define-syntax check-err?
-  (syntax-rules ()
-    [(check-err? name input expected)
-     (with-handler (lambda (err)
-                     (mark-success)
-                     (print-success name))
-                   (test name input expected))]))
-
-;; Check the equality, and otherwise do some nice printing of the result
-(define (test name input expected)
-  (if (equal? input expected)
-      (begin
-        (mark-success)
-        (print-success name))
-      (begin
-        (mark-failed name)
-        (print-failure name)
-        (displayln "    Expected: " expected ", Found " input))))
-
-(define-syntax test-module
-  (syntax-rules ()
-    [(test-module name expr ...)
-     (when (get-test-mode)
-       (begin
-         (displayln "###### Running tests for module " name " ######")
-         (begin
-           expr ...)
-         (displayln "Test result: " *SUCCESS-COUNT* " passed; " *FAILURE-COUNT* " failed;")
-         (display "Failures: ")
-         (displayln *failures*)))]
-    [(test-module expr ...)
-     (begin
-       expr ...)]))
-
-(define-syntax skip-compile
-  (syntax-rules ()
-    [(skip-compile) (begin)]
-    [(skip-compile expr) (mark-skipped)]
-    [(skip-compile expr exprs ...)
-     (begin
-       (mark-skipped)
-       (skip-compile exprs ...))]))
-
-(define (get-test-stats)
-  (hash 'success-count
-        *SUCCESS-COUNT*
-        'failure-count
-        *FAILURE-COUNT*
-        'failures
-        *failures*
-        'failed-to-compile
-        *FAILED-TO-COMPILE*))
-
-; (test-module
-; (check-equal? "Checks that the expressions make sense"
-;               (+ 10 20 30)
-;               (+ 10 20 30))
-
-; (check-err? "This should fail (in a good way)!"
-;             (error! "Throwing an error")
-;             (+ 10 20 30))
-
-; (check-equal? "This should fail"
-;               (+ 10 20)
-;               (+ 30 40))
-
-;   )
-
-; (check-equal? "test" (begin (error! "hello world") 10) 10)
diff --git a/cogs/thread.scm b/cogs/thread.scm
deleted file mode 100644
index 4c167ce82..000000000
--- a/cogs/thread.scm
+++ /dev/null
@@ -1,303 +0,0 @@
-(require-builtin steel/time)
-(require "steel/result")
-
-(define (loop thread-id)
-  (displayln "Hello world!")
-  (time/sleep-ms 500)
-  (displayln "Hello world from: " thread-id)
-  (loop thread-id))
-
-(define (run-background-loop)
-  (displayln "Hello world!")
-  ; (displayln spawn-thread!)
-  (let ([handle (spawn-thread! (λ () (loop 1)))]
-        [handle2 (spawn-thread! (λ ()
-                                  (time/sleep-ms 250)
-                                  (loop 2)))])
-    (thread-join! handle2)))
-
-; (spawn-thread! run-background-loop)
-
-; (define (interesting-function)
-;   (let ((a (hash 'a 100)))
-;     (spawn-thread! (lambda () (time/sleep-ms 1000) (displayln a)))))
-
-; (thread-join! (interesting-function))
-
-;; Channels! Create a channel, send values over the channel, consume on the other one, done.
-
-; (let ((handle (spawn-thread! (λ ()
-;                   (+ 10 (list-ref (list "hello world") 0))))))
-;   (time/sleep-ms 5000)
-;   (unwrap-ok
-;     (thread-join! handle)))
-
-;; Spawn thread! -> This requires some up front overhead, however spawning a new thread
-;; takes about 400 microseconds, which isn't ideal. In theory we do not need to deep clone _everything_,
-;; but there are certain optimizations that need to be implemented up front for this to work.
-; (thread-join!
-; (spawn-thread! run-background-loop))
-
-;; Spawns a thread, returning a handle to the sender to that thread.
-(define (message-passing)
-  (define channels (make-channels))
-  (define sender (list-ref channels 0))
-  (define receiver (list-ref channels 1))
-
-  ;; Worker thread, listen to requests
-  (spawn-thread! (lambda ()
-                   ;; Process incoming requests.
-                   (while #true (displayln (channel->recv receiver)))
-                   (loop)))
-
-  sender)
-
-(define *CHILD_THREADS* '())
-
-;; Keep track of all of the threads currently running
-(define (record-thread-handle handle)
-  (set! *CHILD_THREADS* (cons handle *CHILD_THREADS*)))
-
-(struct CancellableThreadHandle (sender handle))
-
-;;@doc
-;; Spawn a function, func, that runs on a background thread, running at the interval `delay-ms`
-(define (spawn-cancellable-thread-looping func delay-ms)
-  ;; Create the channels. We're going to cancel the thread using
-  ;; the sender here to interrupt the receiver
-  (define channels (make-channels))
-  (define sender (list-ref channels 0))
-  (define receiver (list-ref channels 1))
-
-  (CancellableThreadHandle sender
-                           (spawn-thread! (lambda ()
-                                            (while (not (~> (channel->try-recv receiver) (unwrap-ok)))
-                                                   (begin
-                                                     (func)
-                                                     (time/sleep-ms delay-ms)))
-                                            (displayln "Shutting down thread: "
-                                                       (thread::current/id))))))
-
-; (define tasks
-;   (map
-;    (lambda (_) (spawn-cancellable-thread-looping (lambda () (displayln (thread::current/id))) 1000))
-;    (range 0 100)))
-
-; (thread-join! (CancellableThreadHandle-handle (car tasks)))
-
-; (let ([cancellable-handler
-;        (spawn-cancellable-thread-looping (lambda () (displayln "Hello world!")) 500)])
-;   (time/sleep-ms 3000)
-;   ;; Cancel the background thread with the interrupt token
-;   (channel->send (CancellableThreadHandle-sender cancellable-handler) #t)
-
-;   (displayln "Doing more work after the function!")
-;   (time/sleep-ms 1000)
-;   (displayln "Finished"))
-
-; (let ([sender (message-passing)])
-;   (channel->send sender "Hello world!")
-;   (time/sleep-ms 500)
-;   (channel->send sender "Second message!")
-;   (time/sleep-ms 500)
-;   (channel->send sender "and we're done")
-;   (time/sleep-ms 500))
-
-; (let ([tasks (map (lambda (_)
-;                     (spawn-thread! (lambda ()
-;                                      (time/sleep-ms 2000)
-;                                      (displayln (thread::current/id)))))
-;                   (range 0 10))])
-;   (map thread-join! tasks))
-
-(require-builtin steel/process)
-
-; (define (port-stream)
-;   (let ((head (read-line-from-port my-port)))
-;     (if (equal? 'eof head)
-;         empty-stream
-;         (stream-cons head (lambda () (port-stream))))))
-
-(define (pipe-stdout channel port)
-  (let ([head (read-line-from-port port)])
-    (displayln head)
-    (if (equal? 'eof head)
-        'eof
-        (begin
-          (channel->send channel head)
-          (pipe-stdout channel port)))))
-
-(define (with-stdout-piped command)
-  (set-piped-stdout! command)
-  command)
-
-(require "steel/result")
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; BEGIN EXPERIMENT WITH LIVE PRINTING SUBPROCESS STUFF
-; (define (message-passing-sub-process)
-;   (define channels (make-channels))
-;   (define sender (list-ref channels 0))
-;   (define receiver (list-ref channels 1))
-
-;   ;; Worker thread, listen to requests
-;   (record-thread-handle (spawn-thread! (lambda ()
-;                                          (define child-process
-;                                            ; (command "cargo" '("run" "--" "sleep.scm"))
-;                                            (~> (command "cargo" '("run" "--" "sleep.scm"))
-;                                                (with-stdout-piped)
-;                                                (spawn-process)
-;                                                (Ok->value)))
-
-;                                          (define child-stdout (child-stdout child-process))
-
-;                                          ;; Send stuff along the channel until there is no more stuff
-;                                          ;; to send
-;                                          (pipe-stdout sender child-stdout)
-
-;                                          (wait child-process)
-
-;                                          (channel->send sender 'eof)
-
-;                                          ; (wait child-process)
-;                                          )))
-
-;   channels)
-
-; (require "steel/result")
-
-; (define (read-loop receiver)
-;   (let ([message (channel->try-recv receiver)])
-;     (cond
-;       [(Ok? message)
-;        (let ([inner-message (unwrap-ok message)])
-;          ;; #false would mean we don't have anything to read
-;          ;; on the channel, but the thread is not yet finished.
-;          (when (string? inner-message)
-;            (display inner-message))
-
-;          (unless (equal? 'eof inner-message)
-
-;            (time/sleep-ms 7)
-
-;            (read-loop receiver)))
-
-;        ; (if (thread-finished? (car *CHILD_THREADS*))
-;        ; (read-loop receiver)
-
-;        ; (displayln "finished")
-
-;        ; (read-loop receiver))
-;        ]
-;       [else (displayln "finished")])))
-
-; (define keep-alive #f)
-
-; (define (main)
-
-;   (define sender-and-receiver (message-passing-sub-process))
-
-;   ;; If this gets dropped, it is game over
-;   (define sender (list-ref sender-and-receiver 0))
-;   (define receiver (list-ref sender-and-receiver 1))
-
-;   (read-loop receiver)
-
-;   (displayln "finished"))
-
-; (main)
-
-;; END EXPERIMENT WITH LIVE PRINTING STUFF
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-; (while (not (~> (channel->try-recv receiver) (unwrap-ok)))
-;        (begin
-;          (displayln)
-;          (time/sleep-ms delay-ms))))
-
-(define (message-passing-sub-process)
-  (define channels (make-channels))
-  (define sender (list-ref channels 0))
-  (define receiver (list-ref channels 1))
-
-  (define command-channels (make-channels))
-  (define command-sender (list-ref channels 0))
-  (define command-receiver (list-ref channels 1))
-
-  ;; Worker thread, listen to requests
-  (record-thread-handle
-   (spawn-thread! (lambda ()
-                    (define child-process
-                      ; (command "cargo" '("run" "--" "sleep.scm"))
-                      (~> (command "bash" '()) (with-stdout-piped) (spawn-process) (Ok->value)))
-
-                    (define child-stdout (child-stdout child-process))
-                    (define child-stdin (child-stdin child-process))
-
-                    (write-line! child-stdin "ls")
-
-                    ;; Send stuff along the channel until there is no more stuff
-                    ;; to send
-                    (pipe-stdout sender child-stdout)
-
-                    ; (channel->send sender 'eof)
-
-                    (write-line! child-stdin "ls")
-
-                    (pipe-stdout sender child-stdout)
-
-                    (channel->send sender 'eof)
-
-                    ; (pipe-stdout sender child-stdout)
-
-                    ; (wait child-process)
-
-                    ; (channel->send sender 'eof)
-
-                    ; (wait child-process)
-                    )))
-
-  channels)
-
-(define (read-loop receiver)
-  (let ([message (channel->try-recv receiver)])
-    (cond
-      [(Ok? message)
-       (let ([inner-message (unwrap-ok message)])
-         ;; #false would mean we don't have anything to read
-         ;; on the channel, but the thread is not yet finished.
-         (when (string? inner-message)
-           (display inner-message))
-
-         (unless (equal? 'eof inner-message)
-
-           (time/sleep-ms 7)
-
-           (read-loop receiver)))
-
-       ; (if (thread-finished? (car *CHILD_THREADS*))
-       ; (read-loop receiver)
-
-       ; (displayln "finished")
-
-       ; (read-loop receiver))
-       ]
-      [else (displayln "finished")])))
-
-(define keep-alive #f)
-
-(define (main)
-
-  (define sender-and-receiver (message-passing-sub-process))
-
-  ;; If this gets dropped, it is game over
-  (define sender (list-ref sender-and-receiver 0))
-  (define receiver (list-ref sender-and-receiver 1))
-
-  (read-loop receiver)
-
-  (thread-join! (car *CHILD_THREADS*))
-
-  (displayln "finished"))
-
-(main)
diff --git a/cogs/threads/test-threads.scm b/cogs/threads/test-threads.scm
deleted file mode 100644
index 225050789..000000000
--- a/cogs/threads/test-threads.scm
+++ /dev/null
@@ -1,25 +0,0 @@
-(require-builtin steel/time)
-(require "steel/result")
-
-(require "steel/tests/unit-test.scm"
-         (for-syntax "steel/tests/unit-test.scm")
-         "threads.scm")
-
-(provide __module__)
-
-(define __module__ 'thread-test-module)
-
-(define (spawn-concurrent-tasks)
-
-  (let ([tasks (map (lambda (_)
-                      (spawn-thread! (lambda ()
-                                       (time/sleep-ms 2000)
-                                       (stdout-simple-displayln (thread::current/id)))))
-                    (range 0 10))])
-    (map (lambda (x) (thread-join! x)) tasks)))
-
-; (error "HELLO WORLD")
-
-(test-module
- "Basic threads works"
- (check-equal? "spawn-threads" (spawn-concurrent-tasks) (map (lambda (x) void) (range 0 10))))
diff --git a/cogs/threads/threads.scm b/cogs/threads/threads.scm
deleted file mode 100644
index 9b44443b7..000000000
--- a/cogs/threads/threads.scm
+++ /dev/null
@@ -1,52 +0,0 @@
-(require-builtin steel/time)
-(require "steel/result")
-
-(provide spawn-cancellable-thread-looping)
-
-;; Spawns a thread, returning a handle to the sender to that thread.
-; (define (message-passing)
-;   (define channels (make-channels))
-;   (define sender (list-ref channels 0))
-;   (define receiver (list-ref channels 1))
-
-;   ;; Worker thread, listen to requests
-;   (spawn-thread! (lambda ()
-;                    ;; Process incoming requests.
-;                    (while #true (displayln (channel->recv receiver)))
-;                    (loop)))
-
-; sender)
-
-(define *CHILD_THREADS* '())
-
-;; Keep track of all of the threads currently running
-(define (record-thread-handle handle)
-  (set! *CHILD_THREADS* (cons handle *CHILD_THREADS*)))
-
-(struct CancellableThreadHandle (sender handle))
-
-;;@doc
-;; Spawn a function, func, that runs on a background thread, running at the interval `delay-ms`
-(define (spawn-cancellable-thread-looping func delay-ms)
-  ;; Create the channels. We're going to cancel the thread using
-  ;; the sender here to interrupt the receiver
-  (define channels (make-channels))
-  (define sender (list-ref channels 0))
-  (define receiver (list-ref channels 1))
-
-  (CancellableThreadHandle sender
-                           (spawn-thread! (lambda ()
-                                            (while (not (~> (channel->try-recv receiver) (unwrap-ok)))
-                                                   (begin
-                                                     (func)
-                                                     (time/sleep-ms delay-ms)))
-                                            (stdout-simple-displayln "Shutting down thread: "
-                                                                     (thread::current/id))))))
-
-; (let ([tasks (map (lambda (_)
-;                     (spawn-thread! (lambda ()
-;                                      (time/sleep-ms 2000)
-;                                      (displayln (thread::current/id))
-;                                      1)))
-;                   (range 0 10))])
-;   (displayln (map thread-join! tasks)))
diff --git a/cogs/time/cog.scm b/cogs/time/cog.scm
deleted file mode 100644
index d820e62d8..000000000
--- a/cogs/time/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/time)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '())
\ No newline at end of file
diff --git a/cogs/time/time.scm b/cogs/time/time.scm
deleted file mode 100644
index 94fe73d04..000000000
--- a/cogs/time/time.scm
+++ /dev/null
@@ -1,21 +0,0 @@
-(require-builtin steel/time)
-(provide (for-syntax time!))
-
-
-(define (instant/elapsed->string t)
-    (~> t
-        (instant/elapsed)
-        (duration->string)))
-
-(define-syntax time! 
-    (syntax-rules ()
-        [(time! expr)
-         (let ((t (instant/now))
-               (result expr))
-
-            (display (quote expr)) (display " took ")
-            (displayln (instant/elapsed->string t))
-            result)]))
-
-
-
diff --git a/cogs/transducers/cog.scm b/cogs/transducers/cog.scm
deleted file mode 100644
index d02fb1e87..000000000
--- a/cogs/transducers/cog.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define package-name 'steel/transducers)
-(define version "0.1.0")
-
-;; Core library, requires no dependencies
-(define dependencies '(steel/tests))
\ No newline at end of file
diff --git a/cogs/transducers/transducers.scm b/cogs/transducers/transducers.scm
deleted file mode 100644
index b12925499..000000000
--- a/cogs/transducers/transducers.scm
+++ /dev/null
@@ -1,554 +0,0 @@
-(require "steel/tests/unit-test.scm"
-         (for-syntax "steel/tests/unit-test.scm"))
-
-(provide list-transduce
-         tmap
-         tfilter
-         tflatten
-         tdelete-neighbor-duplicates
-         tenumerate
-         tlog
-         tadd-between
-         ttake
-         ttake-while
-         tconcatenate
-         rcons
-         reverse-rcons)
-
-;; A reduced value is stops the transduction.
-; (define-record-type <reduced>
-;   (reduced val)
-;   reduced?
-;   (val unreduce))
-
-(struct reduced (val))
-
-(define unreduce reduced-val)
-
-;; helper function which ensures x is reduced.
-(define (ensure-reduced x)
-  (if (reduced? x) x (reduced x)))
-
-;; helper function that wraps a reduced value twice since reducing functions (like list-reduce)
-;; unwraps them. tconcatenate is a good example: it re-uses it's reducer on it's input using list-reduce.
-;; If that reduction finishes early and returns a reduced value, list-reduce would "unreduce"
-;; that value and try to continue the transducing process.
-(define (preserving-reduced reducer)
-  (lambda (a b) (let ([return (reducer a b)]) (if (reduced? return) (reduced return) return))))
-
-;; Rewrite list-reduce to abuse some internal optimizations
-;; if v is in the tail position, then it will be the last used
-(define (list-reduce2 f identity lst v)
-  (cond
-    [(null? lst) identity]
-    [(reduced? v) (unreduce v)]
-    [else (list-reduce2 f v (cdr lst) (f identity (car lst)))]))
-
-;; TODO: Original implementation here
-;; This is where the magic tofu is cooked
-(define (list-reduce f identity lst)
-  (if (null? lst)
-      identity
-      (%plain-let ((v (f identity (car lst))))
-                  (if (reduced? v) (unreduce v) (list-reduce f v (cdr lst))))))
-
-(define (test-map func lst accum)
-  (if (empty? lst) (reverse accum) (test-map func (cdr lst) (cons (func (car lst)) accum))))
-
-;; TODO: Come back to this when there is a better understanding
-;; of how to implement let loop
-(define (vector-reduce f identity vec)
-  (let ([len (vector-length vec)])
-    (let loop ([i 0] [acc identity])
-      (if (= i len)
-          acc
-          (let ([acc (f acc (vector-ref vec i))])
-            (if (reduced? acc) (unreduce acc) (loop (+ i 1) acc)))))))
-
-; (define (string-reduce f identity str)
-;   (let ((len (string-length str)))
-;     (let loop ((i 0) (acc identity))
-;       (if (= i len)
-;           acc
-;           (let ((acc (f acc (string-ref str i))))
-;             (if (reduced? acc)
-;                 (unreduce acc)
-;                 (loop (+ i 1) acc)))))))
-
-; (define (bytevector-u8-reduce f identity vec)
-;   (let ((len (bytevector-length vec)))
-;     (let loop ((i 0) (acc identity))
-;       (if (= i len)
-;           acc
-;           (let ((acc (f acc (bytevector-u8-ref vec i))))
-;             (if (reduced? acc)
-;                 (unreduce acc)
-;                 (loop (+ i 1) acc)))))))
-
-; (define (port-reduce f identity reader port)
-;   (let loop ((val (reader port)) (acc identity))
-;     (if (eof-object? val)
-;         acc
-;         (let ((acc (f acc val)))
-;           (if (reduced? acc)
-;               (unreduce acc)
-;               (loop (reader port) acc))))))
-
-; (define (generator-reduce f identity gen)
-;   (let loop ((val (gen)) (acc identity))
-;     (if (eof-object? val)
-;         acc
-;         (let ((acc (f acc val)))
-;           (if (reduced? acc)
-;               (unreduce acc)
-;               (loop (gen) acc))))))
-
-;; A special value to be used as a placeholder where no value has been set and #f
-;; doesn't cut it. Not exported, and not really needed.
-; (define-record-type <nothing>
-;   (make-nothing)
-;   nothing?)
-
-(struct <Nothing> ())
-
-(define nothing (<Nothing>))
-(define nothing? <Nothing>?)
-
-;; helper function which ensures x is reduced.
-; (define (ensure-reduced x)
-;   (if (reduced? x) x (reduced x)))
-
-;; helper function that wraps a reduced value twice since reducing functions (like list-reduce)
-;; unwraps them. tconcatenate is a good example: it re-uses it's reducer on it's input using list-reduce.
-;; If that reduction finishes early and returns a reduced value, list-reduce would "unreduce"
-;; that value and try to continue the transducing process.
-; (define (preserving-reduced f)
-;   (lambda (a b) (let ([return (f a b)]) (if (reduced? return) (reduced return) return))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Reducing functions meant to be used at the end at the transducing
-;; process.    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-;;@doc
-;; A transducer-friendly cons with the empty list as identity
-;; This function accepts multiple arguments:
-;;   * 0 arguments, returns the empty list as the identity
-;;   * 1 argument, a list, returns the reverse of that list
-;;   * 2 arguments, a list and the element, then returns a new list with the element consed to the list
-;;
-;; Used to build up a list during a transduction:
-;; ```scheme
-;; (list-transduce (tfilter odd?) rcons (list 1 2 3 4)) ;; => '(1 3)
-;; ```
-(define rcons
-  (case-lambda
-    [() '()]
-    [(lst) (reverse lst)]
-    [(lst x) (cons x lst)]))
-
-;;@doc
-;; A transducer-friendly cons with the empty list as identity. Acts like rcons, however will reverse
-;; the resulting list.
-;;
-;; This function accepts multiple arguments:
-;;   * 0 arguments, returns the empty list as the identity
-;;   * 1 argument, a list, returns that list
-;;   * 2 arguments, a list and the element, then returns a new list with the element consed to the list
-;;
-;; Used to build up a list during a transduction:
-;; ```scheme
-;; (list-transduce (tfilter odd?) rcons (list 1 2 3 4)) ;; => '(3 1)
-;; ```
-(define reverse-rcons
-  (case-lambda
-    [() '()]
-    [(lst) lst]
-    [(lst x) (cons x lst)]))
-
-;;@doc
-;; Use this as the f in transduce to count the amount of elements passed through.
-;;
-;; ```scheme
-;; (list-transduce (tfilter odd?) tcount (list 1 2 3)) ;; => 2
-;; ```
-(define rcount
-  (case-lambda
-    [() 0]
-    [(result) result]
-    [(result input) (+ 1 result)]))
-
-;;@doc
-;; These two take a predicate and returns reducing functions that behave
-;; like any and every from srfi-1
-(define (rany pred)
-  (case-lambda
-    [() #f]
-    [(result) result]
-    [(result input) (let ([test (pred input)]) (if test (reduced test) #f))]))
-
-(define (revery pred)
-  (case-lambda
-    [() #t]
-    [(result) result]
-    [(result input) (let ([test (pred input)]) (if (and result test) test (reduced #f)))]))
-
-(define list-transduce
-  (case-lambda
-    [(xform f coll) (list-transduce xform f (f) coll)]
-    [(xform f init coll) (let* ([xf (xform f)] [result (list-reduce xf init coll)]) (xf result))]))
-
-(define vector-transduce
-  (case-lambda
-    [(xform f coll) (vector-transduce xform f (f) coll)]
-    [(xform f init coll) (let* ([xf (xform f)] [result (vector-reduce xf init coll)]) (xf result))]))
-
-; (define string-transduce
-;   (case-lambda
-;     ((xform f coll)
-;      (string-transduce xform f (f) coll))
-;     ((xform f init coll)
-;      (let* ((xf (xform f))
-;             (result (string-reduce xf init coll)))
-;        (xf result)))))
-
-; (define bytevector-u8-transduce
-;   (case-lambda
-;     ((xform f coll)
-;      (bytevector-u8-transduce xform f (f) coll))
-;     ((xform f init coll)
-;      (let* ((xf (xform f))
-;             (result (bytevector-u8-reduce xf init coll)))
-;        (xf result)))))
-
-; (define port-transduce
-;   (case-lambda
-;     ((xform f by)
-;      (generator-transduce xform f by))
-;     ((xform f by port)
-;      (port-transduce xform f (f) by port))
-;     ((xform f init by port)
-;      (let* ((xf (xform f))
-;             (result (port-reduce xf init by port)))
-;        (xf result)))))
-
-; (define generator-transduce
-;   (case-lambda
-;     ((xform f gen)
-;      (generator-transduce xform f (f) gen))
-;     ((xform f init gen)
-;      (let* ((xf (xform f))
-;             (result (generator-reduce xf init gen)))
-;        (xf result)))))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;; Transducers!    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(define (tmap f)
-  (lambda (reducer)
-    (case-lambda
-      [() (reducer)]
-      [(result) (reducer result)]
-      [(result input) (reducer result (f input))])))
-
-(define (tfilter pred)
-  (lambda (reducer)
-    (case-lambda
-      [() (reducer)]
-      [(result) (reducer result)]
-      [(result input) (if (pred input) (reducer result input) result)])))
-
-(define (tremove pred)
-  (lambda (reducer)
-    (case-lambda
-      [() (reducer)]
-      [(result) (reducer result)]
-      [(result input) (if (not (pred input)) (reducer result input) result)])))
-
-; (define (tfilter-map f)
-;   (compose (tmap f) (tfilter values)))
-
-; (define (make-replacer map)
-;   (cond
-;    ((list? map)
-;     (lambda (x)
-;       (let ((replacer? (assoc x map)))
-;         (if replacer?
-;             (cdr replacer?)
-;             x))))
-;    ((hash-table? map)
-;     (lambda (x)
-;       (hash-table-ref/default map x x)))
-;    ((procedure? map) map)
-;    (else
-;     (error "Unsupported mapping in treplace" map))))
-
-; (define (treplace map)
-;   (tmap (make-replacer map)))
-
-; (define (tdrop n)
-;   (lambda (reducer)
-;     (let ((new-n (+ 1 n)))
-;       (case-lambda
-;         (() (reducer))
-;         ((result) (reducer result))
-;         ((result input)
-;          (set! new-n (- new-n 1))
-;          (if (positive? new-n)
-;              result
-;              (reducer result input)))))))
-
-; (define (tdrop-while pred)
-;   (lambda (reducer)
-;     (let ((drop? #t))
-;       (case-lambda
-;         (() (reducer))
-;         ((result) (reducer result))
-;         ((result input)
-;          (if (and (pred input) drop?)
-;              result
-;              (begin
-;                (set! drop? #f)
-;                (reducer result input))))))))
-
-(define (ttake n)
-  (define (positive? x)
-    (> x 0))
-  (lambda (reducer)
-    ;; we need to reset new-n for every new transduction
-    (let ([new-n n])
-      (case-lambda
-        [() (reducer)]
-        [(result) (reducer result)]
-        [(result input)
-         (let ([result (if (positive? new-n) (reducer result input) result)])
-           (set! new-n (- new-n 1))
-           (if (not (positive? new-n)) (ensure-reduced result) result))]))))
-
-(define ttake-while
-  (case-lambda
-    [(pred) (ttake-while pred (lambda (result input) result))]
-    [(pred retf)
-     (lambda (reducer)
-       (let ([take? #t])
-         (case-lambda
-           [() (reducer)]
-           [(result) (reducer result)]
-           [(result input)
-            (if (and take? (pred input))
-                (reducer result input)
-                (begin
-                  (set! take? #f)
-                  (ensure-reduced (retf result input))))])))]))
-
-(define (tconcatenate reducer)
-  (let ([preserving-reducer (preserving-reduced reducer)])
-    (case-lambda
-      [() (reducer)]
-      [(result) (reducer result)]
-      [(result input) (list-reduce preserving-reducer result input)])))
-
-; (define (tappend-map f)
-;   (compose (tmap f) tconcatenate))
-
-;;@doc
-;; Flattens everything and passes each value through the reducer
-;;
-;; ```scheme
-;; (list-transduce tflatten rcons (list 1 2 (list 3 4 '(5 6) 7 8))) ;; => (1 2 3 4 5 6 7 8)
-;; ```
-(define tflatten
-  (lambda (reducer)
-    (case-lambda
-      [() '()]
-      [(result) (reducer result)]
-      [(result input)
-       (if (list? input)
-           (list-reduce (preserving-reduced (tflatten reducer)) result input)
-           (reducer result input))])))
-
-;;@doc
-;; removes duplicate consecutive elements
-(define tdelete-neighbor-duplicates
-  (case-lambda
-    [() (tdelete-neighbor-duplicates equal?)]
-    [(equality-pred?)
-     (lambda (reducer)
-       (let ([prev nothing])
-         (case-lambda
-           [() (reducer)]
-           [(result) (reducer result)]
-           [(result input)
-            (if (equality-pred? prev input)
-                result
-                (begin
-                  (set! prev input)
-                  (reducer result input)))])))]))
-
-;; Deletes all duplicates that passes through.
-; (define tdelete-duplicates
-;   (case-lambda
-;     (() (tdelete-duplicates equal?))
-;     ((equality-pred?)
-;      (lambda (reducer)
-;        (let ((already-seen (make-hash-table equality-pred?)))
-;          (case-lambda
-;            (() (reducer))
-;            ((result) (reducer result))
-;            ((result input)
-;             (if (hash-table-exists? already-seen input)
-;                 result
-;                 (begin
-;                   (hash-table-set! already-seen input #t)
-;                   (reducer result input))))))))))
-
-;; Partitions the input into lists of N items. If the input stops it flushes whatever
-;; it has collected, which may be shorter than n.
-; (define (tsegment n)
-;   (if (not (and (integer? n) (positive? n)))
-;       (error "argument to tsegment must be a positive integer")
-;       (lambda (reducer)
-;         (let ((i 0)
-;               (collect (make-vector n)))
-;           (case-lambda
-;             (() (reducer))
-;             ((result)
-;              ;; if there is anything collected when we are asked to quit
-;              ;; we flush it to the remaining transducers
-;              (let ((result
-;                     (if (zero? i)
-;                         result
-;                         (reducer result (vector->list collect 0 i)))))
-;                (set! i 0)
-;                ;; now finally, pass it downstreams
-;                (if (reduced? result)
-;                    (reducer (unreduce result))
-;                    (reducer result))))
-;             ((result input)
-;              (vector-set! collect i input)
-;              (set! i (+ i 1))
-;              ;; If we have collected enough input we can pass it on downstream
-;              (if (< i n)
-;                  result
-;                  (let ((next-input (vector->list collect 0 i)))
-;                    (set! i 0)
-;                    (reducer result next-input)))))))))
-
-; (define (tpartition f)
-;   (lambda (reducer)
-;     (let* ((prev nothing)
-;            (collect '()))
-;       (case-lambda
-;         (() (reducer))
-;         ((result)
-;          (let ((result
-;                 (if (null? collect)
-;                     result
-;                     (reducer result (reverse! collect)))))
-;            (set! collect '())
-;            (if (reduced? result)
-;                (reducer (unreduce result))
-;                (reducer result))))
-;         ((result input)
-;          (let ((fout (f input)))
-;            (cond
-;             ((or (equal? fout prev) (nothing? prev)) ; collect
-;              (set! prev fout)
-;              (set! collect (cons input collect))
-;              result)
-;             (else ; flush what we collected already to the reducer
-;              (let ((next-input  (reverse! collect)))
-;                (set! prev fout)
-;                (set! collect (list input))
-;                (reducer result next-input))))))))))
-
-;;@doc
-;; Interposes element between each value pushed through the transduction.
-(define (tadd-between elem)
-  (lambda (reducer)
-    (let ([send-elem? #f])
-      (case-lambda
-        [() (reducer)]
-        [(result) (reducer result)]
-        [(result input)
-         (if send-elem?
-             (let ([result (reducer result elem)])
-               (if (reduced? result) result (reducer result input)))
-             (begin
-               (set! send-elem? #t)
-               (reducer result input)))]))))
-
-;;@doc
-;; indexes every value passed through in a cons pair as in (index . value). By default starts at 0
-(define tenumerate
-  (case-lambda
-    [() (tenumerate 0)]
-    [(n)
-     (lambda (reducer)
-       (let ([n n])
-         (case-lambda
-           [() (reducer)]
-           [(result) (reducer result)]
-           [(result input)
-            (let ([input (list n input)])
-              (set! n (+ n 1))
-              (reducer result input))])))]))
-
-(define tlog
-  (case-lambda
-    [() (tlog (lambda (result input) (displayln input)))]
-    [(log-function)
-     (lambda (reducer)
-       (case-lambda
-         [() (reducer)]
-         [(result) (reducer result)]
-         [(result input)
-          (log-function result input)
-          (reducer result input)]))]))
-
-;; rcons here seems to be... slow
-;; investigate tmap or rcons and see why / how its used with the input
-; (list-transduce (tmap (lambda (x) (+ x 1))) rcons (list 0 1 2 3))
-
-; (list-transduce (tfilter even?) rcons (list 0 1 2 3 4 5))
-
-; (list-transduce tflatten rcons (list 1 2 (list 3 4 '(5 6) 7 8)))
-
-; (list-transduce (tdelete-neighbor-duplicates) rcons (list 1 1 2 2 3 3 4 4))
-
-; (list-transduce (tenumerate) rcons (list 1 1 2 2 3 3 4 4))
-
-; (list-transduce (tadd-between 10) rcons (list 1 2 3 4 5))
-
-; (list-transduce (ttake 4) rcons (list 1 2 3 4 5 6 7 8 9 10))
-
-; (list-transduce (ttake-while even?) rcons (list 2 4 6 8 9 10))
-
-; (list-transduce tconcatenate rcons '((10 20) (30 40) (50 60)))
-
-(test-module
- "transducers tests"
- (check-equal? "tmap with basic addition and rcons"
-               (list-transduce (tmap (lambda (x) (+ x 1))) rcons (list 0 1 2 3))
-               (list 1 2 3 4))
- (check-equal? "tfilter with a basic predicate"
-               (list-transduce (tfilter even?) rcons (list 0 1 2 3 4 5))
-               (list 0 2 4))
- (check-equal? "tflatten basic flattening"
-               (list-transduce tflatten rcons (list 1 2 (list 3 4 '(5 6) 7 8)))
-               (list 1 2 3 4 5 6 7 8))
- (check-equal? "tdelete-neighbor-duplicates"
-               (list-transduce (tdelete-neighbor-duplicates) rcons (list 1 1 2 2 3 3 4 4))
-               (list 1 2 3 4))
- (check-equal? "tenumerate"
-               (list-transduce (tenumerate) rcons (list 1 1 2 2 3 3 4 4))
-               '((0 1) (1 1) (2 2) (3 2) (4 3) (5 3) (6 4) (7 4)))
- (check-equal? "tadd-between"
-               (list-transduce (tadd-between 10) rcons (list 1 2 3 4 5))
-               '(1 10 2 10 3 10 4 10 5))
- (check-equal? "ttake" (list-transduce (ttake 4) rcons (list 1 2 3 4 5 6 7 8 9 10)) (list 1 2 3 4))
- (check-equal? "ttake-while"
-               (list-transduce (ttake-while even?) rcons (list 2 4 6 8 9 10))
-               (list 2 4 6 8))
- (check-equal? "tconcatenate"
-               (list-transduce tconcatenate rcons '((10 20) (30 40) (50 60)))
-               '(10 20 30 40 50 60)))
diff --git a/core/contracts.rkt b/core/contracts.rkt
deleted file mode 100644
index e860315d7..000000000
--- a/core/contracts.rkt
+++ /dev/null
@@ -1,42 +0,0 @@
-; (provide
-;     listof </c >/c <=/c >=/c any/c and/c or/c)
-
-; ;; Contract combinators
-; (define (listof pred)
-;         (lambda (lst)
-;             (define (loop lst)
-;                 (cond [(null? lst) #t]
-;                       [(pred (car lst)) (loop (cdr lst))]
-;                       [else #f]))
-;             (cond [(null? lst) #t]
-;                   [(list? lst)
-;                     (loop lst)]
-;                   [else #f])))
-
-; ;; Contracts for <
-; (define (</c n)
-;     (make/c (fn (x) (< x n)) (list '</c n)))
-
-; ;; Contracts for >
-; (define (>/c n)
-;     (make/c (fn (x) (> x n)) (list '>/c n)))
-
-; ;; Contracts for <=
-; (define (<=/c n)
-;     (make/c (fn (x) (<= x n)) (list '<=/c n)))
-
-; ;; Contracts for >=
-; (define (>=/c n)
-;     (make/c (fn (x) (>= x n)) (list '>=/c n)))
-
-; ;; Satisfies any single value
-; (define (any/c x)
-;     (make/c (fn (x) #t) 'any/c))
-
-; ;; produces a function compatible with contract definitions
-; (define (and/c x y)
-;     (lambda (z) (and (x z) (y z))))
-
-; ;; produces a function compatible with contract definitions
-; (define (or/c x y)
-;     (lambda (z) (or (x z) (y z))))
diff --git a/core/display.rkt b/core/display.rkt
deleted file mode 100644
index e3ea38f19..000000000
--- a/core/display.rkt
+++ /dev/null
@@ -1,22 +0,0 @@
-(provide println)
-
-(define println simple-displayln)
-
-; (define/contract (struct-name s)
-;   (->/c custom-struct? symbol?)
-;   (mut-vector-ref s 1))
-
-; (define/contract (struct-transparent? s)
-;   (->/c custom-struct? boolean?)
-;   (hash-try-get (mut-vector-ref s 2) ':transparent))
-
-; (define (println x)
-;   (displayln 
-;     (if (custom-struct? x)
-;       (if (struct-transparent? x)
-;           (cons (struct-name x) (transduce x (into-list)))
-;           (string-append "#<"
-;                         (string-append
-;                           (symbol->string (struct-name x))
-;                         ">")))
-;       x)))
diff --git a/core/prelude.rkt b/core/prelude.rkt
deleted file mode 100644
index 556779413..000000000
--- a/core/prelude.rkt
+++ /dev/null
@@ -1,138 +0,0 @@
-(provide
-    caar cadr cdar cddr caaar caadr cadar caddr cdaar cdadr cddar cdddr caaaar caadar caaddr cadaar 
-    cadadr caddar cadddr cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr id flip curry curry2
-    not foldl map foldr unfold fold reduce max min empty? mem-helper member assoc filter even-rec? 
-    odd-rec? sum add1 sub1 zero? take drop slice)
-
-(define caar (lambda (pair) (car (car pair))))
-(define cadr (lambda (pair) (car (cdr pair))))
-(define cdar (lambda (pair) (cdr (car pair))))
-(define cddr (lambda (pair) (cdr (cdr pair))))
-(define caaar (lambda (pair) (car (car (car pair)))))
-(define caadr (lambda (pair) (car (car (cdr pair)))))
-(define cadar (lambda (pair) (car (cdr (car pair)))))
-(define caddr (lambda (pair) (car (cdr (cdr pair)))))
-(define cdaar (lambda (pair) (cdr (car (car pair)))))
-(define cdadr (lambda (pair) (cdr (car (cdr pair)))))
-(define cddar (lambda (pair) (cdr (cdr (car pair)))))
-(define cdddr (lambda (pair) (cdr (cdr (cdr pair)))))
-(define caaaar (lambda (pair) (car (car (car (car pair))))))
-(define caaadr (lambda (pair) (car (car (car (cdr pair))))))
-(define caadar (lambda (pair) (car (car (cdr (car pair))))))
-(define caaddr (lambda (pair) (car (car (cdr (cdr pair))))))
-(define cadaar (lambda (pair) (car (cdr (car (car pair))))))
-(define cadadr (lambda (pair) (car (cdr (car (cdr pair))))))
-(define caddar (lambda (pair) (car (cdr (cdr (car pair))))))
-(define cadddr (lambda (pair) (car (cdr (cdr (cdr pair))))))
-(define cdaaar (lambda (pair) (cdr (car (car (car pair))))))
-(define cdaadr (lambda (pair) (cdr (car (car (cdr pair))))))
-(define cdadar (lambda (pair) (cdr (car (cdr (car pair))))))
-(define cdaddr (lambda (pair) (cdr (car (cdr (cdr pair))))))
-(define cddaar (lambda (pair) (cdr (cdr (car (car pair))))))
-(define cddadr (lambda (pair) (cdr (cdr (car (cdr pair))))))
-(define cdddar (lambda (pair) (cdr (cdr (cdr (car pair))))))
-(define cddddr (lambda (pair) (cdr (cdr (cdr (cdr pair))))))
-(define id (lambda (obj) obj))
-(define flip (lambda (func) (lambda (arg1 arg2) (func arg2 arg1))))
-(define curry (lambda (func arg1) (lambda (arg) (func arg1 arg))))
-(define curry2 (lambda (func arg1) (lambda (arg2 arg3) (func arg1 arg2 arg3))))
-
-
-(define (not a)
-  (if a
-      #f
-      #t))
-
-(define (foldl func accum lst)
-  (if (null? lst)
-      accum
-      (foldl func
-             (func (car lst) accum) ; here's the change
-             (cdr lst))))
-
-
-(define (map func lst)
-  (if (null? lst) 
-      '() 
-      (transduce lst (mapping func) (into-list))))
-
-
-(define foldr (lambda (func accum lst)
-                (if (null? lst)
-                    accum
-                    (func (car lst) (foldr func accum (cdr lst))))))
-
-
-
-(define unfold (lambda (func init pred)
-                 (if (pred init)
-                     (cons init '())
-                     (cons init (unfold func (func init) pred)))))
-
-(define fold (lambda (f a l) (foldl f a l)))
-(define reduce (lambda (f a l) (fold f a l)))
-(define max (lambda (x  num-list) (fold (lambda (y z) (if (> y z) y z)) x (cons 0 num-list))))
-(define min (lambda (x  num-list) (fold (lambda (y z) (if (< y z) y z)) x (cons 536870911 num-list))))
-
-(define empty? null?)
-
-(define mem-helper (lambda (pred op) (lambda (acc next) (if (and (not acc) (pred (op next))) next acc))))
-;; (define memq (lambda (obj lst)       (fold (mem-helper (curry eq? obj) id) #f lst)))
-;; (define memv (lambda (obj lst)       (fold (mem-helper (curry eqv? obj) id) #f lst)))
-(define member (lambda (obj lst)     (fold (mem-helper (curry equal? obj) id) #f lst)))
-
-;; TODO come back to this
-; (define assq (lambda (obj alist)     (fold (mem-helper (curry eq? obj) car) #f alist)))
-
-;; (define assv (lambda (obj alist)     (fold (mem-helper (curry eqv? obj) car) #f alist)))
-; (define assoc (lambda (obj alist)    (fold (mem-helper (curry equal? obj) car) #f alist)))
-
-; (define assoc )
-
-(define (assoc thing alist)
-   (if (null? alist)
-       #f
-       (if (equal? (car (car alist)) thing)
-           (car alist)
-           (assoc thing (cdr alist)))))
-
-
-(define (filter pred lst)
-  (if (empty? lst) 
-      '() 
-      (transduce lst (filtering pred) (into-list))))
-
-; (define (fact n)
-;   (define factorial-tail (lambda (n acc) 
-;                            (if (= n 0)
-;                                acc
-;                                (factorial-tail (- n 1)  (* acc n )))))
-;   (factorial-tail n 1))
-
-(define even-rec? (lambda (x) (if (= x 0) #t (odd-rec? (- x 1)))))
-(define odd-rec?  (lambda (x) (if (= x 0) #f (even-rec? (- x 1)))))
-
-(define sum (lambda (x) (reduce + 0 x)))
-;; (define head car)
-;; (define tail cdr)
-(define (add1 n) (+ 1 n))
-(define (sub1 n) (- n 1))
-(define (zero? n) (= n 0))
-
-;; currently broken, doesn't work properly
-(defn (take lst n)
-  (defn (loop x l acc)
-    (if (= x 0)
-        acc
-        (loop (- x 1) (cdr l) (cons (car l) acc))))
-  (loop n lst (list)))
-
-(define (drop lst n)
-  (define (loop x l)
-    (if (zero? x)
-        l
-        (loop (sub1 x) (cdr l))))
-  (loop n lst))
-
-(define (slice l offset n)
-  (take (drop l offset) n))
\ No newline at end of file
diff --git a/core/syntax.rkt b/core/syntax.rkt
deleted file mode 100644
index c7cd28326..000000000
--- a/core/syntax.rkt
+++ /dev/null
@@ -1,224 +0,0 @@
-(define-syntax steel/base
-  (syntax-rules ()
-    [(steel/base) 
-      (begin
-          (require-builtin steel/hash)
-          (require-builtin steel/sets)
-          (require-builtin steel/lists)
-          (require-builtin steel/strings)
-          (require-builtin steel/symbols)
-          (require-builtin steel/vectors)
-          (require-builtin steel/streams)
-          (require-builtin steel/contracts)
-          (require-builtin steel/identity)
-          (require-builtin steel/numbers)
-          (require-builtin steel/equality)
-          (require-builtin steel/ord)
-          (require-builtin steel/transducers)
-          (require-builtin steel/io)
-          (require-builtin steel/filesystem)
-          (require-builtin steel/ports)
-          (require-builtin steel/meta)
-          (require-builtin steel/json)
-          (require-builtin steel/constants)
-          (require-builtin steel/syntax))]))
-
-(define-syntax quasiquote
-  (syntax-rules (unquote unquote-splicing)
-    ((quasiquote (unquote x))                         x)
-    ((quasiquote ((unquote x) xs ...))          (cons x (quasiquote (xs ...))))
-    ((quasiquote ((unquote-splicing x)))        (append x '()))
-    ((quasiquote ((unquote-splicing x) xs ...)) (append x (quasiquote (xs ...))))
-    ((quasiquote (x xs ...))                   (cons (quasiquote x) (quasiquote (xs ...))))
-    ((quasiquote x)                           'x)))
-
-(define-syntax or
-  (syntax-rules ()
-    [(or) #f]
-    [(or x) x]
-    [(or x y) (let ([z x])
-                (if z z y))]
-    [(or x y ...) (or x (or y ...))]))
-
-(define-syntax and
-  (syntax-rules ()
-    [(and) #t]
-    [(and x) x]
-    [(and x y) (if x y #f)]
-    [(and x y ...) (and x (and y ...))]))
-
-(define-syntax when
-  (syntax-rules ()
-    [(when a b ...)
-     (if a (begin b ...) void)]))
-
-(define-syntax unless
-  (syntax-rules ()
-    [(unless a b ...)
-     (if a void (begin b ...))]))
-
-(define-syntax cond
-  (syntax-rules (else =>)
-    [(cond [else => e1 ...])
-     (begin e1 ...)]
-    [(cond [else e1 ...])
-     (begin e1 ...)]
-    [(cond [e1 e2 ...])
-     (when e1 e2 ...)]
-    [(cond [e1 => e2 ...] c1 ...)
-     (if e1
-         (begin e2 ...)
-         (cond c1 ...))]
-    [(cond [e1 e2 ...] c1 ...)
-     (if e1
-         (begin e2 ...)
-         (cond c1 ...))]))
-
-(define-syntax while
-  (syntax-rules (do)
-    [(while cond do body ...)
-     (begin
-       (define (loop)
-         (when cond
-           body ...
-           (loop)))
-       (loop))]
-    [(while cond body ...)
-     (begin (define (loop)
-              (when cond body ... (loop)))
-            (loop))]))
-
-;; TODO add the single argument case
-(define-syntax f>
-  (syntax-rules ()
-    [(f> fun args* ...)
-     (lambda (x) (fun x args* ...))]
-    [(f> fun) fun]))
-
-(define-syntax ->
-  (syntax-rules ()
-    [(-> a) a]
-    [(-> a (b c ...)) ((f> b c ...) a)]
-    [(-> a (b)) ((f> b) a)]
-    [(-> a b c ...) (-> (-> a b) c ...)]))
-
-(define-syntax l>
-  (syntax-rules ()
-    [(l> fun args* ...)
-     (lambda (x) (fun args* ... x))]
-    [(l> fun) fun]))
-
-(define-syntax ->>
-  (syntax-rules ()
-    [(->> a) a]
-    [(->> a (b c ...)) ((l> b c ...) a)]
-    [(->> a (b)) ((l> b) a)]
-    [(->> a b c ...) (->> (->> a b) c ...)]))
-
-(define-syntax swap
-  (syntax-rules ()
-    [(swap a b)
-     (let ([tmp b])
-       (begin
-         (set! b a)
-         (set! a tmp)))]))
-
-(define-syntax let*
-  (syntax-rules ()
-    ((let* () body ...) ; base case
-     ((lambda () body ...)))
-    ((let* ((var val) rest ...) body ...) ; binding case
-     ((lambda (var) (let* (rest ...) body ...)) val))))
-
-(define-syntax letrec*-helper
-  (syntax-rules ()
-    ((letrec*-helper () body ...)
-     (begin body ...))
-    ((letrec*-helper ((var val) rest ...) body ...)
-     (begin
-       (define var val)
-       (letrec*-helper (rest ...) body ...)))))
-
-(define-syntax letrec*
-  (syntax-rules ()
-    ((letrec* bindings body ...)
-     ((lambda ()
-        (letrec*-helper bindings body ...))))))
-
-(define-syntax ->/c
-  (syntax-rules ()
-    [(->/c r)
-     (make-function/c (make/c r 'r))]
-    [(->/c a b)
-     (make-function/c (make/c a 'a) (make/c b 'b))]
-    [(->/c a b c)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c))]
-    [(->/c a b c d)
-     (make-function/c (make/c a 'a) (make/c b 'b)
-                      (make/c c 'c) (make/c d 'd))]
-    [(->/c a b c d e)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e))]
-    [(->/c a b c d e f)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e) (make/c f 'f))]
-    [(->/c a b c d e f g)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e) (make/c f 'f)
-                      (make/c g 'g))]
-    [(->/c a b c d e f g h)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e) (make/c f 'f)
-                      (make/c g 'g) (make/c h 'h))]
-    [(->/c a b c d e f g h i)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e) (make/c f 'f)
-                      (make/c g 'g) (make/c h 'h) (make/c i 'i))]))
-
-;; Macro for basic usage of contracts
-(define-syntax define/contract
-  (syntax-rules ()
-    [(define/contract (name args ...)
-       contract
-       body ...)
-     (define name (bind/c contract (lambda (args ...) body ...) 'name))]
-    [(define/contract name contract expr)
-     (define name ((bind/c
-                      (make-function/c (make/c contract 'contract))
-                      (lambda () expr))))]))
-
-(define-syntax module
-    (syntax-rules (provide gen-defines contract/out) 
-        [(module name (provide ids ...) funcs ...)
-         (begin
-            (define (datum->syntax name) 
-                ((lambda () funcs ... 
-                (module provide ids ...))))
-            (module gen-defines name ids ...))]
-        
-        ;; in the contract case, ignore the contract in the hash
-        [(module provide (contract/out name contract)) (hash 'name name)]
-        ;; Normal case
-        [(module provide name) (hash 'name name)]
-
-        ;; in the contract case, ignore the contract in the hash
-        [(module provide (contract/out name contract) rest ...)
-         (hash-insert (module provide rest ...) 'name name)]
-
-        ;; Normal case
-        [(module provide name rest ...)
-         (hash-insert (module provide rest ...) 'name name)]
-
-        ;; Module contract provides
-        [(module gen-defines mod (contract/out name contract))
-         (define (datum->syntax name) (bind/c contract (hash-get mod 'name)))]
-        [(module gen-defines mod (contract/out name contract) rest ...)
-         (begin (define (datum->syntax name) (bind/c contract (hash-get mod 'name)))
-            (module gen-defines mod rest ...))]
-
-        ;; Normal provides
-        [(module gen-defines mod name) (define (datum->syntax name) (hash-get mod 'name))]
-        [(module gen-defines mod name rest ...)
-         (begin (define (datum->syntax name) (hash-get mod 'name))
-            (module gen-defines mod rest ...))]))
-
diff --git a/crates/cargo-steel-lib/Cargo.toml b/crates/cargo-steel-lib/Cargo.toml
deleted file mode 100644
index 960590fd6..000000000
--- a/crates/cargo-steel-lib/Cargo.toml
+++ /dev/null
@@ -1,9 +0,0 @@
-[package]
-name = "cargo-steel-lib"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-cargo_metadata = "0.15.3"
\ No newline at end of file
diff --git a/crates/cargo-steel-lib/src/main.rs b/crates/cargo-steel-lib/src/main.rs
deleted file mode 100644
index 4218ef837..000000000
--- a/crates/cargo-steel-lib/src/main.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-use std::{error::Error, path::PathBuf, process::Command};
-
-use cargo_metadata::{Message, MetadataCommand, Package};
-use std::process::Stdio;
-
-fn package_contains_dependency_on_steel(packages: &[Package]) -> Option<&Package> {
-    packages.iter().find(|x| x.name == "steel-core")
-}
-
-fn main() -> Result<(), Box<dyn Error>> {
-    // let build_target = Command::new("cargo")
-    //     .arg("build")
-    //     .arg("--release")
-    //     .spawn()?
-    //     .wait()?
-    //     .success();
-
-    let mut steel_home = PathBuf::from(std::env::var("STEEL_HOME")?);
-
-    steel_home.push("native");
-
-    let metadata = MetadataCommand::new().exec()?;
-
-    // println!("{:#?}", metadata?.root_package());
-
-    // let package_name = metadata?.root_package().expect("Missing cargo toml!").
-
-    let package = match metadata.root_package() {
-        Some(p) => p,
-        None => return Err("cargo steel-lib must be run from within a crate".into()),
-    };
-
-    println!("Attempting to install: {:#?}", package.name);
-
-    if package_contains_dependency_on_steel(&metadata.packages).is_none() {
-        return Err(
-            "Cannot install package as a steel dylib - does not contain a dependency on steel!"
-                .into(),
-        );
-    }
-
-    let mut command = Command::new("cargo")
-        .args([
-            "build",
-            "--release",
-            "--message-format=json-render-diagnostics",
-        ])
-        .stdout(Stdio::piped())
-        .spawn()
-        .unwrap();
-
-    let reader = std::io::BufReader::new(command.stdout.take().unwrap());
-    let last = cargo_metadata::Message::parse_stream(reader)
-        .filter_map(|x| {
-            if let Ok(Message::CompilerArtifact(artifact)) = x {
-                Some(artifact)
-            } else {
-                None
-            }
-        })
-        .last()
-        .unwrap();
-
-    if last.target.kind == ["cdylib"] {
-        println!("Found a cdylib!");
-        // println!("{:#?}", last);
-
-        for file in last.filenames {
-            let filename = file.file_name().unwrap();
-
-            steel_home.push(filename);
-
-            println!("Copying {} to {}", file, &steel_home.to_str().unwrap());
-
-            std::fs::copy(file, &steel_home).unwrap();
-
-            steel_home.pop();
-        }
-    } else if last.target.kind == ["dylib"] {
-        println!("Found a dylib!");
-        // println!("{:#?}", last);
-
-        for file in last.filenames {
-            let filename = file.file_name().unwrap();
-
-            steel_home.push(filename);
-
-            println!("Copying {} to {}", file, &steel_home.to_str().unwrap());
-
-            std::fs::copy(file, &steel_home).unwrap();
-
-            steel_home.pop();
-        }
-    }
-
-    println!("Done!");
-
-    command.wait().expect("Couldn't get cargo's exit status");
-
-    Ok(())
-}
diff --git a/crates/steel-core/.gitignore b/crates/steel-core/.gitignore
deleted file mode 100644
index 53eaa2196..000000000
--- a/crates/steel-core/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-/target
-**/*.rs.bk
diff --git a/crates/steel-core/Cargo.toml b/crates/steel-core/Cargo.toml
deleted file mode 100644
index cfb07bde5..000000000
--- a/crates/steel-core/Cargo.toml
+++ /dev/null
@@ -1,93 +0,0 @@
-[package]
-name = "steel-core"
-# version = "0.4.0"
-version.workspace = true
-authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
-edition = "2021"
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/mattwparas/steel"
-description = "Core compiler and VM implementation for steel"
-
-
-[lib]
-name = "steel"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-[dependencies]
-im-rc = "15.1.0"
-codespan-reporting = "0.11.1"
-log = "0.4.17"
-
-futures-util = "0.3.28"
-futures-task = "0.3.28"
-
-serde_json = "1.0.108"
-serde = { version = "1.0.193", features = ["derive", "rc"] }
-serde_derive = "1.0.193"
-bincode = "1.3.3"
-pretty = "0.12.1"
-im-lists = "0.6.0"
-quickscope = "0.2.0"
-lasso = { version = "0.7.2", features = ["multi-threaded", "serialize"] }
-once_cell = "1.18.0"
-fxhash = "0.2.1"
-# lazy_static = "1.4.0"
-steel-gen = { path = "../steel-gen", version = "0.2.0" }
-steel-parser = { path = "../steel-parser", version = "0.4.0" }
-steel-derive = { path = "../steel-derive", version = "0.4.0" }
-chrono = { version = "0.4.23", default-features = false, features = ["std", "clock"] }
-weak-table = "0.3.2"
-# TODO: Consider whether rand needs to be here
-rand = "0.8.5"
-# TODO: Consider only depending on the sub crate
-num = "0.4.0"
-which = "4.4.0"
-radix_fmt = "1.0.0"
-
-# For structs
-smallvec = { version = "1.10.0", optional = true }
-
-# Pretty printing documentation
-termimad = { version = "0.21.0", optional = true }
-
-# FFI for dylibs
-abi_stable = { version = "0.11.2", optional = true }
-async-ffi = { version = "0.5.0", features = ["abi_stable"], optional = true }
-# Cranelift JIT
-cranelift = { version = "0.84.0", optional = true }
-cranelift-module = { version = "0.84.0", optional = true }
-cranelift-jit = { version = "0.84.0", optional = true }
-
-# Embedded dependencies for various popular libraries
-rusqlite =  { version = "0.28.0", features = ["bundled"], optional = true }
-reqwest = { version = "0.11.14", features = ["blocking", "json"], optional = true }
-url = { version = "2.3.1", optional = true }
-anyhow = { version = "1", optional = true }
-
-[dev-dependencies]
-proptest = "1.1.0"
-criterion = "0.5.1"
-env_logger = "0.10.0"
-
-[build-dependencies]
-steel-gen = { path = "../steel-gen", version = "0.2.0" }
-
-[features]
-default = ["modules"]
-modules = []
-jit = ["dep:cranelift", "dep:cranelift-module", "dep:cranelift-jit"]
-dynamic = []
-profiling = []
-web = ["dep:reqwest", "dep:url"]
-sqlite = ["dep:rusqlite"]
-unsafe-internals = []
-anyhow = ["dep:anyhow"]
-dylibs = ["dep:abi_stable", "dep:async-ffi"]
-markdown = ["dep:termimad"]
-smallvec = ["dep:smallvec"]
-without-drop-protection = []
-
-[[bench]]
-name = "my_benchmark"
-harness = false
-
diff --git a/crates/steel-core/benches/my_benchmark.rs b/crates/steel-core/benches/my_benchmark.rs
deleted file mode 100644
index 285c76d6f..000000000
--- a/crates/steel-core/benches/my_benchmark.rs
+++ /dev/null
@@ -1,334 +0,0 @@
-#![allow(unused)]
-
-use criterion::{black_box, criterion_group, criterion_main, Criterion};
-
-use steel::stdlib::PRELUDE;
-use steel::steel_vm::{engine::Engine, register_fn::RegisterFn};
-
-fn benchmark_template(c: &mut Criterion, name: &str, script: &str, warmup: &str) {
-    let mut vm = Engine::new();
-    vm.compile_and_run_raw_program(PRELUDE).unwrap();
-    vm.compile_and_run_raw_program(black_box(warmup)).unwrap();
-
-    let program = vm.emit_raw_program_no_path(script).unwrap();
-    let executable = vm.raw_program_to_executable(program).unwrap();
-
-    c.bench_function(name, |b| b.iter(|| vm.run_executable(&executable)));
-}
-
-fn range(c: &mut Criterion) {
-    let script = "(range 0 5000)";
-
-    let mut vm = Engine::new();
-
-    vm.compile_and_run_raw_program(PRELUDE).unwrap();
-
-    let program = vm.emit_raw_program_no_path(script).unwrap();
-    let executable = vm.raw_program_to_executable(program).unwrap();
-
-    c.bench_function("range-big", |b| b.iter(|| vm.run_executable(&executable)));
-}
-
-fn map(c: &mut Criterion) {
-    let script = "(map a lst)";
-    let warmup = "(define lst (range 0 5000)) (define a (lambda (a) 0))";
-    benchmark_template(c, "map-big", script, warmup);
-}
-
-fn transducer_map(c: &mut Criterion) {
-    let script = "(transduce lst a (into-list))";
-    let warmup = "(define lst (range 0 10000)) (define a (mapping (lambda (a) (* a 2))))";
-    benchmark_template(c, "transducer-map", script, warmup);
-}
-
-fn filter(c: &mut Criterion) {
-    let script = "(filter number? lst)";
-    let warmup = "(define lst (range 0 5000))";
-    benchmark_template(c, "filter-big", script, warmup);
-}
-
-fn multiple_transducers(c: &mut Criterion) {
-    let warmup = "(define lst (range 0 50000))";
-    let script = r#"
-        (transduce lst (compose
-                    (mapping (fn (x) (* x 2)))
-                    (filtering even?)
-                    (mapping (fn (x) (+ x 25)))
-                    (taking 25000)
-                    (taking 25))
-                    (into-list))
-    "#;
-    benchmark_template(c, "multiple-transducers", script, warmup);
-}
-
-fn ackermann(c: &mut Criterion) {
-    let warmup = r#"
-    (define (ackermann m n)
-        (cond [(equal? m 0) (+ n 1)]
-            [(equal? n 0) (ackermann (- m 1) 1)]
-            [else (ackermann (- m 1) (ackermann m (- n 1)))]))"#;
-    let script = r#"(ackermann 3 3)"#;
-    benchmark_template(c, "ackermann-3-3", script, warmup);
-}
-
-fn ten_thousand_iterations(c: &mut Criterion) {
-    let script = "(test 0)";
-    let warmup = "(define test (lambda (x) (if (= x 10000) x (test (+ x 1)))))";
-    benchmark_template(c, "ten-thousand-iterations", script, warmup);
-}
-
-fn ten_thousand_iterations_letrec(c: &mut Criterion) {
-    let script = "(test)";
-    let warmup = r#"(define (test)
-                            (let ((loop void))
-                                (let ((loop-prime (lambda (x) 
-                                                    (if (= x 10000)
-                                                        x
-                                                        (loop (+ x 1))))))
-                                    (set! loop loop-prime))
-                            (loop 0)))"#;
-
-    benchmark_template(c, "ten-thousand-iterations-letrec", script, warmup);
-}
-
-fn trie_sort(c: &mut Criterion) {
-    let mut vm = Engine::new();
-    // vm.compile_and_run_raw_program(PRELUDE).unwrap();
-    vm.compile_and_run_raw_program(steel::stdlib::TRIESORT)
-        .unwrap();
-
-    let warmup = "(define lst
-        (list
-         \"suppose\"
-         \"believe\"
-         \"changeable\"
-         \"absent\"
-         \"busy\"
-         \"float\"
-         \"debonair\"
-         \"throat\"
-         \"grey\"
-         \"use\"
-         \"measure\"
-         \"van\"
-         \"thirsty\"
-         \"notify\"
-         \"star\"))";
-
-    vm.compile_and_run_raw_program(black_box(warmup)).unwrap();
-
-    let script = "(trie-sort lst)";
-
-    let program = vm.emit_raw_program_no_path(script).unwrap();
-    let executable = vm.raw_program_to_executable(program).unwrap();
-
-    c.bench_function("trie-sort-without-optimizations", |b| {
-        b.iter(|| vm.run_executable(&executable))
-    });
-}
-
-fn fib_28(c: &mut Criterion) {
-    // std::env::set_var("CODE_GEN_V2", "true");
-
-    let mut vm = Engine::new();
-    // vm.compile_and_run_raw_program(PRELUDE).unwrap();
-    vm.compile_and_run_raw_program(
-        "(define (fib n) (if (<= n 2) 1 (+ (fib (- n 1)) (fib (- n 2)))))",
-    )
-    .unwrap();
-
-    let script = "(fib 28)";
-    let program = vm.emit_raw_program_no_path(script).unwrap();
-    let executable = vm.raw_program_to_executable(program).unwrap();
-
-    let mut group = c.benchmark_group("fib-28");
-    group.sample_size(200);
-    group.bench_function("fib-28", |b| b.iter(|| vm.run_executable(&executable)));
-    group.finish();
-}
-
-fn thread_creation(c: &mut Criterion) {
-    let mut vm = Engine::new();
-    vm.compile_and_run_raw_program(
-        r#"
-(define (foo x)
-  (vector 10 20 30 40 x))
-
-(define (block)
-    (thread-join! (spawn-thread! (lambda () (vector-ref (foo 100) 4))))) 
-"#,
-    )
-    .unwrap();
-
-    let script = "(block)";
-    let program = vm.emit_raw_program_no_path(script).unwrap();
-    let executable = vm.raw_program_to_executable(program).unwrap();
-
-    let mut group = c.benchmark_group("thread-creation");
-    // group.sample_size(200);
-    group.bench_function("thread-creation", |b| {
-        b.iter(|| vm.run_executable(&executable))
-    });
-    group.finish();
-}
-
-fn fib_28_contract(c: &mut Criterion) {
-    let mut vm = Engine::new();
-    vm.compile_and_run_raw_program(PRELUDE).unwrap();
-    vm.compile_and_run_raw_program(
-        r#"(define/contract (fib n) 
-                (->/c integer? integer?)
-                (if (<= n 2) 1 (+ (fib (- n 1)) (fib (- n 2)))))"#,
-    )
-    .unwrap();
-
-    let script = "(fib 28)";
-    let program = vm.emit_raw_program_no_path(script).unwrap();
-    let executable = vm.raw_program_to_executable(program).unwrap();
-
-    let mut group = c.benchmark_group("contract-fib-28");
-    group.sample_size(200);
-    group.bench_function("contract-fib-28", |b| {
-        b.iter(|| vm.run_executable(&executable))
-    });
-    group.finish();
-}
-
-// This will include the definition inside the bench
-// just to match against the Rhai benchmarks
-// fn fib_20(c: &mut Criterion) {
-//     let mut vm = Engine::new();
-//     vm.compile_and_run_raw_program(PRELUDE).unwrap();
-
-//     let script = "(define (fib n) (if (<= n 2) 1 (+ (fib (- n 1)) (fib (- n 2))))) (fib 20)";
-
-//     let program = vm.emit_raw_program_no_path(&script).unwrap();
-//     let executable = vm.raw_program_to_executable(program).unwrap();
-
-//     c.bench_function("fib-20", |b| {
-//         b.iter(|| {
-//             vm.execute(Rc::clone(&definition), &constant_map).unwrap();
-//             vm.execute(Rc::clone(&bytecode), &constant_map)
-//         })
-//     });
-// }
-
-fn engine_creation(c: &mut Criterion) {
-    c.bench_function("engine-creation", |b| b.iter(Engine::new));
-}
-
-fn register_function(c: &mut Criterion) {
-    let mut vm = Engine::new();
-    let f: fn(usize, usize) -> usize = |a: usize, b: usize| a + b;
-    let name: &'static str = "addition";
-    c.bench_function("register-fn", |b| {
-        b.iter(|| {
-            let _ = vm.register_fn(name, f);
-        })
-    });
-}
-
-fn binary_trees(c: &mut Criterion) {
-    let mut vm = Engine::new();
-    vm.compile_and_run_raw_program(
-        r#"
-
-; #lang racket/base
-
-;;; The Computer Language Benchmarks Game
-;;; https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
-
-;;; Derived from the Chicken variant by Sven Hartrumpf
-;;; contributed by Matthew Flatt
-;;; *reset*
-
-; (require racket/cmdline)
-
-(struct node (left val right))
-
-;; Instead of (define-struct leaf (val)):
-(define (leaf val)
-  (node #f val #f))
-(define (leaf? l)
-  (not (node-left l)))
-(define (leaf-val l)
-  node-val)
-
-(define (make item d)
-  (if (= d 0)
-      (leaf item)
-      (%plain-let ((item2 (* item 2)) (d2 (- d 1)))
-                  (node (make (- item2 1) d2) item (make item2 d2)))))
-
-(define (check t)
-  (if (leaf? t) 1 (+ 1 (+ (check (node-left t)) (check (node-right t))))))
-
-(define (iterate n m d sum)
-  (if (equal? n m) sum (iterate (+ n 1) m d (+ sum (check (make n d))))))
-
-(define (max x y)
-  (if (> x y) x y))
-
-(define (loop d end max-depth min-depth)
-  (if (>= d end)
-      void
-      (begin
-        (let ([iterations (arithmetic-shift 1 (+ (- max-depth d) min-depth))])
-          (displayln iterations " trees of depth " d " check: " (iterate 0 iterations d 0)))
-        (loop (+ 2 d) end max-depth min-depth))))
-
-(define (main n)
-  (let* ([min-depth 4] [max-depth (max (+ min-depth 2) n)])
-    (let ([stretch-depth (+ max-depth 1)])
-      (displayln "stretch tree of depth " stretch-depth " check: " (check (make 0 stretch-depth))))
-    (let ([long-lived-tree (make 0 max-depth)])
-      ; (begin
-      ; (define end )
-
-      (loop 4 (add1 max-depth) max-depth min-depth)
-
-      ; )
-
-      (displayln "long lived tree of depth " max-depth " check: " (check long-lived-tree)))))
-
-            
-        "#,
-    )
-    .unwrap();
-
-    let script = "(main 12)";
-    let program = vm.emit_raw_program_no_path(script).unwrap();
-    let executable = vm.raw_program_to_executable(program).unwrap();
-
-    let mut group = c.benchmark_group("binary-trees");
-    group.bench_function("binary-trees", |b| {
-        b.iter(|| vm.run_executable(&executable))
-    });
-    group.finish();
-}
-
-criterion_group!(
-    benches,
-    range,
-    map,
-    transducer_map,
-    filter,
-    ten_thousand_iterations,
-    ten_thousand_iterations_letrec,
-    trie_sort,
-    fib_28,
-    thread_creation,
-    engine_creation,
-    register_function,
-    multiple_transducers,
-    binary_trees,
-    // fib_28_contract,
-    ackermann // trie_sort,
-              // merge_sort,
-              // struct_construct,
-              // struct_construct_bigger,
-              // struct_get,
-              // struct_set
-);
-
-criterion_main!(benches);
diff --git a/crates/steel-core/build.rs b/crates/steel-core/build.rs
deleted file mode 100644
index 939a6371f..000000000
--- a/crates/steel-core/build.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// build.rs
-
-fn main() {
-    #[cfg(feature = "dynamic")]
-    {
-        use std::env;
-        use std::fs;
-        use std::path::Path;
-
-        let out_dir = env::var_os("OUT_DIR").unwrap();
-        let dest_path = Path::new(&out_dir).join("generated.rs");
-
-        fs::write(dest_path, steel_gen::permutations::code_gen()).unwrap();
-
-        println!("cargo:rerun-if-changed=build.rs");
-    }
-}
diff --git a/crates/steel-core/proptest-regressions/parser/prop/mod.txt b/crates/steel-core/proptest-regressions/parser/prop/mod.txt
deleted file mode 100644
index 64ad00871..000000000
--- a/crates/steel-core/proptest-regressions/parser/prop/mod.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-# Seeds for failure cases proptest has generated in the past. It is
-# automatically read and these particular cases re-run before any
-# novel cases are generated.
-#
-# It is recommended to check this file in to source control so that
-# everyone who runs the test benefits from these saved cases.
-cc ba3b075e91322e3a6e4878469f37d211442105338985ca85c3cb156b4ab55a29 # shrinks to expr = If(If { test_expr: If(If { test_expr: Atom(Atom { syn: SyntaxObject { ty: IntegerLiteral(-872414935), span: 0..0 } }), then_expr: Atom(Atom { syn: SyntaxObject { ty: IntegerLiteral(-6578869408395709287), span: 0..0 } }), else_expr: Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral('*'), span: 0..0 } }), location: SyntaxObject { ty: If, span: 0..0 } }), then_expr: Atom(Atom { syn: SyntaxObject { ty: IntegerLiteral(-5947150424354642015), span: 0..0 } }), else_expr: Define(Define { name: Atom(Atom { syn: SyntaxObject { ty: Identifier("\"เ🂨\\*ퟡ´.:{𞋌ȺࡒæTנּଏ<Ѩ\u{10eac}"), span: 0..0 } }), body: List(List { args: [] }), location: SyntaxObject { ty: Define, span: 0..0 } }), location: SyntaxObject { ty: If, span: 0..0 } })
-cc 6b6adf8a923572bb82a42c4ddf33909eae18c658502a8b8958d53d2031c0cb5d # shrinks to expr = Define(Define { name: Atom(Atom { syn: SyntaxObject { ty: Identifier(""), span: 0..0 } }), body: List(List { args: [] }), location: SyntaxObject { ty: Define, span: 0..0 } })
-cc b028dc7dfaf0d7ca9df1f64d35838bfc3407e1f224caa4606d300fb6a57ec0eb # shrinks to expr = Begin(Begin { exprs: [], location: SyntaxObject { ty: Begin, span: 0..0 } })
-cc 3d322ed8345904bf0c0af3c68dabd7befa587b545c2ff80461a0afe428cc13bc # shrinks to expr = Define(Define { name: Atom(Atom { syn: SyntaxObject { ty: Identifier("%"), span: 0..0 } }), body: List(List { args: [Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral('\t'), span: 0..0 } })] }), location: SyntaxObject { ty: Define, span: 0..0 } })
-cc d15757be8c5d41a904a9d8f77f3d688f29a77017272ed014ac40aa99584fcb2d # shrinks to expr = List(List { args: [Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral('\u{b}'), span: 0..0 } })] })
-cc 116ff47f68040a770afb3636206ddb98bde9136e5002e56d53a0f982d7cad00b # shrinks to expr = Define(Define { name: Atom(Atom { syn: SyntaxObject { ty: Identifier("a"), span: 0..0 } }), body: List(List { args: [Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral(')'), span: 0..0 } })] }), location: SyntaxObject { ty: Define, span: 0..0 } })
-cc 2c4a70561f7d1499463c242766fc24ba7324882b8e32dab9353b0dbe37bee274 # shrinks to expr = If(If { test_expr: Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral('¡'), span: 0..0 } }), then_expr: Quote(Quote { expr: List(List { args: [] }), location: SyntaxObject { ty: Quote, span: 0..0 } }), else_expr: Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral(' '), span: 0..0 } }), location: SyntaxObject { ty: If, span: 0..0 } })
-cc 57a7a2bb7057027666f1e06b2372fe6c74d2b1404b57ef484c03a03526b78ce3 # shrinks to expr = Define(Define { name: Atom(Atom { syn: SyntaxObject { ty: Identifier("A"), span: 0..0 } }), body: List(List { args: [List(List { args: [Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral('\u{a0}'), span: 0..0 } })] })] }), location: SyntaxObject { ty: Define, span: 0..0 } })
-cc 2d1240d5e780d1d7b07ff30fd590d4cc93e5559e2950d43c1c36d337eb687e75 # shrinks to expr = Define(Define { name: Atom(Atom { syn: SyntaxObject { ty: Identifier("🤌"), span: 0..0 } }), body: List(List { args: [If(If { test_expr: Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral('^'), span: 0..0 } }), then_expr: Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral('\u{0}'), span: 0..0 } }), else_expr: Atom(Atom { syn: SyntaxObject { ty: CharacterLiteral('¡'), span: 0..0 } }), location: SyntaxObject { ty: If, span: 0..0 } })] }), location: SyntaxObject { ty: Define, span: 0..0 } })
diff --git a/crates/steel-core/src/boot/bootstrap.bin b/crates/steel-core/src/boot/bootstrap.bin
deleted file mode 100644
index d2ef982dc..000000000
Binary files a/crates/steel-core/src/boot/bootstrap.bin and /dev/null differ
diff --git a/crates/steel-core/src/compiler/code_gen.rs b/crates/steel-core/src/compiler/code_gen.rs
deleted file mode 100644
index a80d16fb3..000000000
--- a/crates/steel-core/src/compiler/code_gen.rs
+++ /dev/null
@@ -1,1090 +0,0 @@
-use std::sync::atomic::AtomicUsize;
-
-use steel_parser::tokens::MaybeBigInt;
-
-use crate::{
-    compiler::passes::analysis::IdentifierStatus::{
-        Captured, Free, Global, HeapAllocated, LetVar, Local, LocallyDefinedFunction,
-    },
-    core::{
-        instructions::Instruction,
-        labels::{resolve_labels, LabeledInstruction},
-        opcode::OpCode,
-    },
-    parser::{
-        ast::{Atom, ExprKind, List},
-        parser::SyntaxObject,
-        span_visitor::get_span,
-        tokens::TokenType,
-        visitors::VisitorMut,
-    },
-    rvals::IntoSteelVal,
-    stop, SteelVal,
-};
-
-use super::{
-    constants::ConstantMap,
-    passes::analysis::{
-        Analysis,
-        CallKind::{Normal, SelfTailCall, TailCall},
-    },
-};
-
-use crate::rvals::Result;
-
-// TODO: Have this interner also be a part of what gets saved...
-pub(crate) static FUNCTION_ID: AtomicUsize = AtomicUsize::new(0);
-
-fn fresh_function_id() -> usize {
-    // println!("{:?}", FUNCTION_ID);
-    FUNCTION_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
-}
-
-pub struct CodeGenerator<'a> {
-    pub(crate) instructions: Vec<LabeledInstruction>,
-    constant_map: &'a mut ConstantMap,
-    analysis: &'a Analysis,
-    local_count: Vec<usize>,
-}
-
-fn eval_atom(t: &SyntaxObject) -> Result<SteelVal> {
-    match &t.ty {
-        TokenType::BooleanLiteral(b) => Ok((*b).into()),
-        TokenType::NumberLiteral(n) => Ok(SteelVal::NumV(*n)),
-        TokenType::StringLiteral(s) => Ok(SteelVal::StringV(s.into())),
-        TokenType::CharacterLiteral(c) => Ok(SteelVal::CharV(*c)),
-        TokenType::IntegerLiteral(steel_parser::tokens::MaybeBigInt::Small(n)) => {
-            Ok(SteelVal::IntV(*n))
-        }
-        TokenType::IntegerLiteral(MaybeBigInt::Big(b)) => b.clone().into_steelval(),
-        // TODO: Keywords shouldn't be misused as an expression - only in function calls are keywords allowed
-        TokenType::Keyword(k) => Ok(SteelVal::SymbolV(k.clone().into())),
-        what => {
-            // println!("getting here in the eval_atom - code_gen");
-            stop!(UnexpectedToken => what; t.span)
-        }
-    }
-}
-
-fn try_eval_atom(t: &SyntaxObject) -> Option<SteelVal> {
-    match &t.ty {
-        TokenType::BooleanLiteral(b) => Some((*b).into()),
-        // TokenType::Identifier(s) => env.borrow().lookup(&s),
-        TokenType::NumberLiteral(n) => Some(SteelVal::NumV(*n)),
-        TokenType::StringLiteral(s) => Some(SteelVal::StringV(s.into())),
-        TokenType::CharacterLiteral(c) => Some(SteelVal::CharV(*c)),
-        TokenType::IntegerLiteral(steel_parser::tokens::MaybeBigInt::Small(n)) => {
-            Some(SteelVal::IntV(*n))
-        }
-        // TODO: Keywords shouldn't be misused as an expression - only in function calls are keywords allowed
-        TokenType::Keyword(k) => Some(SteelVal::SymbolV(k.clone().into())),
-        _what => {
-            // println!("getting here in the eval_atom - code_gen");
-            // stop!(UnexpectedToken => what; t.span)
-
-            return None;
-        }
-    }
-}
-
-impl<'a> CodeGenerator<'a> {
-    pub fn new(constant_map: &'a mut ConstantMap, analysis: &'a Analysis) -> Self {
-        CodeGenerator {
-            instructions: Vec::new(),
-            constant_map,
-            analysis,
-            local_count: Vec::new(),
-        }
-    }
-
-    pub fn top_level_compile(mut self, expr: &ExprKind) -> Result<Vec<Instruction>> {
-        self.visit(expr)?;
-        self.instructions
-            .push(LabeledInstruction::builder(OpCode::POPPURE));
-
-        Ok(resolve_labels(self.instructions))
-    }
-
-    fn push(&mut self, instr: LabeledInstruction) {
-        self.instructions.push(instr);
-    }
-
-    fn len(&self) -> usize {
-        self.instructions.len()
-    }
-
-    fn specialize_constant(&mut self, syn: &SyntaxObject) -> Result<()> {
-        let value = eval_atom(syn)?;
-
-        let idx = self.constant_map.add_or_get(value);
-        self.push(
-            LabeledInstruction::builder(OpCode::PUSHCONST)
-                .payload(idx)
-                .contents(syn.clone())
-                .constant(true),
-        );
-        Ok(())
-    }
-
-    fn specialize_immediate(&self, l: &List) -> Option<OpCode> {
-        if l.args.len() == 3 {
-            let function = l.first()?;
-
-            let _ = l.args[1].atom_identifier()?;
-            let _ = eval_atom(l.args[2].atom_syntax_object()?).ok()?;
-
-            if let Some(info) = self.analysis.get(function.atom_syntax_object()?) {
-                if info.kind == Free || info.kind == Global {
-                    return match function.atom_identifier().unwrap().resolve() {
-                        "+" => Some(OpCode::ADDIMMEDIATE),
-                        "-" => Some(OpCode::SUBIMMEDIATE),
-                        "<=" => Some(OpCode::LTEIMMEDIATE),
-                        _ => None,
-                    };
-                }
-            }
-        }
-
-        None
-    }
-
-    fn should_specialize_call(&self, l: &List) -> Option<OpCode> {
-        if l.args.len() == 3 {
-            let function = l.first()?;
-
-            let _ = l.args[1].atom_identifier()?;
-            let _ = eval_atom(l.args[2].atom_syntax_object()?).ok()?;
-
-            if let Some(info) = self.analysis.get(function.atom_syntax_object()?) {
-                if info.kind == Free || info.kind == Global {
-                    return match function.atom_identifier().unwrap().resolve() {
-                        "+" => Some(OpCode::ADDREGISTER),
-                        "-" => Some(OpCode::SUBREGISTER),
-                        "<=" => Some(OpCode::LTEREGISTER),
-                        _ => None,
-                    };
-                }
-            }
-        }
-
-        None
-    }
-
-    fn specialize_immediate_call(&mut self, l: &List, op: OpCode) -> Option<()> {
-        // let value = eval_atom(l.args[2].atom_syntax_object().unwrap())?;
-
-        if l.args.len() != 3 {
-            return None;
-        }
-
-        let value = if let Some(TokenType::IntegerLiteral(MaybeBigInt::Small(l))) =
-            l.args[2].atom_syntax_object().map(|x| &x.ty)
-        {
-            *l
-        } else {
-            return None;
-            // stop!()
-        };
-
-        if value < 0 {
-            return None;
-        }
-
-        // if let Some(analysis) = &l.args[1]
-        //     .atom_syntax_object()
-        //     .and_then(|a| self.analysis.get(a))
-        // {
-        //     if let Some(offset) = analysis.stack_offset {
-        //         self.push(LabeledInstruction::builder(op).payload(offset));
-        //     } else {
-        //         stop!(Generic => "Missing stack offset!");
-        //     }
-        // } else {
-        //     panic!("Shouldn't be happening")
-        // }
-
-        let analysis = &l.args[1]
-            .atom_syntax_object()
-            .and_then(|a| self.analysis.get(a))?;
-
-        let offset = analysis.stack_offset?;
-
-        self.push(LabeledInstruction::builder(op).payload(offset));
-
-        // let idx = self.constant_map.add_or_get(value);
-
-        self.push(LabeledInstruction::builder(OpCode::PASS).payload(value as usize));
-
-        Some(())
-    }
-
-    #[allow(unused)]
-    fn specialize_call(&mut self, l: &List, op: OpCode) -> Option<()> {
-        if l.args.len() != 3 {
-            return None;
-        }
-
-        let value = try_eval_atom(l.args[2].atom_syntax_object().unwrap())?;
-
-        // Specialize SUB1 -> specializing here is a bit much but it should help
-        // if value == SteelVal::IntV(1) && op == OpCode::SUBREGISTER {
-        //     self.push(LabeledInstruction::builder(OpCode::SUBREGISTER1));
-
-        //     if let Some(analysis) = &l.args[1]
-        //         .atom_syntax_object()
-        //         .and_then(|a| self.analysis.get(&a))
-        //     {
-        //         self.push(
-        //             LabeledInstruction::builder(OpCode::PASS)
-        //                 .payload(analysis.stack_offset.unwrap()),
-        //         );
-        //     } else {
-        //         panic!("Shouldn't be happening")
-        //     }
-
-        //     return Ok(());
-        // }
-
-        let analysis = &l.args[1]
-            .atom_syntax_object()
-            .and_then(|a| self.analysis.get(a))?;
-
-        let offset = analysis.stack_offset?;
-
-        self.push(LabeledInstruction::builder(op).payload(offset));
-
-        // if let Some(analysis) =
-        // {
-        //     if let Some(offset) = analysis.stack_offset {
-        //         self.push(LabeledInstruction::builder(op).payload(offset));
-        //     } else {
-        //         return None;
-        //     }
-        // } else {
-        //     panic!("Shouldn't be happening")
-        // }
-
-        // local variable, map to index:
-        // if let ExprKind::Atom(a) = &l.args[1] {
-        //     if let Some(analysis) = self.analysis.get(&a.syn) {
-        //         self.push(
-        //             LabeledInstruction::builder(OpCode::PASS)
-        //                 .payload(analysis.stack_offset.unwrap()),
-        //         );
-        //     } else {
-        //         panic!("Shouldn't be getting here")
-        //     }
-        // } else {
-        //     panic!("Shouldn't be getting here")
-        // }
-
-        let idx = self.constant_map.add_or_get(value);
-
-        // println!("Index: {:?}", idx);
-
-        self.push(LabeledInstruction::builder(OpCode::PASS).payload(idx));
-
-        Some(())
-
-        // Ok(())
-    }
-}
-
-impl<'a> VisitorMut for CodeGenerator<'a> {
-    type Output = Result<()>;
-
-    // TODO come back later and resolve this properly using labels
-    // If looks like label resolution needs to be able to arbitrarily point to a label one
-    // instruction after
-    fn visit_if(&mut self, f: &crate::parser::ast::If) -> Self::Output {
-        // load in the test condition
-        self.visit(&f.test_expr)?;
-        // Get the if index
-        let if_idx = self.instructions.len();
-        // push in if
-        self.push(LabeledInstruction::builder(OpCode::IF).payload(self.instructions.len() + 2));
-        // save spot of jump instruction, fill in after
-        // let idx = self.len();
-        // self.push(Instruction::new_jmp(0)); // dummy value
-
-        // emit instructions for then
-        self.visit(&f.then_expr)?;
-        self.push(LabeledInstruction::builder(OpCode::JMP));
-        let false_start = self.len();
-
-        // emit instructions for else expression
-        self.visit(&f.else_expr)?;
-        let j3 = self.len(); // first instruction after else
-
-        // println!("false_start: {:?}", false_start);
-        // println!("j3: {:?}", j3);
-
-        // // set index of jump instruction
-        // if let Some(elem) = self.instructions.get_mut(idx) {
-        //     (*elem).payload_size = false_start;
-        // } else {
-        //     stop!(Generic => "out of bounds jump");
-        // }
-
-        // if let Some(potential_pop_instr) = self.instructions.get(j3 - 1) {
-        //     if potential_pop_instr.op_code == OpCode::POPPURE {
-        //         println!("Found a pop instruction: {:?}", potential_pop_instr);
-        //     }
-        // }
-
-        if let Some(elem) = self.instructions.get_mut(false_start - 1) {
-            elem.payload_size = j3;
-            // (*elem).payload_size = false_start;
-        } else {
-            stop!(Generic => "out of bounds jump");
-        }
-
-        if let Some(elem) = self.instructions.get_mut(if_idx) {
-            elem.payload_size = false_start;
-            // (*elem).payload_size = false_start;
-        } else {
-            stop!(Generic => "out of bounds jump");
-        }
-
-        Ok(())
-
-        // self.visit(&f.test_expr)?;
-
-        // let if_idx = self.instructions.len();
-
-        // self.push(LabeledInstruction::builder(OpCode::IF).payload(self.instructions.len() + 2));
-
-        // self.visit(&f.then_expr)?;
-
-        // let false_start_label = fresh();
-        // let j3_label = fresh();
-
-        // self.push(LabeledInstruction::builder(OpCode::JMP).goto(j3_label));
-
-        // let false_start = self.len(); // index after the jump
-
-        // // self.instructions
-        // //     .last_mut()
-        // //     .unwrap()
-        // //     .set_tag(false_start_label);
-
-        // self.visit(&f.else_expr)?;
-
-        // self.instructions.last_mut().unwrap().set_tag(j3_label);
-
-        // // if let Some(elem) = self.instructions.get_mut(false_start - 1) {
-        // //     // (*elem).goto = Some(j3);
-
-        // //     elem.set_goto(j3_label);
-
-        // //     // (*elem).payload_size = false_start;
-        // // } else {
-        // //     stop!(Generic => "out of bounds jump");
-        // // }
-
-        // if let Some(elem) = self.instructions.get_mut(if_idx) {
-        //     // (*elem).goto = Some(false_start_label);
-
-        //     elem.set_goto(false_start_label);
-
-        //     // (*elem).payload_size = false_start;
-        // } else {
-        //     stop!(Generic => "out of bounds jump");
-        // }
-
-        // Ok(())
-    }
-
-    fn visit_define(&mut self, define: &crate::parser::ast::Define) -> Self::Output {
-        // let sidx = self.len();
-
-        if let ExprKind::Atom(name) = &define.name {
-            self.push(LabeledInstruction::builder(OpCode::SDEF).contents(name.syn.clone()));
-
-            self.visit(&define.body)?;
-
-            // let defn_body_size = self.len() - sidx;
-
-            // TODO: Consider whether SDEF and EDEF are even necessary at all
-            // Just remove them otherwise
-            self.push(LabeledInstruction::builder(OpCode::EDEF));
-
-            // if let Some(elem) = self.instructions.get_mut(sidx) {
-            //     (*elem).payload_size = defn_body_size;
-            // } else {
-            //     stop!(Generic => "out of bounds closure len");
-            // }
-
-            // println!("binding global: {}", name);
-            self.push(LabeledInstruction::builder(OpCode::BIND).contents(name.syn.clone()));
-
-            self.push(LabeledInstruction::builder(OpCode::VOID));
-        } else {
-            panic!(
-                "Complex defines not supported in bytecode generation: {}",
-                define.name
-            )
-        }
-
-        Ok(())
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        lambda_function: &crate::parser::ast::LambdaFunction,
-    ) -> Self::Output {
-        let idx = self.len();
-
-        // Grab the function information from the analysis - this is going to tell us what the captured
-        // vars are, and subsequently how to compile the let for this use case
-        let function_info = self
-            .analysis
-            .function_info
-            .get(&lambda_function.syntax_object_id)
-            .unwrap();
-
-        // Distinguishing between a pure function and a non pure function will enable
-        // thinner code for the resulting function
-        let op_code = if function_info.captured_vars().is_empty() {
-            OpCode::PUREFUNC
-        } else {
-            OpCode::NEWSCLOSURE
-        };
-
-        // Attach the debug symbols here
-        self.push(LabeledInstruction::builder(op_code).contents(lambda_function.location.clone()));
-        self.push(
-            LabeledInstruction::builder(OpCode::PASS).payload(usize::from(lambda_function.rest)),
-        );
-
-        let arity = lambda_function.args.len();
-
-        // Patching over the changes, see old code generator for more information
-        // TODO: This is not a portable change. Syntax Object IDs need to have a patched unique ID
-        // This should be doable by supplementing everything with an offset when consuming external modules
-        // self.push(
-        //     LabeledInstruction::builder(OpCode::PASS).payload(lambda_function.syntax_object_id),
-        // );
-
-        self.push(LabeledInstruction::builder(OpCode::PASS).payload(fresh_function_id()));
-
-        // Save how many locals we have, for when we hit lets
-        self.local_count.push(arity);
-
-        let mut body_instructions = {
-            let mut code_gen = CodeGenerator::new(self.constant_map, self.analysis);
-            code_gen.visit(&lambda_function.body)?;
-            code_gen.instructions
-        };
-
-        // In the event we actually have a closure, we need to add the necessarily
-        // boilerplate to lift out closed over variables since they could escape
-        if op_code == OpCode::NEWSCLOSURE {
-            // Mark the upvalues here
-            self.push(
-                LabeledInstruction::builder(OpCode::NDEFS)
-                    .payload(function_info.captured_vars().len()),
-            );
-
-            let mut vars = function_info.captured_vars().iter().collect::<Vec<_>>();
-
-            vars.sort_by_key(|x| x.1.id);
-
-            // vars.sort_by_key(|x| x.stack_offset);
-
-            // Here we're going to explicitly capture from either the enclosing scope
-            // or the stack. For example:
-            //
-            // (lambda (x)
-            //      (lambda (y)
-            //            (+ x y)))
-            //
-            // The inner lambda here will capture x from the stack, since that
-            // is the environment in which it was immediately available.
-            // Whereas:
-            //
-            // (lambda (x)
-            //      (lambda (y)
-            //            (lambda (z)
-            //                   (+ x y z))))
-            //
-            // The innermost lambda is going to have to capture x and y from the closure above it,
-            // where they've already been captured.
-            //
-            // This way, at closure construction (in the VM) we can immediately patch in the kind
-            // of closure that we want to create, and where to get it
-            for (key, var) in vars {
-                // If we're patching in from the enclosing, check to see if this is a heap allocated var that
-                // we need to patch in to the current scope
-                if var.captured_from_enclosing {
-                    if var.mutated {
-                        self.push(
-                            LabeledInstruction::builder(OpCode::COPYHEAPCAPTURECLOSURE)
-                                .payload(var.parent_heap_offset.unwrap())
-                                .contents(SyntaxObject::default(TokenType::Identifier(*key))),
-                        );
-                    } else {
-                        // In this case we're gonna patch in the variable from the current captured scope
-                        self.push(
-                            LabeledInstruction::builder(OpCode::COPYCAPTURECLOSURE)
-                                .payload(var.capture_offset.unwrap())
-                                .contents(SyntaxObject::default(TokenType::Identifier(*key))),
-                        );
-                    }
-                } else if var.mutated {
-                    self.push(
-                        LabeledInstruction::builder(OpCode::FIRSTCOPYHEAPCAPTURECLOSURE)
-                            .payload(var.heap_offset.unwrap())
-                            .contents(SyntaxObject::default(TokenType::Identifier(*key))),
-                    );
-                } else {
-                    // In this case, it hasn't yet been captured, so we'll just capture
-                    // directly from the stack
-                    self.push(
-                        LabeledInstruction::builder(OpCode::COPYCAPTURESTACK)
-                            .payload(var.stack_offset.unwrap())
-                            .contents(SyntaxObject::default(TokenType::Identifier(*key))),
-                    );
-                }
-            }
-        }
-
-        let pop_op_code = OpCode::POPPURE;
-
-        // Elide the POPN if the POPPURE will take care of it
-        if let Some(x) = body_instructions.last_mut() {
-            if x.op_code == OpCode::POPN {
-                x.op_code = OpCode::PASS;
-            }
-        }
-
-        body_instructions
-            .push(LabeledInstruction::builder(pop_op_code).payload(lambda_function.args.len()));
-
-        // Load in the heap alloc instructions - on each invocation we can copy in to the current frame
-        {
-            let mut captured_mutable_arguments = function_info
-                .arguments()
-                .iter()
-                // .values()
-                .filter(|x| x.1.captured && x.1.mutated)
-                .collect::<Vec<_>>();
-
-            captured_mutable_arguments.sort_by_key(|x| x.1.stack_offset);
-
-            for (key, var) in captured_mutable_arguments {
-                self.push(
-                    LabeledInstruction::builder(OpCode::ALLOC)
-                        .payload(var.stack_offset.unwrap())
-                        .contents(SyntaxObject::default(TokenType::Identifier(*key))),
-                );
-            }
-        }
-
-        self.instructions.append(&mut body_instructions);
-
-        // pop off the local variables from the run time stack, so we don't have them
-
-        let closure_body_size = self.len() - idx;
-        self.push(LabeledInstruction::builder(OpCode::ECLOSURE).payload(arity));
-
-        if let Some(elem) = self.instructions.get_mut(idx) {
-            elem.payload_size = closure_body_size;
-        } else {
-            stop!(Generic => "out of bounds closure len");
-        }
-
-        self.local_count.pop();
-
-        Ok(())
-    }
-
-    fn visit_begin(&mut self, begin: &crate::parser::ast::Begin) -> Self::Output {
-        if begin.exprs.is_empty() {
-            self.push(LabeledInstruction::builder(OpCode::VOID));
-            return Ok(());
-        }
-
-        let (last, elements) = begin.exprs.split_last().unwrap();
-
-        // Just insert a single pop value from stack
-        // when
-        // for expr in &begin.exprs {
-        //     self.visit(expr)?;
-        // }
-
-        for expr in elements {
-            self.visit(expr)?;
-            self.push(LabeledInstruction::builder(OpCode::POPSINGLE));
-        }
-
-        self.visit(last)?;
-
-        // if begin.exprs.len() > 1 {
-        //     self.push(LabeledInstruction::builder(OpCode::POPN).payload(begin.exprs.len() - 1));
-        // }
-
-        Ok(())
-    }
-
-    fn visit_return(&mut self, r: &crate::parser::ast::Return) -> Self::Output {
-        self.visit(&r.expr)?;
-        self.push(LabeledInstruction::builder(OpCode::POPPURE));
-        Ok(())
-    }
-
-    fn visit_quote(&mut self, quote: &crate::parser::ast::Quote) -> Self::Output {
-        let converted =
-            SteelVal::try_from(crate::parser::ast::ExprKind::Quote(Box::new(quote.clone())))?;
-
-        let idx = self.constant_map.add_or_get(converted);
-        self.push(
-            LabeledInstruction::builder(OpCode::PUSHCONST)
-                .payload(idx)
-                // TODO: This is a little suspect, we're doing a bunch of stuff twice
-                // that we really don't need. In fact, we probably can get away with just...
-                // embedding the steel val directly here.
-                .list_contents(crate::parser::ast::ExprKind::Quote(Box::new(quote.clone())))
-                .constant(true),
-        );
-
-        Ok(())
-    }
-
-    fn visit_macro(&mut self, m: &crate::parser::ast::Macro) -> Self::Output {
-        stop!(BadSyntax => format!("unexpected macro definition: {}", m); m.location.span)
-    }
-
-    fn visit_atom(&mut self, a: &crate::parser::ast::Atom) -> Self::Output {
-        if let Some(analysis) = self.analysis.get(&a.syn) {
-            let op_code = match (&analysis.kind, analysis.last_usage) {
-                (Global, _) => OpCode::PUSH,
-                (Local, true) | (LetVar, true) => OpCode::MOVEREADLOCAL,
-                // (Local, true) | (LetVar, true) => OpCode::READLOCAL,
-                (Local, false) | (LetVar, false) => OpCode::READLOCAL,
-
-                (LocallyDefinedFunction, _) => {
-                    stop!(Generic => "Unable to lower to bytecode: locally defined function should be lifted to an external scope")
-                }
-                // In the event we're captured, we're going to just read the
-                // offset from the captured var
-                (Captured, _) => OpCode::READCAPTURED,
-                (Free, _) => OpCode::PUSH,
-                (HeapAllocated, _) => OpCode::READALLOC,
-                // This is technically true, but in an incremental compilation mode, we assume the variable is already bound
-                // stop!(FreeIdentifier => format!("free identifier: {}", a); a.syn.span),
-            };
-
-            // println!("Atom: {}", a);
-            // println!("{:#?}", analysis);
-
-            let payload = match op_code {
-                OpCode::READCAPTURED => analysis.read_capture_offset.unwrap(),
-                OpCode::READALLOC => analysis.read_heap_offset.unwrap(),
-                _ => analysis.stack_offset.unwrap_or_default(),
-            };
-
-            self.push(
-                LabeledInstruction::builder(op_code)
-                    .payload(payload)
-                    .contents(a.syn.clone()),
-            );
-
-            Ok(())
-        } else {
-            self.specialize_constant(&a.syn)
-        }
-    }
-
-    // TODO: Specialize the calls to binops here
-    // This should be pretty straightforward - just check if they're still globals
-    // then, specialize accordingly.
-    fn visit_list(&mut self, l: &crate::parser::ast::List) -> Self::Output {
-        if let Some(op) = self.specialize_immediate(l) {
-            match self.specialize_immediate_call(l, op) {
-                Some(r) => return Ok(r),
-                None => {}
-            }
-        } else if let Some(op) = self.should_specialize_call(l) {
-            match self.specialize_call(l, op) {
-                Some(r) => return Ok(r),
-                None => {}
-            }
-        }
-
-        if l.args.is_empty() {
-            stop!(BadSyntax => "function application empty");
-        }
-
-        let pop_len = if !l.args.is_empty() {
-            l.args[1..].len()
-        } else {
-            0
-        };
-
-        for expr in &l.args[1..] {
-            self.visit(expr)?;
-        }
-
-        // emit instructions for the func
-        self.visit(&l.args[0])?;
-
-        let contents = if let ExprKind::Atom(Atom { syn: s }) = &l.args[0] {
-            s.clone()
-        } else {
-            // TODO check span information here by coalescing the entire list
-            SyntaxObject::new(TokenType::Identifier("lambda".into()), get_span(&l.args[0]))
-        };
-
-        if let Some(call_info) = self.analysis.call_info.get(&l.syntax_object_id) {
-            let op_code = match call_info.kind {
-                Normal => OpCode::FUNC,
-                TailCall => OpCode::TAILCALL,
-                SelfTailCall(_) => {
-                    // We don't need to push the function onto the stack if we're doing a self
-                    // tail call
-                    self.instructions.pop();
-                    OpCode::TCOJMP
-                    // OpCode::TAILCALL
-                }
-            };
-
-            self.push(
-                LabeledInstruction::builder(op_code)
-                    .contents(contents)
-                    .payload(pop_len),
-            );
-
-            if let SelfTailCall(depth) = call_info.kind {
-                self.push(LabeledInstruction::builder(OpCode::PASS).payload(depth - 1));
-            }
-
-            Ok(())
-        } else {
-            self.push(
-                LabeledInstruction::builder(OpCode::FUNC)
-                    .contents(contents)
-                    .payload(pop_len),
-            );
-
-            Ok(())
-
-            // stop!(Generic => "Unable to find analysis information for call site!")
-        }
-    }
-
-    fn visit_syntax_rules(&mut self, l: &crate::parser::ast::SyntaxRules) -> Self::Output {
-        stop!(BadSyntax => "unexpected syntax rules"; l.location.span)
-    }
-
-    fn visit_set(&mut self, s: &crate::parser::ast::Set) -> Self::Output {
-        // stop!(BadSyntax => "set! is currently not implemented"; s.location.span);
-
-        self.visit(&s.expr)?;
-
-        let a = s.variable.atom_syntax_object().unwrap();
-
-        if let Some(analysis) = self.analysis.get(a) {
-            // TODO: We really want to fail as early as possible, but lets just try this here:
-            if analysis.builtin {
-                stop!(Generic => "set!: cannot mutate module-required identifier"; s.location.span);
-            }
-
-            let op_code = match &analysis.kind {
-                Global => OpCode::SET,
-                Local | LetVar => OpCode::SETLOCAL,
-
-                LocallyDefinedFunction => {
-                    stop!(Generic => "Unable to lower to bytecode: locally defined function should be lifted to an external scope")
-                }
-                // In the event we're captured, we're going to just read the
-                // offset from the captured var
-                Captured => {
-                    stop!(Generic => "Compiler error: Should not be able to set! an immutably captured variable")
-                }
-                Free => OpCode::SET,
-                HeapAllocated => OpCode::SETALLOC,
-                // This is technically true, but in an incremental compilation mode, we assume the variable is already bound
-                // stop!(FreeIdentifier => format!("free identifier: {}", a); a.syn.span),
-            };
-
-            let payload = match op_code {
-                // OpCode::SETCAPTURED => analysis.read_capture_offset.unwrap(),
-                OpCode::SETALLOC => analysis.read_heap_offset.unwrap(),
-                _ => analysis.stack_offset.unwrap_or_default(),
-            };
-
-            self.push(
-                LabeledInstruction::builder(op_code)
-                    .payload(payload)
-                    .contents(a.clone()),
-            );
-
-            Ok(())
-        } else {
-            stop!(Generic => "Something went wrong with getting the var in set!"; s.location.span);
-        }
-    }
-
-    fn visit_require(&mut self, r: &crate::parser::ast::Require) -> Self::Output {
-        stop!(BadSyntax => "unexpected require statement in code gen"; r.location.span)
-    }
-
-    fn visit_let(&mut self, l: &crate::parser::ast::Let) -> Self::Output {
-        // What we're gonna do here is pretty straight forward:
-        // Since we're entering a scope, we need to include the code to remove from this from
-        // the stack as well
-        //
-        // Otherwise, the machinery is more or less the same as before - we're just not going to
-        // enter a new section of bytecode, its all going to live under the same block.
-        //
-        // (let ((a 10) (b 20))
-        //      (+ 1 2 3 4 5) <--- Could get dropped immediately, but for now it does not
-        //      (+ 2 3 4 5 6) <--|
-        //      (+ a b))
-        //
-        // This should result in something like
-        // PUSHCONST 10
-        // PUSHCONST 20
-        // READLOCAL a
-        // READLOCAL b
-        // PUSH +
-        // FUNC 2
-        // LETENDSCOPE 0 <- index of the stack when we entered this let expr
-
-        self.push(
-            LabeledInstruction::builder(OpCode::BEGINSCOPE)
-                .payload(*self.local_count.last().unwrap_or(&0)),
-        );
-
-        let info = self
-            .analysis
-            .let_info
-            .get(&l.syntax_object_id)
-            .expect("Missing analysis information for let");
-
-        // Push the scope + the number of arguments in this scope
-        // self.push(LabeledInstruction::builder(OpCode::BEGINSCOPE).payload(l.bindings.len()));
-        // self.push(LabeledInstruction::builder(OpCode::BEGINSCOPE).payload(info.stack_offset));
-
-        // We just assume these will live on the stack at whatever position we're entering now
-        for expr in l.expression_arguments() {
-            self.visit(expr)?;
-            // For the JIT -> push the last instruction to the internal scope
-            // TODO: Rename from BEGINSCOPE to something like MARKLETVAR
-            // self.push(LabeledInstruction::builder(OpCode::LetVar));
-        }
-
-        let mut heap_allocated_arguments = info
-            .arguments
-            .values()
-            .filter(|x| x.captured && x.mutated)
-            .collect::<Vec<_>>();
-
-        heap_allocated_arguments.sort_by_key(|x| x.stack_offset);
-
-        for var in heap_allocated_arguments {
-            // println!("Found a var that is both mutated and captured");
-            // println!("{:#?}", var);
-
-            self.push(
-                LabeledInstruction::builder(OpCode::ALLOC).payload(var.stack_offset.unwrap()),
-            );
-        }
-
-        self.visit(&l.body_expr)?;
-
-        // TODO:
-        // It is possible, that during the course of execution, local variables get captured.
-        // For example:
-        //
-        // (let ((a 10) (b 20))
-        //      (lambda (x) (+ x a b)))
-        //
-        // In this case, at the end of the let scope, we can move those variables
-        // into the slot that exists on the heap - and local variable references internally
-        // in the function will refer to the local function slots, rather than the spots on the stack
-        //
-        // Having things on the stack will make things much faster. Lets try to keep them there.
-        //
-        // The let will have to keep track of if any of these values are captured, and if they are
-        // just insert an instruction to close that upvalue
-
-        self.push(LabeledInstruction::builder(OpCode::LETENDSCOPE).payload(info.stack_offset));
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod code_gen_tests {
-    use super::*;
-
-    use crate::parser::parser::Parser;
-
-    #[test]
-    fn check_function_calls() {
-        let expr = r#"
-        ;; (define fib (lambda (n) (if (<= n 2) 1 (+ (fib (- n 1)) (fib (- n 2))))))
-
-        (fib 10)
-            "#;
-
-        let exprs = Parser::parse(expr).unwrap();
-        let mut analysis = Analysis::from_exprs(&exprs);
-        analysis.populate_captures(&exprs);
-
-        let mut constants = ConstantMap::new();
-
-        let mut code_gen = CodeGenerator::new(&mut constants, &analysis);
-
-        code_gen.visit(&exprs[0]).unwrap();
-        // code_gen.visit(&exprs[1]).unwrap();
-
-        println!("{:#?}", code_gen.instructions);
-    }
-
-    #[test]
-    fn check_fib() {
-        let expr = r#"
-        (define fib (lambda (n) (if (<= n 2) 1 (+ (fib (- n 1)) (fib (- n 2))))))
-
-        (fib 10)
-            "#;
-
-        let exprs = Parser::parse(expr).unwrap();
-        let mut analysis = Analysis::from_exprs(&exprs);
-        analysis.populate_captures(&exprs);
-
-        let mut constants = ConstantMap::new();
-
-        let mut code_gen = CodeGenerator::new(&mut constants, &analysis);
-
-        code_gen.visit(&exprs[0]).unwrap();
-        code_gen.visit(&exprs[1]).unwrap();
-
-        println!("{:#?}", code_gen.instructions);
-    }
-
-    #[test]
-    fn check_new_closure() {
-        let expr = r#"
-            (lambda (x)
-                (lambda (y) (+ x y)))
-        "#;
-
-        let exprs = Parser::parse(expr).unwrap();
-        let mut analysis = Analysis::from_exprs(&exprs);
-        analysis.populate_captures(&exprs);
-
-        let mut constants = ConstantMap::new();
-
-        let mut code_gen = CodeGenerator::new(&mut constants, &analysis);
-
-        code_gen.visit(&exprs[0]).unwrap();
-
-        println!("{:#?}", code_gen.instructions);
-    }
-
-    #[test]
-    fn check_lambda_output() {
-        let expr = r#"
-        (lambda (x y z)
-            (+ x y z))
-        "#;
-
-        let exprs = Parser::parse(expr).unwrap();
-
-        let mut analysis = Analysis::from_exprs(&exprs);
-        analysis.populate_captures(&exprs);
-
-        let mut constants = ConstantMap::new();
-
-        let mut code_gen = CodeGenerator::new(&mut constants, &analysis);
-
-        code_gen.visit(&exprs[0]).unwrap();
-
-        println!("{:#?}", code_gen.instructions);
-
-        let expected = vec![
-            (OpCode::PUREFUNC, 9), // This captures no variables - should be able to be lifted as well
-            (OpCode::PASS, 0),     // multi arity
-            (OpCode::PASS, 0),     // This shouldn't need to be here
-            (OpCode::MOVEREADLOCAL, 0), // last usage of x, first var
-            (OpCode::MOVEREADLOCAL, 1), // last usage of y
-            (OpCode::MOVEREADLOCAL, 2), // last usage of z
-            (OpCode::PUSH, 0), // + is a global, that is late bound and the index is resolved later
-            (OpCode::TAILCALL, 3), // tail call function, with 3 arguments
-            (OpCode::POPPURE, 3), // Pop 3 arguments
-            (OpCode::ECLOSURE, 3), // Something about 3 arguments...
-        ];
-
-        let mut found = code_gen
-            .instructions
-            .iter()
-            .map(|x| (x.op_code, x.payload_size))
-            .collect::<Vec<_>>();
-
-        // Wipe out the syntax object id from the PASS
-        found[2].1 = 0;
-
-        assert_eq!(expected, found);
-    }
-
-    #[test]
-    fn check_let_captured_var() {
-        let expr = r#"
-        (%plain-let ((a 10) (b 20))
-            (lambda () (+ a b)))
-        "#;
-
-        let exprs = Parser::parse(expr).unwrap();
-
-        let mut analysis = Analysis::from_exprs(&exprs);
-        analysis.populate_captures(&exprs);
-
-        let mut constants = ConstantMap::new();
-
-        let mut code_gen = CodeGenerator::new(&mut constants, &analysis);
-
-        code_gen.visit(&exprs[0]).unwrap();
-    }
-
-    // #[test]
-    // fn check_let_output() {
-    //     let expr = r#"
-    //         (%plain-let ((a 10) (b 20))
-    //             (+ a b))
-    //     "#;
-
-    //     let exprs = Parser::parse(expr).unwrap();
-
-    //     let analysis = Analysis::from_exprs(&exprs);
-    //     let mut constants = ConstantMap::new();
-
-    //     let mut code_gen = CodeGenerator::new(&mut constants, &analysis);
-
-    //     code_gen.visit(&exprs[0]).unwrap();
-
-    //     println!("{:#?}", code_gen.instructions);
-
-    //     let expected = vec![
-    //         (OpCode::BEGINSCOPE, 0),
-    //         (OpCode::PUSHCONST, 0),   // Should be the only constant in the map
-    //         (OpCode::PUSHCONST, 1),   // Should be the second constant in the map
-    //         (OpCode::READLOCAL, 0),   // Corresponds to index 0
-    //         (OpCode::READLOCAL, 1),   // Corresponds to index 1
-    //         (OpCode::PUSH, 0), // + is a global, that is late bound and the index is resolved later
-    //         (OpCode::FUNC, 2), // Function call with 2 arguments
-    //         (OpCode::LETENDSCOPE, 2), // Exit the let scope and drop the vars and anything above it
-    //     ];
-
-    //     let found = code_gen
-    //         .instructions
-    //         .iter()
-    //         .map(|x| (x.op_code, x.payload_size))
-    //         .collect::<Vec<_>>();
-
-    //     assert_eq!(expected, found);
-    // }
-}
diff --git a/crates/steel-core/src/compiler/compiler.rs b/crates/steel-core/src/compiler/compiler.rs
deleted file mode 100644
index 9a9c5b380..000000000
--- a/crates/steel-core/src/compiler/compiler.rs
+++ /dev/null
@@ -1,997 +0,0 @@
-#![allow(unused)]
-
-use crate::{
-    compiler::{
-        constants::ConstantMap,
-        map::SymbolMap,
-        passes::{
-            analysis::SemanticAnalysis, begin::flatten_begins_and_expand_defines,
-            reader::MultipleArityFunctions, shadow::RenameShadowedVariables,
-        },
-    },
-    core::labels::Expr,
-    parser::{
-        ast::AstTools,
-        expand_visitor::{expand_kernel, expand_kernel_in_env},
-        interner::InternedString,
-        kernel::Kernel,
-        parser::{lower_entire_ast, lower_macro_and_require_definitions},
-    },
-    steel_vm::{
-        builtin::BuiltInModule,
-        cache::MemoizationTable,
-        engine::{ModuleContainer, DEFAULT_DOC_MACROS},
-    },
-};
-use crate::{
-    core::{instructions::Instruction, opcode::OpCode},
-    parser::parser::Sources,
-};
-
-use std::{
-    collections::{HashMap, HashSet},
-    path::PathBuf,
-};
-use std::{iter::Iterator, rc::Rc};
-
-// TODO: Replace the usages of hashmap with this directly
-use fxhash::FxHashMap;
-use serde::{Deserialize, Serialize};
-
-use crate::rvals::{Result, SteelVal};
-
-use crate::parser::ast::ExprKind;
-use crate::parser::expander::SteelMacro;
-use crate::parser::parser::SyntaxObject;
-use crate::parser::parser::{ParseError, Parser};
-use crate::parser::tokens::TokenType;
-
-// use crate::core::instructions::{densify, DenseInstruction};
-
-use crate::stop;
-
-use log::{debug, log_enabled};
-
-use crate::steel_vm::const_evaluation::ConstantEvaluatorManager;
-
-use super::{
-    constants::SerializableConstantMap,
-    modules::{CompiledModule, ModuleManager},
-    passes::analysis::Analysis,
-    program::RawProgramWithSymbols,
-};
-
-use im_rc::HashMap as ImmutableHashMap;
-
-use std::time::Instant;
-
-// use itertools::Itertools;
-
-#[derive(Default)]
-pub struct DebruijnIndicesInterner {
-    flat_defines: HashSet<InternedString>,
-    second_pass_defines: HashSet<InternedString>,
-}
-
-impl DebruijnIndicesInterner {
-    pub fn collect_first_pass_defines(
-        &mut self,
-        instructions: &mut [Instruction],
-        symbol_map: &mut SymbolMap,
-    ) -> Result<()> {
-        for i in 2..instructions.len() {
-            match (&instructions[i], &instructions[i - 1], &instructions[i - 2]) {
-                (
-                    Instruction {
-                        op_code: OpCode::BIND,
-                        contents:
-                            Some(Expr::Atom(SyntaxObject {
-                                ty: TokenType::Identifier(s),
-                                span,
-                                ..
-                            })),
-                        ..
-                    },
-                    Instruction {
-                        op_code: OpCode::EDEF,
-                        ..
-                    },
-                    Instruction {
-                        op_code: OpCode::ECLOSURE,
-                        ..
-                    },
-                ) => {
-                    let idx = symbol_map.add(s);
-                    self.flat_defines.insert(s.to_owned());
-                    // if !self.flat_defines.insert(s.to_owned()) {
-                    //     stop!(BadSyntax => format!("Cannot redefine define within the same scope: {}", s); *span);
-                    // }
-
-                    if let Some(x) = instructions.get_mut(i) {
-                        x.payload_size = idx;
-                    }
-                }
-                (
-                    Instruction {
-                        op_code: OpCode::BIND,
-                        contents:
-                            Some(Expr::Atom(SyntaxObject {
-                                ty: TokenType::Identifier(s),
-                                span,
-                                ..
-                            })),
-                        ..
-                    },
-                    ..,
-                ) => {
-                    let idx = symbol_map.add(s);
-                    self.flat_defines.insert(s.to_owned());
-                    // if !self.flat_defines.insert(s.to_owned()) {
-                    //     stop!(BadSyntax => format!("Cannot redefine define within the same scope: {}", s); *span);
-                    // }
-
-                    if let Some(x) = instructions.get_mut(i) {
-                        x.payload_size = idx;
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        Ok(())
-    }
-
-    pub fn collect_second_pass_defines(
-        &mut self,
-        instructions: &mut [Instruction],
-        symbol_map: &mut SymbolMap,
-    ) -> Result<()> {
-        // let mut second_pass_defines: HashSet<String> = HashSet::new();
-
-        let mut depth = 0;
-
-        // name mangle
-        // Replace all identifiers with indices
-        for i in 0..instructions.len() {
-            match &instructions[i] {
-                Instruction {
-                    op_code: OpCode::SCLOSURE | OpCode::NEWSCLOSURE | OpCode::PUREFUNC,
-                    ..
-                } => {
-                    depth += 1;
-                }
-                Instruction {
-                    op_code: OpCode::ECLOSURE,
-                    ..
-                } => {
-                    depth -= 1;
-                }
-                Instruction {
-                    op_code: OpCode::BEGINSCOPE,
-                    ..
-                } => {
-                    depth += 1;
-                }
-                Instruction {
-                    op_code: OpCode::LETENDSCOPE,
-                    ..
-                } => {
-                    depth -= 1;
-                }
-                Instruction {
-                    op_code: OpCode::BIND,
-                    contents:
-                        Some(Expr::Atom(SyntaxObject {
-                            ty: TokenType::Identifier(s),
-                            ..
-                        })),
-                    ..
-                } => {
-                    // Keep track of where the defines actually are in the process
-                    self.second_pass_defines.insert(s.to_owned());
-                }
-                Instruction {
-                    op_code: OpCode::PUSH,
-                    contents:
-                        Some(Expr::Atom(SyntaxObject {
-                            ty: TokenType::Identifier(s),
-                            span,
-                            ..
-                        })),
-                    ..
-                }
-                | Instruction {
-                    op_code: OpCode::SET,
-                    contents:
-                        Some(Expr::Atom(SyntaxObject {
-                            ty: TokenType::Identifier(s),
-                            span,
-                            ..
-                        })),
-                    ..
-                } => {
-                    if self.flat_defines.get(s).is_some()
-                        && self.second_pass_defines.get(s).is_none()
-                        && depth == 0
-                    {
-                        let message =
-                            format!("Cannot reference an identifier before its definition: {s}");
-                        stop!(FreeIdentifier => message; *span);
-                    }
-
-                    let idx = symbol_map.get(s).map_err(|e| e.set_span(*span))?;
-
-                    // TODO commenting this for now
-                    if let Some(x) = instructions.get_mut(i) {
-                        x.payload_size = idx;
-                    }
-                }
-                Instruction {
-                    op_code: OpCode::CALLGLOBAL,
-                    contents:
-                        Some(Expr::Atom(SyntaxObject {
-                            ty: TokenType::Identifier(s),
-                            span,
-                            ..
-                        })),
-                    ..
-                }
-                | Instruction {
-                    op_code: OpCode::CALLGLOBALTAIL,
-                    contents:
-                        Some(Expr::Atom(SyntaxObject {
-                            ty: TokenType::Identifier(s),
-                            span,
-                            ..
-                        })),
-                    ..
-                } => {
-                    if self.flat_defines.get(s).is_some()
-                        && self.second_pass_defines.get(s).is_none()
-                        && depth == 0
-                    {
-                        let message =
-                            format!("Cannot reference an identifier before its definition: {s}");
-                        stop!(FreeIdentifier => message; *span);
-                    }
-
-                    let idx = symbol_map.get(s).map_err(|e| e.set_span(*span))?;
-
-                    // TODO commenting this for now
-                    if let Some(x) = instructions.get_mut(i) {
-                        x.payload_size = idx;
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        Ok(())
-    }
-}
-
-#[derive(Clone, Copy, PartialEq, PartialOrd, Serialize, Deserialize)]
-pub enum OptLevel {
-    Zero = 0,
-    One,
-    Two,
-    Three,
-}
-
-#[derive(Clone)]
-pub struct Compiler {
-    pub(crate) symbol_map: SymbolMap,
-    pub(crate) constant_map: ConstantMap,
-    pub(crate) macro_env: HashMap<InternedString, SteelMacro>,
-    module_manager: ModuleManager,
-    opt_level: OptLevel,
-    pub(crate) kernel: Option<Kernel>,
-    memoization_table: MemoizationTable,
-    mangled_identifiers: HashSet<InternedString>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SerializableCompiler {
-    pub(crate) symbol_map: SymbolMap,
-    pub(crate) constant_map: SerializableConstantMap,
-    pub(crate) macro_env: HashMap<InternedString, SteelMacro>,
-    pub(crate) opt_level: OptLevel,
-    pub(crate) module_manager: ModuleManager,
-}
-
-impl SerializableCompiler {
-    pub(crate) fn into_compiler(self) -> Compiler {
-        let mut compiler = Compiler::default();
-
-        compiler.symbol_map = self.symbol_map;
-        compiler.constant_map = ConstantMap::from_serialized(self.constant_map).unwrap();
-        compiler.macro_env = self.macro_env;
-        compiler.opt_level = self.opt_level;
-        compiler.module_manager = self.module_manager;
-
-        compiler
-    }
-}
-
-impl Compiler {
-    pub(crate) fn into_serializable_compiler(self) -> Result<SerializableCompiler> {
-        Ok(SerializableCompiler {
-            symbol_map: self.symbol_map,
-            constant_map: self.constant_map.into_serializable_map(),
-            macro_env: self.macro_env,
-            opt_level: self.opt_level,
-            module_manager: self.module_manager,
-        })
-    }
-}
-
-impl Default for Compiler {
-    fn default() -> Self {
-        Compiler::new(
-            SymbolMap::new(),
-            ConstantMap::new(),
-            HashMap::new(),
-            ModuleManager::default(),
-        )
-    }
-}
-
-impl Compiler {
-    fn new(
-        symbol_map: SymbolMap,
-        constant_map: ConstantMap,
-        macro_env: HashMap<InternedString, SteelMacro>,
-        module_manager: ModuleManager,
-    ) -> Compiler {
-        Compiler {
-            symbol_map,
-            constant_map,
-            macro_env,
-            module_manager,
-            opt_level: OptLevel::Three,
-            kernel: None,
-            memoization_table: MemoizationTable::new(),
-            mangled_identifiers: HashSet::new(),
-        }
-    }
-
-    fn new_with_kernel(
-        symbol_map: SymbolMap,
-        constant_map: ConstantMap,
-        macro_env: HashMap<InternedString, SteelMacro>,
-        module_manager: ModuleManager,
-        kernel: Kernel,
-    ) -> Compiler {
-        Compiler {
-            symbol_map,
-            constant_map,
-            macro_env,
-            module_manager,
-            opt_level: OptLevel::Three,
-            kernel: Some(kernel),
-            memoization_table: MemoizationTable::new(),
-            mangled_identifiers: HashSet::new(),
-        }
-    }
-
-    pub(crate) fn default_from_kernel(kernel: Kernel) -> Compiler {
-        Compiler::new_with_kernel(
-            SymbolMap::new(),
-            ConstantMap::new(),
-            HashMap::new(),
-            ModuleManager::default(),
-            kernel,
-        )
-    }
-
-    pub fn default_with_kernel() -> Compiler {
-        Compiler::new_with_kernel(
-            SymbolMap::new(),
-            ConstantMap::new(),
-            HashMap::new(),
-            ModuleManager::default(),
-            Kernel::new(),
-        )
-    }
-
-    /// Registers a name in the underlying symbol map and returns the idx that it maps to
-    pub fn register(&mut self, name: &str) -> usize {
-        let spur = name.into();
-        self.symbol_map.add(&spur)
-    }
-
-    /// Get the index associated with a name in the underlying symbol map
-    /// If the name hasn't been registered, this will return `None`
-    pub fn get_idx(&self, name: &str) -> Option<usize> {
-        self.symbol_map.get(&InternedString::try_get(name)?).ok()
-    }
-
-    pub fn register_builtin(&mut self, name: String, contents: String) {
-        self.module_manager.add_builtin_module(name, contents);
-    }
-
-    pub fn compile_executable_from_expressions(
-        &mut self,
-        exprs: Vec<ExprKind>,
-        builtin_modules: ModuleContainer,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        sources: &mut Sources,
-    ) -> Result<RawProgramWithSymbols> {
-        self.compile_raw_program(exprs, constants, builtin_modules, None, sources)
-    }
-
-    pub fn compile_executable(
-        &mut self,
-        expr_str: &str,
-        path: Option<PathBuf>,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        builtin_modules: ModuleContainer,
-        sources: &mut Sources,
-    ) -> Result<RawProgramWithSymbols> {
-        #[cfg(feature = "profiling")]
-        let now = Instant::now();
-
-        let id = sources.add_source(expr_str.to_string(), path.clone());
-
-        // Could fail here
-        let parsed: std::result::Result<Vec<ExprKind>, ParseError> = if let Some(p) = &path {
-            Parser::new_from_source(expr_str, p.clone(), Some(id))
-                .without_lowering()
-                .map(|x| x.and_then(lower_macro_and_require_definitions))
-                .collect()
-        } else {
-            Parser::new(expr_str, Some(id))
-                .without_lowering()
-                .map(|x| x.and_then(lower_macro_and_require_definitions))
-                .collect()
-        };
-
-        // println!("Finished parsing");
-
-        #[cfg(feature = "profiling")]
-        if log_enabled!(target: "pipeline_time", log::Level::Debug) {
-            debug!(target: "pipeline_time", "Parsing Time: {:?}", now.elapsed());
-        }
-
-        let parsed = parsed?;
-
-        // TODO fix this hack
-        self.compile_raw_program(parsed, constants, builtin_modules, path, sources)
-    }
-
-    // TODO: Add a flag/function for parsing comments as well
-    // Move the body of this function into the other one, so that way we have proper
-    pub fn emit_expanded_ast(
-        &mut self,
-        expr_str: &str,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        path: Option<PathBuf>,
-        sources: &mut Sources,
-        builtin_modules: ModuleContainer,
-    ) -> Result<Vec<ExprKind>> {
-        let id = sources.add_source(expr_str.to_string(), path.clone());
-
-        // Could fail here
-        let parsed: std::result::Result<Vec<ExprKind>, ParseError> =
-            Parser::new(expr_str, Some(id))
-                .without_lowering()
-                .map(|x| x.and_then(lower_macro_and_require_definitions))
-                .collect();
-
-        let parsed = parsed?;
-
-        self.lower_expressions_impl(parsed, constants, builtin_modules, path, sources)
-    }
-
-    pub fn emit_expanded_ast_without_optimizations(
-        &mut self,
-        expr_str: &str,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        path: Option<PathBuf>,
-        sources: &mut Sources,
-        builtin_modules: ModuleContainer,
-    ) -> Result<Vec<ExprKind>> {
-        let id = sources.add_source(expr_str.to_string(), path.clone());
-
-        // Could fail here
-        let parsed: std::result::Result<Vec<ExprKind>, ParseError> =
-            Parser::new(expr_str, Some(id))
-                .without_lowering()
-                .map(|x| x.and_then(lower_macro_and_require_definitions))
-                .collect();
-
-        let parsed = parsed?;
-
-        self.expand_ast(parsed, constants, builtin_modules, path, sources)
-    }
-
-    pub fn compile_module(
-        &mut self,
-        path: PathBuf,
-        sources: &mut Sources,
-        builtin_modules: ModuleContainer,
-    ) -> Result<()> {
-        self.module_manager.add_module(
-            path,
-            &mut self.macro_env,
-            &mut self.kernel,
-            sources,
-            builtin_modules,
-        )
-    }
-
-    pub fn modules(&self) -> &HashMap<PathBuf, CompiledModule> {
-        self.module_manager.modules()
-    }
-
-    pub fn expand_expressions(
-        &mut self,
-        exprs: Vec<ExprKind>,
-        path: Option<PathBuf>,
-        sources: &mut Sources,
-        builtin_modules: ModuleContainer,
-    ) -> Result<Vec<ExprKind>> {
-        #[cfg(feature = "modules")]
-        return self.module_manager.compile_main(
-            &mut self.macro_env,
-            &mut self.kernel,
-            sources,
-            exprs,
-            path,
-            builtin_modules,
-        );
-
-        #[cfg(not(feature = "modules"))]
-        self.module_manager
-            .expand_expressions(&mut self.macro_env, exprs)
-    }
-
-    fn generate_instructions_for_executable(
-        &mut self,
-        expanded_statements: Vec<ExprKind>,
-    ) -> Result<Vec<Vec<Instruction>>> {
-        let mut results = Vec::new();
-        let mut instruction_buffer = Vec::new();
-        let mut index_buffer = Vec::new();
-
-        let analysis = {
-            let mut analysis = Analysis::from_exprs(&expanded_statements);
-            analysis.populate_captures(&expanded_statements);
-            analysis.populate_captures(&expanded_statements);
-            analysis
-        };
-
-        // expanded_statements.pretty_print();
-
-        for expr in expanded_statements {
-            let mut instructions =
-                super::code_gen::CodeGenerator::new(&mut self.constant_map, &analysis)
-                    .top_level_compile(&expr)?;
-
-            // TODO: I don't think this needs to be here anymore
-            // inject_heap_save_to_pop(&mut instructions);
-            index_buffer.push(instructions.len());
-            instruction_buffer.append(&mut instructions);
-        }
-
-        for idx in index_buffer {
-            let extracted: Vec<Instruction> = instruction_buffer.drain(0..idx).collect();
-            results.push(extracted);
-        }
-
-        Ok(results)
-    }
-
-    fn expand_ast(
-        &mut self,
-        exprs: Vec<ExprKind>,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        builtin_modules: ModuleContainer,
-        path: Option<PathBuf>,
-        sources: &mut Sources,
-    ) -> Result<Vec<ExprKind>> {
-        let mut expanded_statements =
-            self.expand_expressions(exprs, path, sources, builtin_modules.clone())?;
-
-        // expanded_statements = expanded_statements
-        //     .into_iter()
-        //     .map(lower_entire_ast)
-        //     .collect::<std::result::Result<Vec<_>, ParseError>>()?;
-
-        log::debug!(target: "expansion-phase", "Expanding macros -> phase 1");
-
-        if let Some(kernel) = self.kernel.as_mut() {
-            // Label anything at the top as well - top level
-            kernel.load_syntax_transformers(&mut expanded_statements, "top-level".to_string())?;
-        }
-
-        expanded_statements = expanded_statements
-            .into_iter()
-            .map(|x| {
-                expand_kernel_in_env(
-                    x,
-                    self.kernel.as_mut(),
-                    builtin_modules.clone(),
-                    "top-level".to_string(),
-                )
-                .and_then(|x| crate::parser::expand_visitor::expand(x, &self.macro_env))
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        expanded_statements = expanded_statements
-            .into_iter()
-            .map(lower_entire_ast)
-            .collect::<std::result::Result<Vec<_>, ParseError>>()?;
-
-        expanded_statements = expanded_statements
-            .into_iter()
-            .map(|x| {
-                expand_kernel_in_env(
-                    x,
-                    self.kernel.as_mut(),
-                    builtin_modules.clone(),
-                    "top-level".to_string(),
-                )
-                .and_then(|x| crate::parser::expand_visitor::expand(x, &self.macro_env))
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        log::debug!(target: "expansion-phase", "Beginning constant folding");
-
-        let mut expanded_statements =
-            self.apply_const_evaluation(constants.clone(), expanded_statements, false)?;
-
-        RenameShadowedVariables::rename_shadowed_vars(&mut expanded_statements);
-
-        let mut analysis = Analysis::from_exprs(&expanded_statements);
-        analysis.populate_captures(&expanded_statements);
-
-        let mut semantic = SemanticAnalysis::from_analysis(&mut expanded_statements, analysis);
-
-        // This is definitely broken still
-        semantic
-            .elide_single_argument_lambda_applications()
-            .replace_non_shadowed_globals_with_builtins(
-                &mut self.macro_env,
-                &mut self.module_manager,
-                &mut self.mangled_identifiers,
-            )
-            // TODO: To get this to work, we have to check the macros to make sure those
-            // are safe to eliminate. In interactive mode, we'll
-            // be unable to optimize those away
-            .remove_unused_globals_with_prefix("mangler", &self.macro_env, &self.module_manager);
-        // Don't do lambda lifting here
-        // .lift_pure_local_functions()
-        // .lift_all_local_functions();
-
-        // debug!("About to expand defines");
-
-        log::debug!(target: "expansion-phase", "Flattening begins, converting internal defines to let expressions");
-
-        let mut analysis = semantic.into_analysis();
-
-        let mut expanded_statements = flatten_begins_and_expand_defines(expanded_statements);
-
-        // After define expansion, we'll want this
-        RenameShadowedVariables::rename_shadowed_vars(&mut expanded_statements);
-
-        analysis.fresh_from_exprs(&expanded_statements);
-        analysis.populate_captures(&expanded_statements);
-
-        let mut semantic = SemanticAnalysis::from_analysis(&mut expanded_statements, analysis);
-
-        semantic.check_if_values_are_redefined()?;
-
-        semantic.refresh_variables();
-        semantic.flatten_anonymous_functions();
-        semantic.refresh_variables();
-
-        // Replace mutation with boxes
-        semantic.populate_captures();
-        semantic.populate_captures();
-
-        semantic.replace_mutable_captured_variables_with_boxes();
-
-        log::debug!(target: "expansion-phase", "Expanding multiple arity functions");
-
-        let mut analysis = semantic.into_analysis();
-
-        // Rename them again
-        RenameShadowedVariables::rename_shadowed_vars(&mut expanded_statements);
-
-        let mut expanded_statements =
-            MultipleArityFunctions::expand_multiple_arity_functions(expanded_statements);
-
-        log::info!(target: "expansion-phase", "Aggressive constant evaluation with memoization");
-
-        // Begin lowering anonymous function calls to lets
-
-        analysis.fresh_from_exprs(&expanded_statements);
-        analysis.populate_captures(&expanded_statements);
-        let mut semantic = SemanticAnalysis::from_analysis(&mut expanded_statements, analysis);
-
-        semantic.replace_anonymous_function_calls_with_plain_lets();
-
-        Ok(expanded_statements)
-    }
-
-    fn lower_expressions_impl(
-        &mut self,
-        exprs: Vec<ExprKind>,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        builtin_modules: ModuleContainer,
-        path: Option<PathBuf>,
-        sources: &mut Sources,
-    ) -> Result<Vec<ExprKind>> {
-        let mut expanded_statements =
-            self.expand_expressions(exprs, path, sources, builtin_modules.clone())?;
-
-        // expanded_statements = expanded_statements
-        //     .into_iter()
-        //     .map(lower_entire_ast)
-        //     .collect::<std::result::Result<Vec<_>, ParseError>>()?;
-
-        // if log_enabled!(log::Level::Debug) {
-        //     debug!(
-        //         "Generating instructions for the expression: {:?}",
-        //         expanded_statements
-        //             .iter()
-        //             .map(|x| x.to_string())
-        //             .collect::<Vec<_>>()
-        //     );
-        // }
-
-        log::debug!(target: "expansion-phase", "Expanding macros -> phase 1");
-
-        if let Some(kernel) = self.kernel.as_mut() {
-            // Label anything at the top as well - top level
-            kernel.load_syntax_transformers(&mut expanded_statements, "top-level".to_string())?;
-        }
-
-        expanded_statements = expanded_statements
-            .into_iter()
-            .map(|x| {
-                expand_kernel_in_env(
-                    x,
-                    self.kernel.as_mut(),
-                    builtin_modules.clone(),
-                    "top-level".to_string(),
-                )
-                .and_then(|x| crate::parser::expand_visitor::expand(x, &self.macro_env))
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        expanded_statements = expanded_statements
-            .into_iter()
-            .map(lower_entire_ast)
-            .collect::<std::result::Result<Vec<_>, ParseError>>()?;
-
-        expanded_statements = expanded_statements
-            .into_iter()
-            .map(|x| {
-                expand_kernel_in_env(
-                    x,
-                    self.kernel.as_mut(),
-                    builtin_modules.clone(),
-                    "top-level".to_string(),
-                )
-                // TODO: If we have this, then we have to lower all of the expressions again
-                .and_then(|x| crate::parser::expand_visitor::expand(x, &self.macro_env))
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        // println!("{:#?}", expanded_statements);
-
-        // Let's do the @doc macro here?
-
-        log::debug!(target: "expansion-phase", "Beginning constant folding");
-
-        let mut expanded_statements =
-            self.apply_const_evaluation(constants.clone(), expanded_statements, false)?;
-
-        RenameShadowedVariables::rename_shadowed_vars(&mut expanded_statements);
-
-        let mut analysis = Analysis::from_exprs(&expanded_statements);
-        analysis.populate_captures(&expanded_statements);
-
-        let mut semantic = SemanticAnalysis::from_analysis(&mut expanded_statements, analysis);
-
-        // This is definitely broken still
-        semantic
-            .elide_single_argument_lambda_applications()
-            .replace_non_shadowed_globals_with_builtins(
-                &mut self.macro_env,
-                &mut self.module_manager,
-                &mut self.mangled_identifiers,
-            )
-            // TODO: To get this to work, we have to check the macros to make sure those
-            // are safe to eliminate. In interactive mode, we'll
-            // be unable to optimize those away
-            .remove_unused_globals_with_prefix("mangler", &self.macro_env, &self.module_manager)
-            .lift_pure_local_functions()
-            .lift_all_local_functions();
-
-        // debug!("About to expand defines");
-
-        log::debug!(target: "expansion-phase", "Flattening begins, converting internal defines to let expressions");
-
-        let mut analysis = semantic.into_analysis();
-
-        let mut expanded_statements = flatten_begins_and_expand_defines(expanded_statements);
-
-        // After define expansion, we'll want this
-        RenameShadowedVariables::rename_shadowed_vars(&mut expanded_statements);
-
-        analysis.fresh_from_exprs(&expanded_statements);
-        analysis.populate_captures(&expanded_statements);
-
-        // expanded_statements.pretty_print();
-
-        let mut semantic = SemanticAnalysis::from_analysis(&mut expanded_statements, analysis);
-
-        // Check if the values are redefined!
-        semantic.check_if_values_are_redefined()?;
-
-        semantic.refresh_variables();
-        semantic.flatten_anonymous_functions();
-        semantic.refresh_variables();
-
-        // Replace mutation with boxes
-        semantic.populate_captures();
-        semantic.populate_captures();
-
-        semantic.replace_mutable_captured_variables_with_boxes();
-
-        // if log_enabled!(log::Level::Debug) {
-        //     debug!(
-        //         "Successfully expanded defines: {:?}",
-        //         expanded_statements
-        //             .iter()
-        //             .map(|x| x.to_string())
-        //             .collect::<Vec<_>>()
-        //     );
-        // }
-
-        log::debug!(target: "expansion-phase", "Expanding multiple arity functions");
-
-        let mut analysis = semantic.into_analysis();
-
-        // Rename them again
-        RenameShadowedVariables::rename_shadowed_vars(&mut expanded_statements);
-
-        // TODO - make sure I want to keep this
-        let mut expanded_statements =
-            MultipleArityFunctions::expand_multiple_arity_functions(expanded_statements);
-
-        log::info!(target: "expansion-phase", "Aggressive constant evaluation with memoization");
-
-        // Begin lowering anonymous function calls to lets
-
-        // let mut analysis = Analysis::from_exprs(&expanded_statements);
-        // let mut analysis = semantic.into_analysis();
-        analysis.fresh_from_exprs(&expanded_statements);
-        analysis.populate_captures(&expanded_statements);
-        let mut semantic = SemanticAnalysis::from_analysis(&mut expanded_statements, analysis);
-        // semantic.populate_captures();
-
-        semantic.replace_anonymous_function_calls_with_plain_lets();
-
-        Ok(expanded_statements)
-
-        // Done lowering anonymous function calls to let
-        // TODO: Re-enable this, but not in the repl. This repl causes... issues with the implementation
-        // self.apply_const_evaluation(constants, expanded_statements, true)
-    }
-
-    // TODO
-    // figure out how the symbols will work so that a raw program with symbols
-    // can be later pulled in and symbols can be interned correctly
-    fn compile_raw_program(
-        &mut self,
-        exprs: Vec<ExprKind>,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        builtin_modules: ModuleContainer,
-        path: Option<PathBuf>,
-        sources: &mut Sources,
-    ) -> Result<RawProgramWithSymbols> {
-        log::debug!(target: "expansion-phase", "Expanding macros -> phase 0");
-
-        let mut expanded_statements =
-            self.lower_expressions_impl(exprs, constants, builtin_modules, path, sources)?;
-
-        // expanded_statements.pretty_print();
-
-        log::debug!(target: "expansion-phase", "Generating instructions");
-
-        let instructions = self.generate_instructions_for_executable(expanded_statements)?;
-
-        let mut raw_program = RawProgramWithSymbols::new(
-            instructions,
-            self.constant_map.clone(),
-            "0.1.0".to_string(),
-        );
-
-        // Make sure to apply the peephole optimizations
-        raw_program.apply_optimizations();
-
-        // Lets see everything that gets run!
-        // raw_program.debug_print();
-
-        Ok(raw_program)
-    }
-
-    fn run_const_evaluation_with_memoization(
-        &mut self,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        mut expanded_statements: Vec<ExprKind>,
-    ) -> Result<Vec<ExprKind>> {
-        todo!("Implement kernel level const evaluation here!")
-    }
-
-    fn apply_const_evaluation(
-        &mut self,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        mut expanded_statements: Vec<ExprKind>,
-        use_kernel: bool,
-    ) -> Result<Vec<ExprKind>> {
-        #[cfg(feature = "profiling")]
-        let opt_time = Instant::now();
-
-        let mut maybe_kernel = None;
-
-        if use_kernel {
-            if let Some(kernel) = self.kernel.as_mut() {
-                kernel.load_program_for_comptime(constants.clone(), &mut expanded_statements);
-            }
-        }
-
-        match self.opt_level {
-            // TODO
-            // Cut this off at 10 iterations no matter what
-            OptLevel::Three => {
-                for _ in 0..10 {
-                    let mut manager = ConstantEvaluatorManager::new(
-                        &mut self.memoization_table,
-                        constants.clone(),
-                        self.opt_level,
-                        if use_kernel {
-                            &mut self.kernel
-                        } else {
-                            &mut maybe_kernel
-                        },
-                    );
-                    expanded_statements = manager.run(expanded_statements)?;
-
-                    if !manager.changed {
-                        break;
-                    }
-                }
-            }
-            OptLevel::Two => {
-                expanded_statements = ConstantEvaluatorManager::new(
-                    &mut self.memoization_table,
-                    constants,
-                    self.opt_level,
-                    if use_kernel {
-                        &mut self.kernel
-                    } else {
-                        &mut maybe_kernel
-                    },
-                )
-                .run(expanded_statements)?;
-            }
-            _ => {}
-        }
-
-        #[cfg(feature = "profiling")]
-        if log_enabled!(target: "pipeline_time", log::Level::Debug) {
-            debug!(
-                target: "pipeline_time",
-                "Const Evaluation Time: {:?}",
-                opt_time.elapsed()
-            );
-        };
-
-        Ok(expanded_statements)
-    }
-}
diff --git a/crates/steel-core/src/compiler/constants.rs b/crates/steel-core/src/compiler/constants.rs
deleted file mode 100644
index 4233e0aed..000000000
--- a/crates/steel-core/src/compiler/constants.rs
+++ /dev/null
@@ -1,251 +0,0 @@
-use crate::parser::tryfrom_visitor::TryFromExprKindForSteelVal;
-use crate::rvals::{into_serializable_value, Result, SerializableSteelVal, SteelVal};
-
-use crate::parser::{
-    ast::ExprKind,
-    parser::{ParseError, Parser},
-};
-
-use std::collections::HashMap;
-use std::{cell::RefCell, rc::Rc};
-
-// TODO add the serializing and deserializing for constants
-use serde::{Deserialize, Serialize};
-
-// Shared constant map - for repeated in memory execution of a program, this is going to share the same
-// underlying representation.
-#[derive(Debug, PartialEq)]
-pub struct ConstantMap {
-    map: Rc<RefCell<HashMap<SteelVal, usize>>>,
-    values: Rc<RefCell<Vec<SteelVal>>>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SerializableConstantMap(Vec<u8>);
-
-// #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
-// struct ConstantExprMap {
-//     map: Vec<Expr>,
-// }
-impl Default for ConstantMap {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Clone for ConstantMap {
-    fn clone(&self) -> Self {
-        Self {
-            values: Rc::clone(&self.values),
-            map: Rc::clone(&self.map),
-        }
-    }
-}
-
-impl ConstantMap {
-    pub fn new() -> ConstantMap {
-        ConstantMap {
-            values: Rc::new(RefCell::new(Vec::new())),
-            map: Rc::new(RefCell::new(HashMap::new())),
-        }
-    }
-
-    pub(crate) fn into_serializable_map(self) -> SerializableConstantMap {
-        SerializableConstantMap(self.to_bytes().unwrap())
-    }
-
-    pub fn to_serializable_vec(
-        &self,
-        serializer: &mut std::collections::HashMap<usize, SerializableSteelVal>,
-        visited: &mut std::collections::HashSet<usize>,
-    ) -> Vec<SerializableSteelVal> {
-        self.values
-            .borrow()
-            .iter()
-            .cloned()
-            .map(|x| into_serializable_value(x, serializer, visited))
-            .collect::<Result<_>>()
-            .unwrap()
-    }
-
-    // There might be a better way of doing this - but provide this as an option
-    // in the event we want a deep clone of the constant map
-    // pub fn deep_clone(&self) -> ConstantMap {
-    //     ConstantMap(Rc::new(RefCell::new(
-    //         self.0.borrow().iter().cloned().collect(),
-    //     )))
-    // }
-
-    pub fn from_vec(vec: Vec<SteelVal>) -> ConstantMap {
-        ConstantMap {
-            map: Rc::new(RefCell::new(
-                vec.clone()
-                    .into_iter()
-                    .enumerate()
-                    .map(|x| (x.1, x.0))
-                    .collect(),
-            )),
-            values: Rc::new(RefCell::new(vec)),
-        }
-    }
-
-    fn to_constant_expr_map(&self) -> Vec<String> {
-        self.values
-            .borrow()
-            .iter()
-            .map(|x| match x {
-                SteelVal::StringV(s) => {
-                    format!("{:?}", s)
-                }
-                SteelVal::CharV(c) => {
-                    format!("#\\{c}")
-                }
-                _ => x.to_string(),
-            })
-            .collect()
-    }
-
-    pub fn to_bytes(&self) -> Result<Vec<u8>> {
-        // let vector_val = self.to_constant_expr_map()?;
-
-        let str_vector = self.to_constant_expr_map();
-        let result = bincode::serialize(&str_vector);
-
-        Ok(result.unwrap())
-    }
-
-    pub fn from_serialized(map: SerializableConstantMap) -> Result<Self> {
-        Self::from_bytes(&map.0)
-    }
-
-    pub fn from_bytes(encoded: &[u8]) -> Result<ConstantMap> {
-        let str_vector: Vec<String> = bincode::deserialize(encoded).unwrap();
-
-        // println!("{:?}", str_vector);
-
-        str_vector
-            .into_iter()
-            .map(|x| {
-                // Parse the input
-                let parsed: std::result::Result<Vec<ExprKind>, ParseError> =
-                    Parser::new_flat(&x, None).collect();
-                let parsed = parsed?;
-
-                TryFromExprKindForSteelVal::try_from_expr_kind_quoted(parsed[0].clone())
-
-                // Ok(SteelVal::try_from(parsed[0].clone()).unwrap())
-            })
-            .collect::<Result<Vec<_>>>()
-            .map(Self::from_vec)
-    }
-
-    // pub fn from_bytes(encoded: &[u8]) -> ConstantMap {
-    //     bincode::deserialize(encoded).unwrap()
-    // }
-}
-
-impl ConstantMap {
-    pub fn add(&mut self, val: SteelVal) -> usize {
-        let idx = self.len();
-        self.values.borrow_mut().push(val.clone());
-
-        // TODO: Consider just storing the hash code, not the actual value.
-        self.map.borrow_mut().insert(val, idx);
-
-        idx
-    }
-
-    // Fallible
-    #[inline(always)]
-    pub fn get(&self, idx: usize) -> SteelVal {
-        self.values.borrow()[idx].clone()
-    }
-
-    pub fn try_get(&self, idx: usize) -> Option<SteelVal> {
-        self.values.borrow().get(idx).cloned()
-    }
-
-    // Replace with existing constants if they already exist
-    fn walk_constants(&mut self, val: &SteelVal) -> Option<SteelVal> {
-        match val {
-            SteelVal::ListV(l) => Some(SteelVal::ListV(
-                l.iter()
-                    .map(|value| {
-                        let idx = self.add_or_get(value.clone());
-
-                        self.get(idx)
-                    })
-                    .collect(),
-            )),
-            _ => None,
-        }
-    }
-
-    // This is certainly not what we want. This time complexity is
-    // questionable
-    pub fn add_or_get(&mut self, mut val: SteelVal) -> usize {
-        if let SteelVal::ListV(_) = &val {
-            if let Some(new_list) = self.walk_constants(&val) {
-                val = new_list;
-            };
-        }
-
-        let idx = self.map.borrow_mut().get(&val).copied();
-
-        if let Some(idx) = idx {
-            idx
-        } else {
-            self.add(val)
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.values.borrow().len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.values.borrow().is_empty()
-    }
-
-    pub fn roll_back(&mut self, idx: usize) {
-        self.values.borrow_mut().truncate(idx);
-    }
-
-    #[cfg(test)]
-    pub fn clear(&mut self) {
-        self.values.borrow_mut().clear()
-    }
-}
-
-#[cfg(test)]
-pub mod constant_table_tests {
-    use super::*;
-
-    #[test]
-    fn run_tests_constant_map() {
-        let mut instance = ConstantMap::new();
-        test_add(&mut instance);
-
-        let mut instance = ConstantMap::new();
-        test_get(&mut instance);
-    }
-
-    fn test_add(instance: &mut ConstantMap) {
-        assert_eq!(instance.len(), 0);
-        let val1 = SteelVal::BoolV(true);
-        let val2 = SteelVal::BoolV(false);
-        assert_eq!(instance.add(val1), 0);
-        assert_eq!(instance.add(val2), 1);
-    }
-
-    fn test_get(instance: &mut ConstantMap) {
-        assert_eq!(instance.len(), 0);
-        let val1 = SteelVal::BoolV(true);
-        let val2 = SteelVal::BoolV(false);
-        assert_eq!(instance.add(val1), 0);
-        assert_eq!(instance.add(val2), 1);
-
-        assert_eq!(instance.get(0), SteelVal::BoolV(true));
-        assert_eq!(instance.get(1), SteelVal::BoolV(false));
-    }
-}
diff --git a/crates/steel-core/src/compiler/map.rs b/crates/steel-core/src/compiler/map.rs
deleted file mode 100644
index 1234f2ece..000000000
--- a/crates/steel-core/src/compiler/map.rs
+++ /dev/null
@@ -1,58 +0,0 @@
-use crate::throw;
-use crate::{parser::interner::InternedString, rvals::Result};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-
-#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
-pub struct SymbolMap {
-    values: Vec<InternedString>,
-    map: HashMap<InternedString, usize>,
-}
-
-impl Default for SymbolMap {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl SymbolMap {
-    pub fn new() -> Self {
-        SymbolMap {
-            values: Vec::new(),
-            map: HashMap::new(),
-        }
-    }
-
-    pub fn values(&self) -> &Vec<InternedString> {
-        &self.values
-    }
-
-    pub fn len(&self) -> usize {
-        self.values.len()
-    }
-
-    pub fn roll_back(&mut self, index: usize) {
-        for value in self.values.drain(index..) {
-            self.map.remove(&value);
-        }
-    }
-
-    pub fn add(&mut self, ident: &InternedString) -> usize {
-        let idx = self.values.len();
-
-        self.map.insert(*ident, idx);
-
-        // Add the values so we can do a backwards resolution
-        self.values.push(*ident);
-
-        idx
-    }
-
-    // fallible
-    pub fn get(&self, ident: &InternedString) -> Result<usize> {
-        self.map
-            .get(ident)
-            .copied()
-            .ok_or_else(throw!(FreeIdentifier => ident.resolve()))
-    }
-}
diff --git a/crates/steel-core/src/compiler/mod.rs b/crates/steel-core/src/compiler/mod.rs
deleted file mode 100644
index 005c0125e..000000000
--- a/crates/steel-core/src/compiler/mod.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// pub mod code_generator;
-#[allow(clippy::module_inception)]
-pub mod compiler;
-pub mod constants;
-pub mod map;
-pub mod modules;
-pub mod passes;
-pub mod program;
-
-pub mod code_gen;
diff --git a/crates/steel-core/src/compiler/modules.rs b/crates/steel-core/src/compiler/modules.rs
deleted file mode 100644
index cab29e422..000000000
--- a/crates/steel-core/src/compiler/modules.rs
+++ /dev/null
@@ -1,2386 +0,0 @@
-#![allow(unused)]
-use crate::{
-    compiler::{
-        passes::{
-            analysis::{Analysis, SemanticAnalysis},
-            VisitorMutRefUnit,
-        },
-        program::PROVIDE,
-    },
-    parser::{
-        ast::{AstTools, Atom, Begin, Define, ExprKind, List, Quote},
-        expand_visitor::{
-            expand_kernel, expand_kernel_in_env, expand_kernel_in_env_with_allowed,
-            expand_kernel_in_env_with_change,
-        },
-        interner::InternedString,
-        kernel::Kernel,
-        parser::{
-            lower_entire_ast, lower_macro_and_require_definitions, ParseError, Parser, Sources,
-            SyntaxObject,
-        },
-        tokens::TokenType,
-    },
-    steel_vm::{
-        builtin::BuiltInModule,
-        engine::{ModuleContainer, DEFAULT_PRELUDE_MACROS},
-        transducers::interleave,
-    },
-};
-use crate::{parser::expand_visitor::Expander, rvals::Result};
-
-use steel_parser::expr_list;
-
-use std::{
-    borrow::Cow,
-    collections::{HashMap, HashSet},
-    io::Read,
-    path::PathBuf,
-};
-
-use crate::parser::expander::SteelMacro;
-use crate::stop;
-
-use std::time::SystemTime;
-
-use crate::parser::expand_visitor::{expand, extract_macro_defs};
-
-use log::{debug, info, log_enabled};
-
-use crate::parser::ast::IteratorExtensions;
-
-use super::{
-    passes::{
-        begin::FlattenBegin,
-        mangle::{collect_globals, NameMangler, NameUnMangler},
-    },
-    program::{CONTRACT_OUT, FOR_SYNTAX, ONLY_IN, PREFIX_IN, REQUIRE_IDENT_SPEC},
-};
-
-macro_rules! declare_builtins {
-    ( $( $name:expr => $path:expr ), *) => {
-        static BUILT_INS: &[(&str, &str)] = &[
-            $( ($name, include_str!($path)), )*
-        ];
-    };
-}
-
-pub(crate) const MANGLER_SEPARATOR: &str = "__%#__";
-
-macro_rules! create_prelude {
-    (
-        $( $module:literal, )*
-        $( for_syntax $module_for_syntax:literal ),*
-    ) => {
-
-        pub static PRELUDE_WITHOUT_BASE: &str = concat!(
-            $( "(require \"", $module, "\")\n", )*
-            $( "(require (for-syntax \"", $module_for_syntax, "\"))\n", )*
-        );
-
-        pub static PRELUDE_STRING: &str = concat!(
-            "(require-builtin steel/base)\n",
-            $( "(require \"", $module, "\")\n", )*
-            $( "(require (for-syntax \"", $module_for_syntax, "\"))\n", )*
-        );
-    }
-}
-
-declare_builtins!(
-    "steel/option" => "../scheme/modules/option.scm",
-    "steel/result" => "../scheme/modules/result.scm",
-    "steel/iterators" => "../scheme/modules/iterators.scm",
-    "steel/mutable-vectors" => "../scheme/modules/mvector.scm",
-    "#%private/steel/contract" => "../scheme/modules/contracts.scm",
-    "#%private/steel/print" => "../scheme/print.scm",
-    "#%private/steel/control" => "../scheme/modules/parameters.scm",
-    "#%private/steel/reader" => "../scheme/modules/reader.scm",
-    "#%private/steel/stdlib" => "../scheme/stdlib.scm"
-);
-
-create_prelude!(
-    "#%private/steel/control",
-    "#%private/steel/contract",
-    "#%private/steel/print",
-    "#%private/steel/reader",
-    for_syntax "#%private/steel/control",
-    for_syntax "#%private/steel/contract"
-);
-
-/// Manages the modules
-/// keeps some visited state on the manager for traversal
-/// Also keeps track of the metadata for each file in order to determine
-/// if it needs to be recompiled
-#[derive(Clone, serde::Serialize, serde::Deserialize)]
-pub(crate) struct ModuleManager {
-    compiled_modules: HashMap<PathBuf, CompiledModule>,
-    file_metadata: HashMap<PathBuf, SystemTime>,
-    visited: HashSet<PathBuf>,
-    custom_builtins: HashMap<String, String>,
-}
-
-impl ModuleManager {
-    pub(crate) fn new(
-        compiled_modules: HashMap<PathBuf, CompiledModule>,
-        file_metadata: HashMap<PathBuf, SystemTime>,
-    ) -> Self {
-        ModuleManager {
-            compiled_modules,
-            file_metadata,
-            visited: HashSet::new(),
-            custom_builtins: HashMap::new(),
-        }
-    }
-
-    pub fn add_builtin_module(&mut self, module_name: String, mut text: String) {
-        // Custom external builtins should be loaded with the prelude first, otherwise
-        // they'll need to handle a bunch of imports
-        text.insert_str(0, PRELUDE_STRING);
-
-        self.custom_builtins.insert(module_name, text);
-    }
-
-    pub fn modules(&self) -> &HashMap<PathBuf, CompiledModule> {
-        &self.compiled_modules
-    }
-
-    pub fn modules_mut(&mut self) -> &mut HashMap<PathBuf, CompiledModule> {
-        &mut self.compiled_modules
-    }
-
-    pub(crate) fn default() -> Self {
-        Self::new(HashMap::new(), HashMap::new())
-    }
-
-    // Add the module directly to the compiled module cache
-    pub(crate) fn add_module(
-        &mut self,
-        path: PathBuf,
-        global_macro_map: &mut HashMap<InternedString, SteelMacro>,
-        kernel: &mut Option<Kernel>,
-        sources: &mut Sources,
-        builtin_modules: ModuleContainer,
-    ) -> Result<()> {
-        // todo!()
-
-        self.visited.clear();
-
-        // TODO: Expand macros on the fly when visiting a module. Don't wait till the end
-        // Macro expansion should happen as we enter a module.
-        let mut module_builder = ModuleBuilder::new_from_path(
-            path,
-            &mut self.compiled_modules,
-            &mut self.visited,
-            &mut self.file_metadata,
-            sources,
-            kernel,
-            builtin_modules,
-            global_macro_map,
-            &self.custom_builtins,
-        )?;
-
-        module_builder.compile()?;
-
-        // println!("{:#?}", self.compiled_modules);
-
-        Ok(())
-    }
-
-    #[allow(unused)]
-    pub(crate) fn compile_main(
-        &mut self,
-        global_macro_map: &mut HashMap<InternedString, SteelMacro>,
-        kernel: &mut Option<Kernel>,
-        sources: &mut Sources,
-        exprs: Vec<ExprKind>,
-        path: Option<PathBuf>,
-        builtin_modules: ModuleContainer,
-    ) -> Result<Vec<ExprKind>> {
-        // Wipe the visited set on entry
-        self.visited.clear();
-
-        // TODO
-        // This is also explicitly wrong -> we should separate the global macro map from the macros found locally in this module
-        // For instance, (cond) is global, but (define-syntax blagh) might be local to main
-        // if a module then defines a function (blagh) that is used inside its scope, this would expand the macro in that scope
-        // which we do not want
-        let non_macro_expressions = extract_macro_defs(exprs, global_macro_map)?;
-
-        let mut module_builder = ModuleBuilder::main(
-            path,
-            non_macro_expressions,
-            &mut self.compiled_modules,
-            &mut self.visited,
-            &mut self.file_metadata,
-            sources,
-            kernel,
-            builtin_modules,
-            global_macro_map,
-            &self.custom_builtins,
-        )?;
-
-        let mut module_statements = module_builder.compile()?;
-
-        // println!("Compiled modules: {:?}", module_builder.compiled_modules);
-
-        // Expand the ast first with the macros from global/source file
-        let mut ast = module_builder
-            .source_ast
-            .into_iter()
-            .map(|x| expand(x, global_macro_map))
-            .collect::<Result<Vec<_>>>()?;
-
-        {
-            module_builder.source_ast = ast;
-            module_builder.collect_provides();
-
-            ast = std::mem::take(&mut module_builder.source_ast);
-        }
-
-        let mut require_defines = Vec::new();
-
-        let mut mangled_prefixes = module_builder
-            .require_objects
-            .iter()
-            .filter(|x| !x.for_syntax)
-            .map(|x| {
-                "mangler".to_string() + x.path.get_path().to_str().unwrap() + MANGLER_SEPARATOR
-            })
-            .collect::<Vec<_>>();
-
-        let mut explicit_requires = HashMap::new();
-
-        for require_object in &module_builder.require_objects {
-            let path = require_object.path.get_path();
-            explicit_requires.clear();
-
-            // If there _are_ explicit identifiers to import, limit what we import to what
-            // is in the set
-            for ident in &require_object.idents_to_import {
-                match ident {
-                    MaybeRenamed::Normal(i) => {
-                        explicit_requires.insert(i.atom_identifier().unwrap().clone(), None);
-                    }
-
-                    MaybeRenamed::Renamed(from, to) => {
-                        explicit_requires.insert(
-                            from.atom_identifier().unwrap().clone(),
-                            Some(to.atom_identifier().unwrap().clone()),
-                        );
-                    }
-                }
-            }
-
-            // println!("{:?}", path);
-            let module = if let Some(module) = module_builder.compiled_modules.get(path.as_ref()) {
-                module
-            } else {
-                // log::debug!(target: "modules", "No provides found for module, skipping: {:?}", path);
-
-                continue;
-            };
-
-            for provide_expr in &module.provides {
-                // For whatever reason, the value coming into module.provides is an expression like: (provide expr...)
-                for provide in &provide_expr.list().unwrap().args[1..] {
-                    // println!("{}", provide);
-
-                    // println!("Top level provide handler");
-
-                    // Would be nice if this could be handled by some macro expansion...
-                    // See if contract/out
-
-                    let other_module_prefix =
-                        "mangler".to_string() + module.name.to_str().unwrap() + MANGLER_SEPARATOR;
-
-                    // TODO: Expand the contract out into something we expect
-                    // Otherwise, this is going to blow up
-                    match provide {
-                        ExprKind::List(l) => {
-                            if let Some(qualifier) = l.first_ident() {
-                                match *qualifier {
-                                    x if x == *CONTRACT_OUT => {
-                                        // Directly expand into define/contract, but with the value just being the hash get below
-
-                                        // (bind/c contract name 'name)
-
-                                        let name = l.args.get(1).unwrap();
-
-                                        if !explicit_requires.is_empty()
-                                            && !name
-                                                .atom_identifier()
-                                                .map(|x| explicit_requires.contains_key(x))
-                                                .unwrap_or_default()
-                                        {
-                                            continue;
-                                        }
-
-                                        // TODO: This should surface an error - cannot use contract
-                                        // out on a macro
-                                        if module
-                                            .macro_map
-                                            .contains_key(name.atom_identifier().unwrap())
-                                        {
-                                            continue;
-                                        }
-
-                                        // TODO: THe contract has to get mangled with the prefix as well?
-                                        let contract = l.args.get(2).unwrap();
-
-                                        let hash_get = expr_list![
-                                            ExprKind::ident("%proto-hash-get%"),
-                                            ExprKind::atom(
-                                                "__module-".to_string() + &other_module_prefix
-                                            ),
-                                            ExprKind::Quote(Box::new(Quote::new(
-                                                name.clone(),
-                                                SyntaxObject::default(TokenType::Quote)
-                                            ))),
-                                        ];
-
-                                        let mut owned_name = name.clone();
-
-                                        // If we have the alias listed, we should use it
-                                        if !explicit_requires.is_empty() {
-                                            if let Some(alias) = explicit_requires
-                                                .get(name.atom_identifier().unwrap())
-                                                .copied()
-                                                .flatten()
-                                            {
-                                                *owned_name.atom_identifier_mut().unwrap() =
-                                                    alias.clone();
-                                            }
-                                        }
-
-                                        if let Some(prefix) = &require_object.prefix {
-                                            if let Some(existing) = owned_name.atom_identifier_mut()
-                                            {
-                                                let mut prefixed_identifier = prefix.clone();
-                                                prefixed_identifier.push_str(existing.resolve());
-
-                                                // Update the existing identifier to point to a new one with the prefix applied
-                                                *existing = prefixed_identifier.into();
-                                            }
-                                        }
-
-                                        let define = ExprKind::Define(Box::new(Define::new(
-                                            owned_name,
-                                            hash_get,
-                                            SyntaxObject::default(TokenType::Define),
-                                        )));
-
-                                        require_defines.push(define);
-                                    }
-                                    x if x == *REQUIRE_IDENT_SPEC => {
-                                        // Directly expand into define/contract, but with the value just being the hash get below
-
-                                        // (bind/c contract name 'name)
-
-                                        let name = l.args.get(1).unwrap();
-
-                                        if !explicit_requires.is_empty()
-                                            && !name
-                                                .atom_identifier()
-                                                .map(|x| explicit_requires.contains_key(x))
-                                                .unwrap_or_default()
-                                        {
-                                            continue;
-                                        }
-
-                                        if module
-                                            .macro_map
-                                            .contains_key(name.atom_identifier().unwrap())
-                                        {
-                                            continue;
-                                        }
-
-                                        let hash_get = expr_list![
-                                            ExprKind::ident("%proto-hash-get%"),
-                                            ExprKind::atom(
-                                                "__module-".to_string() + &other_module_prefix
-                                            ),
-                                            ExprKind::Quote(Box::new(Quote::new(
-                                                name.clone(),
-                                                SyntaxObject::default(TokenType::Quote)
-                                            ))),
-                                        ];
-
-                                        let mut owned_name = name.clone();
-
-                                        // If we have the alias listed, we should use it
-                                        if !explicit_requires.is_empty() {
-                                            if let Some(alias) = explicit_requires
-                                                .get(name.atom_identifier().unwrap())
-                                                .copied()
-                                                .flatten()
-                                            {
-                                                *owned_name.atom_identifier_mut().unwrap() =
-                                                    alias.clone();
-                                            }
-                                        }
-
-                                        if let Some(prefix) = &require_object.prefix {
-                                            if let Some(existing) = owned_name.atom_identifier_mut()
-                                            {
-                                                let mut prefixed_identifier = prefix.clone();
-                                                prefixed_identifier.push_str(existing.resolve());
-
-                                                // Update the existing identifier to point to a new one with the prefix applied
-                                                *existing = prefixed_identifier.into();
-                                            }
-                                        }
-
-                                        let define = ExprKind::Define(Box::new(Define::new(
-                                            owned_name,
-                                            hash_get,
-                                            SyntaxObject::default(TokenType::Define),
-                                        )));
-
-                                        require_defines.push(define);
-                                    }
-                                    _ => {
-                                        stop!(TypeMismatch => format!("provide expects either an identifier, (for-syntax <ident>), or (contract/out ...), found: {}", provide))
-                                    }
-                                }
-                            } else {
-                                stop!(TypeMismatch => "provide expects either an identifier or a (for-syntax <ident>)")
-                            }
-                        }
-                        ExprKind::Atom(_) => {
-                            if !explicit_requires.is_empty()
-                                && !provide
-                                    .atom_identifier()
-                                    .map(|x| explicit_requires.contains_key(x))
-                                    .unwrap_or_default()
-                            {
-                                continue;
-                            }
-
-                            if module
-                                .macro_map
-                                .contains_key(provide.atom_identifier().unwrap())
-                            {
-                                continue;
-                            }
-
-                            let hash_get = expr_list![
-                                ExprKind::ident("%proto-hash-get%"),
-                                ExprKind::atom("__module-".to_string() + &other_module_prefix),
-                                ExprKind::Quote(Box::new(Quote::new(
-                                    provide.clone(),
-                                    SyntaxObject::default(TokenType::Quote)
-                                ))),
-                            ];
-
-                            let mut owned_provide = provide.clone();
-
-                            // If we have the alias listed, we should use it
-                            if !explicit_requires.is_empty() {
-                                if let Some(alias) = explicit_requires
-                                    .get(provide.atom_identifier().unwrap())
-                                    .copied()
-                                    .flatten()
-                                {
-                                    *owned_provide.atom_identifier_mut().unwrap() = alias.clone();
-                                }
-                            }
-
-                            // TODO: If there is a prefix applied, use it here?
-                            if let Some(prefix) = &require_object.prefix {
-                                if let Some(existing) = owned_provide.atom_identifier_mut() {
-                                    let mut prefixed_identifier = prefix.clone();
-                                    prefixed_identifier.push_str(existing.resolve());
-
-                                    // Update the existing identifier to point to a new one with the prefix applied
-                                    *existing = prefixed_identifier.into();
-                                }
-                            }
-
-                            let define = ExprKind::Define(Box::new(Define::new(
-                                owned_provide,
-                                hash_get,
-                                SyntaxObject::default(TokenType::Define),
-                            )));
-
-                            require_defines.push(define);
-                        }
-                        _ => {
-                            stop!(TypeMismatch => "provide expression needs to either be a `contract/out` form or an identifier")
-                        }
-                    }
-                }
-            }
-        }
-
-        let mut mangled_asts = Vec::new();
-
-        // TODO: Move this to the lower level as well
-        // It seems we're only doing this expansion at the top level, but we _should_ do this at the lower level as well
-        for require_object in module_builder.require_objects.iter()
-        // .filter(|x| x.for_syntax)
-        // .map(|x| x.path.get_path())
-        {
-            let require_for_syntax = require_object.path.get_path();
-
-            let (module, mut in_scope_macros, mut name_mangler) = Self::find_in_scope_macros(
-                &self.compiled_modules,
-                require_for_syntax.as_ref(),
-                &require_object,
-                &mut mangled_asts,
-            );
-
-            let kernel_macros_in_scope: HashSet<_> =
-                module.provides_for_syntax.iter().cloned().collect();
-
-            ast = ast
-                .into_iter()
-                .map(|x| {
-                    // @matt 12/8/2023
-                    // The easiest thing to do here, is to go to the other module, and find
-                    // what defmacros have been exposed on the require for syntax. Once those
-                    // have been found, we run a pass with kernel expansion, limiting the
-                    // expander to only use the macros that we've exposed. After that,
-                    // we run the expansion again, using the full suite of defmacro capabilities.
-                    //
-                    // The question that remains - how to define the neat phases of what kinds
-                    // of macros can expand into what? Can defmacro -> syntax-rules -> defmacro?
-                    // This could eventually prove to be cumbersome, but it is still early
-                    // for defmacro. Plus, I need to create a syntax-case or syntax-parse
-                    // frontend before the defmacro style macros become too pervasive.
-                    //
-                    // TODO: Replicate this behavior over to builtin modules
-
-                    // First expand the in scope macros
-                    // These are macros
-                    let mut expander = Expander::new(&in_scope_macros);
-                    let mut first_round_expanded = expander.expand(x)?;
-                    let mut changed = false;
-
-                    // (first_round_expanded, changed) = expand_kernel_in_env_with_allowed(
-                    //     first_round_expanded,
-                    //     kernel.as_mut(),
-                    //     // We don't need to expand those here
-                    //     ModuleContainer::default(),
-                    //     module.name.to_str().unwrap().to_string(),
-                    //     &kernel_macros_in_scope,
-                    // )?;
-
-                    // If the kernel expander expanded into something - go ahead
-                    // and expand all of the macros in this
-                    // if changed || expander.changed {
-                    // Expand here?
-                    // first_round_expanded = expand(first_round_expanded, &module.macro_map)?;
-
-                    // Probably don't need this
-                    // (first_round_expanded, changed) = expand_kernel_in_env_with_change(
-                    //     first_round_expanded,
-                    //     kernel.as_mut(),
-                    //     ModuleContainer::default(),
-                    //     module.name.to_str().unwrap().to_string(),
-                    // )?;
-
-                    // This is pretty suspect, and needs to be revisited - only the output of the
-                    // macro expansion and not the whole thing needs to be mangled most likely.
-                    // Otherwise, we'll run into weird stuff?
-                    // if changed {
-                    //     name_mangler.visit(&mut first_round_expanded);
-                    // }
-                    // }
-
-                    if expander.changed || changed {
-                        expand(first_round_expanded, &module.macro_map)
-                    } else {
-                        Ok(first_round_expanded)
-                    }
-                })
-                .collect::<Result<_>>()?;
-
-            global_macro_map.extend(in_scope_macros);
-        }
-
-        // Include the defines from the modules now imported
-        module_statements.append(&mut require_defines);
-
-        // The next two lines here expand _all_ of the source code with the top level macros
-        // This is necessary because of the std library macros, although this should be able to be
-        // solved with scoped imports of the standard library explicitly
-        module_statements.append(&mut ast);
-
-        // @Matt 7/4/23
-        // TODO: With mangling, this could cause problems. We'll want to un-mangle quotes AFTER the macro has been expanded,
-        // in order to preserve the existing behavior.
-        let result = module_statements
-            .into_iter()
-            .map(|x| expand(x, global_macro_map))
-            .collect::<Result<_>>();
-
-        result
-    }
-
-    fn find_in_scope_macros<'a>(
-        compiled_modules: &'a HashMap<PathBuf, CompiledModule>,
-        require_for_syntax: &'a PathBuf,
-        require_object: &'a RequireObject,
-        mangled_asts: &'a mut Vec<ExprKind>,
-    ) -> (
-        &'a CompiledModule,
-        HashMap<InternedString, SteelMacro>,
-        NameMangler,
-    ) {
-        let module = compiled_modules
-            .get(require_for_syntax)
-            .expect(&format!("Module missing!: {:?}", require_for_syntax));
-
-        let prefix = "mangler".to_string() + module.name.to_str().unwrap() + MANGLER_SEPARATOR;
-
-        let globals = collect_globals(&module.ast);
-
-        let mut name_mangler = NameMangler::new(globals, prefix);
-
-        // If the module hasn't been emitted already, then include it here
-        if !module.emitted {
-            let mut module_ast = module.ast.clone();
-
-            name_mangler.mangle_vars(&mut module_ast);
-
-            mangled_asts.append(&mut module_ast);
-        }
-
-        // let provided_macros = module.provides_for
-        // let expander = Expander::new(&module.macro_map);
-        // TODO
-        // expand expressions one by one
-        // if expansion with _just_ public macros from the required module doesn't do anything, stop
-        // if it _does_ change, do another pass with all of the macros in scope
-        // do this for each of the expressions in the file in this loop
-        // TODO -> try not cloning this
-        // TODO -> do this in the module expansion as well
-        let mut in_scope_macros = module
-            .provides_for_syntax
-            .iter()
-            // Chain with just the normal provides!
-            // .chain(module.provides)
-            .filter_map(|x| module.macro_map.get(x).map(|m| (*x, m.clone()))) // TODO -> fix this unwrap
-            .map(|mut x| {
-                for expr in x.1.exprs_mut() {
-                    name_mangler.visit(expr);
-                }
-
-                x
-            })
-            .collect::<HashMap<_, _>>();
-
-        // If the require_object specifically imports things, we should reference it
-
-        if !require_object.idents_to_import.is_empty() {
-            for maybe in &require_object.idents_to_import {
-                match maybe {
-                    MaybeRenamed::Normal(n) => {
-                        if let Some(ident) = n.atom_identifier() {
-                            if let Some(mut m) = module.macro_map.get(ident).cloned() {
-                                for expr in m.exprs_mut() {
-                                    name_mangler.visit(expr);
-                                }
-
-                                if let Some(prefix) = &require_object.prefix {
-                                    in_scope_macros
-                                        .insert((prefix.to_string() + ident.resolve()).into(), m);
-                                } else {
-                                    in_scope_macros.insert(*ident, m);
-                                }
-                            }
-                        }
-                    }
-                    MaybeRenamed::Renamed(from, to) => {
-                        if let Some(ident) = from.atom_identifier() {
-                            if let Some(mut m) = module.macro_map.get(ident).cloned() {
-                                for expr in m.exprs_mut() {
-                                    name_mangler.visit(expr);
-                                }
-                                // TODO: Remove this unwrap
-                                // in_scope_macros.insert(*to.atom_identifier().unwrap(), m);
-
-                                if let Some(prefix) = &require_object.prefix {
-                                    in_scope_macros.insert(
-                                        (prefix.to_string()
-                                            + to.atom_identifier().unwrap().resolve())
-                                        .into(),
-                                        m,
-                                    );
-                                } else {
-                                    in_scope_macros.insert(*to.atom_identifier().unwrap(), m);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        } else {
-            // Pull in all of the macros that the module exposes
-
-            for provide_expr in &module.provides {
-                if let Some(provide_expr) = provide_expr.list() {
-                    for ident in provide_expr.args.split_first().unwrap().1 {
-                        // println!("Looking for {}", ident);
-
-                        if let Some(ident) = ident.atom_identifier() {
-                            if let Some(mut m) = module.macro_map.get(ident).cloned() {
-                                // println!("Pulling in macro: {}", ident);
-
-                                for expr in m.exprs_mut() {
-                                    name_mangler.visit(expr);
-                                }
-
-                                if let Some(prefix) = &require_object.prefix {
-                                    in_scope_macros
-                                        .insert((prefix.to_string() + ident.resolve()).into(), m);
-                                } else {
-                                    in_scope_macros.insert(*ident, m);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Check what macros are in scope here
-        // println!(
-        //     "In scope macros: {:#?}",
-        //     in_scope_macros.keys().collect::<Vec<_>>()
-        // );
-        (module, in_scope_macros, name_mangler)
-    }
-
-    #[cfg(not(feature = "modules"))]
-    pub(crate) fn expand_expressions(
-        &mut self,
-        global_macro_map: &mut HashMap<InternedString, SteelMacro>,
-        exprs: Vec<ExprKind>,
-    ) -> Result<Vec<ExprKind>> {
-        let non_macro_expressions = extract_macro_defs(exprs, global_macro_map)?;
-        non_macro_expressions
-            .into_iter()
-            .map(|x| expand(x, global_macro_map))
-            .collect()
-    }
-}
-
-// Pre-compile module to bytecode? Is it even possible?
-// Dynamically linking the module would then make it relatively
-// easy to just load everything up at the start.
-// Compiled module _should_ be possible now. Just create a target
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct CompiledModule {
-    name: PathBuf,
-    provides: Vec<ExprKind>,
-    require_objects: Vec<RequireObject>,
-    provides_for_syntax: Vec<InternedString>,
-    pub(crate) macro_map: HashMap<InternedString, SteelMacro>,
-    ast: Vec<ExprKind>,
-    emitted: bool,
-}
-
-// TODO: @Matt 6/12/23 - This _should_ be serializable. If possible, we can try to store intermediate objects down to some file.
-impl CompiledModule {
-    pub fn new(
-        name: PathBuf,
-        provides: Vec<ExprKind>,
-        require_objects: Vec<RequireObject>,
-        provides_for_syntax: Vec<InternedString>,
-        macro_map: HashMap<InternedString, SteelMacro>,
-        ast: Vec<ExprKind>,
-    ) -> Self {
-        Self {
-            name,
-            provides,
-            require_objects,
-            provides_for_syntax,
-            macro_map,
-            ast,
-            emitted: false,
-        }
-    }
-
-    pub fn get_ast(&self) -> &[ExprKind] {
-        &self.ast
-    }
-
-    pub fn get_provides(&self) -> &[ExprKind] {
-        &self.provides
-    }
-
-    // pub fn get_requires(&self) -> &[PathBuf] {
-    //     &self.requires
-    // }
-
-    pub fn set_emitted(&mut self, emitted: bool) {
-        self.emitted = emitted;
-    }
-
-    fn to_top_level_module(
-        &self,
-        modules: &HashMap<PathBuf, CompiledModule>,
-        global_macro_map: &HashMap<InternedString, SteelMacro>,
-    ) -> Result<ExprKind> {
-        let mut globals = collect_globals(&self.ast);
-
-        let mut exprs = self.ast.clone();
-
-        let mut provide_definitions = Vec::new();
-
-        let prefix = "mangler".to_string() + self.name.to_str().unwrap() + MANGLER_SEPARATOR;
-
-        // Now we should be able to set up a series of requires with the right style
-        // ;; Refresh the module definition in this namespace
-        // (define a-module.rkt-b (hash-get 'b b-module.rkt-b))
-
-        let mut explicit_requires = HashMap::new();
-
-        // TODO: This is the same as the top level, they should be merged
-        for require_object in &self.require_objects {
-            let path = require_object.path.get_path();
-
-            explicit_requires.clear();
-
-            for ident in &require_object.idents_to_import {
-                match ident {
-                    MaybeRenamed::Normal(i) => {
-                        explicit_requires.insert(i.atom_identifier().unwrap().clone(), None);
-                    }
-                    MaybeRenamed::Renamed(from, to) => {
-                        explicit_requires.insert(
-                            from.atom_identifier().unwrap().clone(),
-                            Some(to.atom_identifier().unwrap().clone()),
-                        );
-                    }
-                }
-            }
-
-            // println!("{:?}", path);
-            // println!("{:?}", modules.keys().collect::<Vec<_>>());
-            let module = modules.get(path.as_ref()).unwrap();
-
-            let other_module_prefix =
-                "mangler".to_string() + module.name.to_str().unwrap() + MANGLER_SEPARATOR;
-
-            for provide_expr in &module.provides {
-                // For whatever reason, the value coming into module.provides is an expression like: (provide expr...)
-                for provide in &provide_expr.list().unwrap().args[1..] {
-                    match provide {
-                        ExprKind::List(l) => {
-                            if let Some(qualifier) = l.first_ident() {
-                                if module.macro_map.contains_key(qualifier) {
-                                    continue;
-                                }
-
-                                match *qualifier {
-                                    x if x == *REQUIRE_IDENT_SPEC => {
-                                        // Directly expand into define/contract, but with the value just being the hash get below
-
-                                        // (bind/c contract name 'name)
-
-                                        let name = l.args.get(1).unwrap();
-
-                                        if !explicit_requires.is_empty()
-                                            && !name
-                                                .atom_identifier()
-                                                .map(|x| explicit_requires.contains_key(x))
-                                                .unwrap_or_default()
-                                        {
-                                            continue;
-                                        }
-
-                                        if module
-                                            .macro_map
-                                            .contains_key(name.atom_identifier().unwrap())
-                                        {
-                                            continue;
-                                        }
-
-                                        let hash_get = expr_list![
-                                            ExprKind::ident("%proto-hash-get%"),
-                                            ExprKind::atom(
-                                                "__module-".to_string() + &other_module_prefix
-                                            ),
-                                            ExprKind::Quote(Box::new(Quote::new(
-                                                name.clone(),
-                                                SyntaxObject::default(TokenType::Quote)
-                                            ))),
-                                        ];
-
-                                        let mut owned_name = name.clone();
-
-                                        // If we have the alias listed, we should use it
-                                        if !explicit_requires.is_empty() {
-                                            if let Some(alias) = explicit_requires
-                                                .get(name.atom_identifier().unwrap())
-                                                .copied()
-                                                .flatten()
-                                            {
-                                                *owned_name.atom_identifier_mut().unwrap() =
-                                                    alias.clone();
-                                            }
-                                        }
-
-                                        if let Some(prefix) = &require_object.prefix {
-                                            if let Some(existing) = owned_name.atom_identifier_mut()
-                                            {
-                                                let mut prefixed_identifier = prefix.clone();
-                                                prefixed_identifier.push_str(existing.resolve());
-
-                                                // Update the existing identifier to point to a new one with the prefix applied
-                                                *existing = prefixed_identifier.into();
-                                            }
-                                        }
-
-                                        globals.insert(*name.atom_identifier().unwrap());
-
-                                        let define = ExprKind::Define(Box::new(Define::new(
-                                            owned_name,
-                                            hash_get,
-                                            SyntaxObject::default(TokenType::Define),
-                                        )));
-
-                                        provide_definitions.push(define);
-                                    }
-
-                                    x if x == *CONTRACT_OUT => {
-                                        // Directly expand into define/contract, but with the value just being the hash get below
-
-                                        // (bind/c contract name 'name)
-
-                                        let mut name = l.args.get(1).unwrap().clone();
-                                        let contract = l.args.get(2).unwrap();
-
-                                        if !explicit_requires.is_empty()
-                                            && !name
-                                                .atom_identifier()
-                                                .map(|x| explicit_requires.contains_key(x))
-                                                .unwrap_or_default()
-                                        {
-                                            continue;
-                                        }
-
-                                        // If we have the alias listed, we should use it
-                                        if !explicit_requires.is_empty() {
-                                            if let Some(alias) = explicit_requires
-                                                .get(name.atom_identifier().unwrap())
-                                                .copied()
-                                                .flatten()
-                                            {
-                                                *name.atom_identifier_mut().unwrap() =
-                                                    alias.clone();
-                                            }
-                                        }
-
-                                        if let Some(prefix) = &require_object.prefix {
-                                            if let Some(existing) = name.atom_identifier_mut() {
-                                                let mut prefixed_identifier = prefix.clone();
-                                                prefixed_identifier.push_str(existing.resolve());
-
-                                                // Update the existing identifier to point to a new one with the prefix applied
-                                                *existing = prefixed_identifier.into();
-                                            }
-                                        }
-
-                                        // Since this is now bound to be in the scope of the current working module, we also want
-                                        // this to be mangled. In the event we do something like, qualify the import, then we might
-                                        // have to mangle this differently
-                                        globals.insert(*name.atom_identifier().unwrap());
-
-                                        let hash_get = expr_list![
-                                            ExprKind::ident("%proto-hash-get%"),
-                                            ExprKind::atom(
-                                                "__module-".to_string() + &other_module_prefix
-                                            ),
-                                            ExprKind::Quote(Box::new(Quote::new(
-                                                name.clone(),
-                                                SyntaxObject::default(TokenType::Quote)
-                                            ))),
-                                        ];
-
-                                        let define = ExprKind::Define(Box::new(Define::new(
-                                            ExprKind::atom(
-                                                prefix.clone()
-                                                    + name.atom_identifier().unwrap().resolve(),
-                                            ),
-                                            hash_get,
-                                            SyntaxObject::default(TokenType::Define),
-                                        )));
-
-                                        provide_definitions.push(define);
-                                    }
-                                    _ => {
-                                        stop!(TypeMismatch => format!("provide expects either an identifier, (for-syntax <ident>), or (contract/out ...) - found: {}", provide))
-                                    }
-                                }
-                            } else {
-                                stop!(TypeMismatch => "provide expects either an identifier or a (for-syntax <ident>)")
-                            }
-                        }
-                        ExprKind::Atom(_) => {
-                            if !explicit_requires.is_empty()
-                                && !provide
-                                    .atom_identifier()
-                                    .map(|x| explicit_requires.contains_key(x))
-                                    .unwrap_or_default()
-                            {
-                                continue;
-                            }
-
-                            if module
-                                .macro_map
-                                .contains_key(provide.atom_identifier().unwrap())
-                            {
-                                continue;
-                            }
-
-                            // Mangle with a prefix if necessary
-                            let mut provide = provide.clone();
-
-                            // If we have the alias listed, we should use it
-                            if !explicit_requires.is_empty() {
-                                if let Some(alias) = explicit_requires
-                                    .get(provide.atom_identifier().unwrap())
-                                    .copied()
-                                    .flatten()
-                                {
-                                    *provide.atom_identifier_mut().unwrap() = alias.clone();
-                                }
-                            }
-
-                            if let Some(prefix) = &require_object.prefix {
-                                if let Some(existing) = provide.atom_identifier_mut() {
-                                    let mut prefixed_identifier = prefix.clone();
-                                    prefixed_identifier.push_str(existing.resolve());
-
-                                    // Update the existing identifier to point to a new one with the prefix applied
-                                    *existing = prefixed_identifier.into();
-                                }
-                            }
-
-                            let provide_ident = provide.atom_identifier().unwrap();
-
-                            // Since this is now bound to be in the scope of the current working module, we also want
-                            // this to be mangled. In the event we do something like, qualify the import, then we might
-                            // have to mangle this differently
-                            globals.insert(*provide_ident);
-
-                            let define = ExprKind::Define(Box::new(Define::new(
-                                ExprKind::atom(prefix.clone() + provide_ident.resolve()),
-                                expr_list![
-                                    ExprKind::ident("%proto-hash-get%"),
-                                    ExprKind::atom("__module-".to_string() + &other_module_prefix),
-                                    ExprKind::Quote(Box::new(Quote::new(
-                                        provide.clone(),
-                                        SyntaxObject::default(TokenType::Quote)
-                                    )))
-                                ],
-                                SyntaxObject::default(TokenType::Define),
-                            )));
-
-                            provide_definitions.push(define);
-                        }
-                        _ => {
-                            stop!(TypeMismatch => "provide expression needs to either be a `contract/out` form or an identifier")
-                        }
-                    }
-                }
-            }
-        }
-
-        // Mangle all of the variables that are either:
-        // 1. Defined locally in this file
-        // 2. Required by another file
-        let mut name_mangler = NameMangler::new(globals, prefix.clone());
-
-        // Afterwards, walk through and unmangle any quoted values, since these
-        // were intended to be used with non mangled values.
-        let mut name_unmangler = NameUnMangler::new(&prefix);
-
-        name_mangler.mangle_vars(&mut exprs);
-
-        // The provide definitions should also be mangled
-        name_mangler.mangle_vars(&mut provide_definitions);
-
-        // let mut hash_builder = Vec::new();
-
-        // These are gonna be the pairs
-        // hash_builder.push(());
-
-        // Construct the series of provides as well, we'll want these to refer to the correct values
-        //
-        let mut provides: Vec<_> = self
-            .provides
-            .iter()
-            .flat_map(|x| &x.list().unwrap().args[1..])
-            .cloned()
-            .map(|x| (x.clone(), x))
-            .collect();
-
-        for provide in &mut provides {
-            match &provide.1 {
-                ExprKind::List(l) => {
-                    if let Some(qualifier) = l.first_ident() {
-                        match qualifier {
-                            x if *x == *REQUIRE_IDENT_SPEC => {
-                                // *provide = expand(l.get(2).unwrap().clone(), global_macro_map)?;
-
-                                // *provide = expand(l.)
-
-                                provide.0 = l.get(1).unwrap().clone();
-                                provide.1 = expand(l.get(2).unwrap().clone(), global_macro_map)?;
-
-                                continue;
-
-                                // name_unmangler.unmangle_expr(provide);
-                            }
-                            x if *x == *CONTRACT_OUT => {
-                                // Update the item to point to just the name
-                                //
-                                // *provide = l.get(1).unwrap().clone();
-                                // {
-                                //     println!("---------");
-                                //     println!("Provide expr: {}", l.to_string());
-                                // }
-
-                                provide.0 = l.get(1).unwrap().clone();
-                                provide.1 = expand(
-                                    expr_list![
-                                        ExprKind::ident("bind/c"),
-                                        l.get(2).unwrap().clone(),
-                                        l.get(1).unwrap().clone(),
-                                        ExprKind::Quote(Box::new(Quote::new(
-                                            l.get(1).unwrap().clone(),
-                                            SyntaxObject::default(TokenType::Quote)
-                                        ))),
-                                    ],
-                                    global_macro_map,
-                                )?;
-
-                                // println!("-------- {}", provide.to_pretty(60));
-
-                                name_unmangler.unmangle_expr(&mut provide.1);
-                                // continue;
-                            }
-                            _ => {
-                                stop!(TypeMismatch => "bar provide expects either an identifier, (for-syntax <ident>), or (contract/out ...)")
-                            }
-                        }
-                    } else {
-                        stop!(TypeMismatch => "provide expects either an identifier or a (for-syntax <ident>)")
-                    }
-                }
-                ExprKind::Atom(_) => {
-                    continue;
-                }
-                _ => {
-                    stop!(TypeMismatch => "provide expression needs to either be a `contract/out` form or an identifier")
-                }
-            }
-        }
-
-        // Drop all of the macro references here
-        provides.retain(|x| !self.macro_map.contains_key(x.0.atom_identifier().unwrap()));
-
-        // We want one without the mangled version, for the actual provides
-        let un_mangled = provides.clone();
-
-        let left_unmangled: Vec<_> = un_mangled.into_iter().map(|x| x.0).collect();
-
-        let mut right: Vec<_> = provides.into_iter().map(|x| x.1).collect();
-
-        name_mangler.mangle_vars(&mut right);
-        // name_unmangler.unmangle_vars(&mut provides);
-
-        let mut hash_body = vec![ExprKind::ident("hash")];
-
-        // We can put the module name in there, but that doesn't help us get the docs out...
-        // Probably need to just store the docs directly in the module itself as well?
-        // hash_body.push(ExprKind::atom("#:module-name"));
-        // hash_body.push(ExprKind::atom(prefix.clone()));
-
-        // left_unmangled.pretty_print();
-
-        hash_body.extend(interleave(
-            left_unmangled.into_iter().map(|x| {
-                if let ExprKind::Atom(_) = x {
-                    ExprKind::Quote(Box::new(Quote::new(
-                        x,
-                        SyntaxObject::default(TokenType::Quote),
-                    )))
-                } else if let ExprKind::List(l) = x {
-                    if let Some(qualifier) = l.first_ident() {
-                        match qualifier {
-                            x if *x == *REQUIRE_IDENT_SPEC => {
-                                todo!()
-                            }
-                            _ => {
-                                return ExprKind::Quote(Box::new(Quote::new(
-                                    l.get(2).unwrap().clone(),
-                                    SyntaxObject::default(TokenType::Quote),
-                                )))
-                            }
-                        }
-                    }
-
-                    // Then this is a contract out, and we should handle it here
-
-                    ExprKind::Quote(Box::new(Quote::new(
-                        l.get(2).unwrap().clone(),
-                        SyntaxObject::default(TokenType::Quote),
-                    )))
-                    // ExprKind::Quote(Box::new(Quote::new(
-                    //     x,
-                    //     SyntaxObject::default(TokenType::Quote),
-                    // )))
-                } else {
-                    panic!("TODO this shouldn't be possible")
-                }
-            }),
-            right,
-        ));
-
-        let module_define = ExprKind::Define(Box::new(Define::new(
-            ExprKind::atom("__module-".to_string() + &prefix),
-            ExprKind::List(List::new(hash_body)),
-            SyntaxObject::default(TokenType::Quote),
-        )));
-
-        // println!("------ {}", module_define.to_pretty(60));
-
-        exprs.push(module_define);
-
-        // Construct the overall definition
-        // TODO: Perhaps mangle these as well, especially if they have contracts associated with them
-        provide_definitions.append(&mut exprs);
-
-        // Try this out?
-        // let mut analysis = Analysis::from_exprs(&provide_definitions);
-        // let mut semantic = SemanticAnalysis::from_analysis(&mut provide_definitions, analysis);
-
-        // // This is definitely broken still
-        // semantic.remove_unused_globals_with_prefix("mangler");
-        // .replace_non_shadowed_globals_with_builtins()
-        // .remove_unused_globals_with_prefix("mangler");
-
-        // println!("------ {}", provide_definitions.to_pretty(60));
-
-        Ok(ExprKind::Begin(Begin::new(
-            provide_definitions,
-            SyntaxObject::default(TokenType::Begin),
-        )))
-    }
-
-    // Turn the module into the AST node that represents the macro module in the stdlib
-    fn _to_module_ast_node(&self) -> ExprKind {
-        let mut body = vec![
-            ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-                "module".into(),
-            )))),
-            ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-                ("___".to_string() + self.name.to_str().unwrap()).into(),
-            )))),
-        ];
-
-        // Put any provides at the top
-        body.append(&mut self.provides.clone());
-
-        // Include any dependencies here
-        // body.append(&mut self.requires.clone());
-
-        // TODO: @Matt 10/8/22
-        // Reconsider how to address this expansion.
-        // We really don't want to pollute the module space - perhaps disallow shadowed built-ins so we don't need this?
-        // That would probably be annoying
-        // let steel_base = ExprKind::List(List::new(vec![ExprKind::atom("steel/base".to_string())]));
-
-        // self.ast.pretty_print();
-
-        // body.push(steel_base);
-
-        // Put the ast nodes inside the macro
-        body.append(&mut self.ast.clone());
-
-        // TODO clean this up
-        let res = ExprKind::List(List::new(body));
-
-        // if log_enabled!(target: "requires", log::Level::Debug) {
-        //     debug!(target: "requires", "Module ast node: {}", res.to_string());
-        // }
-
-        res
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
-enum MaybeRenamed {
-    Normal(ExprKind),
-    Renamed(ExprKind, ExprKind),
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-pub struct RequireObject {
-    path: PathOrBuiltIn,
-    for_syntax: bool,
-    idents_to_import: Vec<MaybeRenamed>,
-    prefix: Option<String>,
-}
-
-#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
-enum PathOrBuiltIn {
-    BuiltIn(Cow<'static, str>),
-    Path(PathBuf),
-}
-
-impl PathOrBuiltIn {
-    pub fn get_path(&self) -> Cow<'_, PathBuf> {
-        match self {
-            Self::Path(p) => Cow::Borrowed(p),
-            Self::BuiltIn(p) => Cow::Owned(PathBuf::from(p.to_string())),
-        }
-    }
-}
-
-#[derive(Default, Debug, Clone)]
-struct RequireObjectBuilder {
-    path: Option<PathOrBuiltIn>,
-    for_syntax: bool,
-    idents_to_import: Vec<MaybeRenamed>,
-    // Built up prefix
-    prefix: Option<String>,
-}
-
-impl RequireObjectBuilder {
-    fn build(self) -> Result<RequireObject> {
-        let path = self
-            .path
-            .ok_or_else(crate::throw!(Generic => "require must have a path!"))?;
-
-        Ok(RequireObject {
-            path,
-            for_syntax: self.for_syntax,
-            idents_to_import: self.idents_to_import,
-            prefix: self.prefix,
-        })
-    }
-}
-
-struct ModuleBuilder<'a> {
-    name: PathBuf,
-    main: bool,
-    source_ast: Vec<ExprKind>,
-    macro_map: HashMap<InternedString, SteelMacro>,
-    // TODO: Change the requires / requires_for_syntax to just be a require enum?
-    require_objects: Vec<RequireObject>,
-
-    provides: Vec<ExprKind>,
-    provides_for_syntax: Vec<ExprKind>,
-    compiled_modules: &'a mut HashMap<PathBuf, CompiledModule>,
-    visited: &'a mut HashSet<PathBuf>,
-    file_metadata: &'a mut HashMap<PathBuf, SystemTime>,
-    sources: &'a mut Sources,
-    kernel: &'a mut Option<Kernel>,
-    builtin_modules: ModuleContainer,
-    global_macro_map: &'a HashMap<InternedString, SteelMacro>,
-    custom_builtins: &'a HashMap<String, String>,
-}
-
-impl<'a> ModuleBuilder<'a> {
-    #[allow(clippy::too_many_arguments)]
-    #[allow(unused)]
-    fn main(
-        name: Option<PathBuf>,
-        source_ast: Vec<ExprKind>,
-        compiled_modules: &'a mut HashMap<PathBuf, CompiledModule>,
-        visited: &'a mut HashSet<PathBuf>,
-        file_metadata: &'a mut HashMap<PathBuf, SystemTime>,
-        sources: &'a mut Sources,
-        kernel: &'a mut Option<Kernel>,
-        builtin_modules: ModuleContainer,
-        global_macro_map: &'a HashMap<InternedString, SteelMacro>,
-        custom_builtins: &'a HashMap<String, String>,
-    ) -> Result<Self> {
-        // TODO don't immediately canonicalize the path unless we _know_ its coming from a path
-        // change the path to not always be required
-        // if its not required we know its not coming in
-
-        let name = if let Some(p) = name {
-            std::fs::canonicalize(p)?
-        } else {
-            std::env::current_dir()?
-        };
-
-        Ok(ModuleBuilder {
-            name,
-            main: true,
-            source_ast,
-            macro_map: DEFAULT_PRELUDE_MACROS.with(|x| x.borrow().clone()),
-            require_objects: Vec::new(),
-            provides: Vec::new(),
-            provides_for_syntax: Vec::new(),
-            compiled_modules,
-            visited,
-            file_metadata,
-            sources,
-            kernel,
-            builtin_modules,
-            global_macro_map,
-            custom_builtins,
-        })
-    }
-
-    fn compile(&mut self) -> Result<Vec<ExprKind>> {
-        // debug!(target: "requires", "Visiting: {:?}", self.name);
-
-        // @Matt - 10/3/23
-        // This has a relatively fatal flaw at the moment:
-        /*
-
-            (define-syntax register-plugin
-              (syntax-rules ()
-                [(register-plugin plugin-path identifiers ...)
-                 (begin
-                   (require plugin-path
-                            (only-in identifiers ...))
-                   (provide identifiers ...))]))
-        */
-        // This will fail to compile - anything that expands into a require will fail since
-        // require is more or less a top level primitive. What we need to do is figure
-        // out a way to have this be recursive - the whole compilation step should
-        // go again once we discover that there is another require. It shouldn't be too bad,
-        // but the base case has to be figured out such that we don't get infinite recursion.
-        // I think the condition is probably something along the following:
-        //
-        // - Did we expand anything
-        // - Are there require statements
-        //
-        // If we expanded anything, we then should check for require statements... maybe
-
-        let mut new_exprs = Vec::new();
-
-        // self.source_ast.pretty_print();
-
-        self.collect_requires()?;
-        self.collect_provides()?;
-
-        if log_enabled!(log::Level::Info) {
-            // debug!(target: "requires", "Requires: {:#?}", self.require_objects);
-            // debug!(target: "requires", "Provides: {:#?}", self.provides);
-            // debug!(target: "requires", "Provides for-syntax: {:?}", self.provides_for_syntax);
-        }
-
-        if self.visited.contains(&self.name) {
-            stop!(Generic => format!("circular dependency found during module resolution with: {:?}", self.name))
-        }
-
-        self.visited.insert(self.name.clone());
-
-        if self.main {
-            let exprs = std::mem::take(&mut self.source_ast);
-            self.source_ast = exprs
-                .into_iter()
-                .filter(|x| {
-                    if let ExprKind::List(l) = x {
-                        if let Some(provide) = l.first_ident() {
-                            return *provide != *PROVIDE;
-                        }
-                    }
-                    true
-                })
-                .collect();
-        }
-
-        self.extract_macro_defs()?;
-
-        // TODO include built ins here
-        if self.require_objects.is_empty() && !self.main {
-            // We're at a leaf, put into the cache
-            new_exprs.push(self.compile_module()?);
-        } else {
-            // TODO come back for parsing built ins
-            for module in self
-                .require_objects
-                .iter()
-                .filter(|x| matches!(x.path, PathOrBuiltIn::BuiltIn(_)))
-                .map(|x| x.path.get_path())
-            {
-                // We've established nothing has changed with this file
-                // Check to see if its in the cache first
-                // Otherwise go ahead and compile
-                // If we already have compiled this module, get it from the cache
-                if let Some(_m) = self.compiled_modules.get(module.as_ref()) {
-                    // debug!("Getting {:?} from the module cache", module);
-                    // println!("Already found in the cache: {:?}", module);
-                    // new_exprs.push(m.to_module_ast_node());
-                    // No need to do anything
-                    continue;
-                }
-
-                // TODO this is some bad crap here don't do this
-                let input = BUILT_INS
-                    .iter()
-                    .find(|x| x.0 == module.to_str().unwrap())
-                    .map(|x| x.1)
-                    .or_else(|| {
-                        self.custom_builtins
-                            .get(module.to_str().unwrap())
-                            .map(|x| x.as_str())
-                    })
-                    .ok_or_else(
-                        crate::throw!(Generic => "Unable to find builtin module: {:?}", module),
-                    )?;
-
-                let mut new_module = ModuleBuilder::new_built_in(
-                    module.into_owned(),
-                    input,
-                    self.compiled_modules,
-                    self.visited,
-                    self.file_metadata,
-                    self.sources,
-                    self.kernel,
-                    self.builtin_modules.clone(),
-                    self.global_macro_map,
-                    self.custom_builtins,
-                )?;
-
-                // Walk the tree and compile any dependencies
-                // This will eventually put the module in the cache
-                let mut module_exprs = new_module.compile()?;
-
-                new_exprs.append(&mut module_exprs);
-
-                // Probably want to evaluate a module even if it has no provides?
-                if !new_module.provides.is_empty() {
-                    new_exprs.push(new_module.compile_module()?);
-                } else {
-                    // log::debug!(target: "requires", "Found no provides, skipping compilation of module: {:?}", new_module.name);
-                }
-            }
-
-            // At this point, requires should be fully qualified (absolute) paths
-
-            for module in self
-                .require_objects
-                .iter()
-                .filter(|x| matches!(x.path, PathOrBuiltIn::Path(_)))
-                .map(|x| x.path.get_path())
-            {
-                let last_modified = std::fs::metadata(module.as_ref())?.modified()?;
-
-                // Check if we should compile based on the last time modified
-                // If we're unable to get information, we want to compile
-                let should_recompile =
-                    if let Some(cached_modified) = self.file_metadata.get(module.as_ref()) {
-                        &last_modified != cached_modified
-                    } else {
-                        true
-                    };
-
-                // We've established nothing has changed with this file
-                // Check to see if its in the cache first
-                // Otherwise go ahead and compile
-                if !should_recompile {
-                    // If we already have compiled this module, get it from the cache
-                    if let Some(_m) = self.compiled_modules.get(module.as_ref()) {
-                        // debug!("Getting {:?} from the module cache", module);
-                        // println!("Already found in the cache: {:?}", module);
-                        // new_exprs.push(m.to_module_ast_node());
-                        // No need to do anything
-                        continue;
-                    }
-                }
-
-                let mut new_module = ModuleBuilder::new_from_path(
-                    module.into_owned(),
-                    self.compiled_modules,
-                    self.visited,
-                    self.file_metadata,
-                    self.sources,
-                    self.kernel,
-                    self.builtin_modules.clone(),
-                    self.global_macro_map,
-                    self.custom_builtins,
-                )?;
-
-                // Walk the tree and compile any dependencies
-                // This will eventually put the module in the cache
-                let mut module_exprs = new_module.compile()?;
-
-                // debug!("Inside {:?} - append {:?}", self.name, module);
-                // if log_enabled!(log::Level::Debug) {
-                //     debug!(
-                //         target: "modules",
-                //         "appending with {:?}",
-                //         module_exprs.iter().map(|x| x.to_string()).join(" SEP ")
-                //     );
-                // }
-
-                new_exprs.append(&mut module_exprs);
-
-                // TODO evaluate this
-
-                // let mut ast = std::mem::replace(&mut new_module.source_ast, Vec::new());
-                // ast.append(&mut module_exprs);
-                // new_module.source_ast = ast;
-
-                // dbg!(&new_module.name);
-                // dbg!(&new_module.compiled_modules.contains_key(&new_module.name));
-
-                // If we need to, revisit because there are new provides
-                if !new_module.provides.is_empty() {
-                    new_exprs.push(new_module.compile_module()?);
-                // If the module hasn't yet been compiled, compile it anyway
-                } else if !new_module.compiled_modules.contains_key(&new_module.name) {
-                    // else if !new_module.compiled_modules.contains_key(&new_module.name) {
-                    new_exprs.push(new_module.compile_module()?);
-                } else {
-                    // log::debug!(target: "requires", "Found no provides, skipping compilation of module: {:?}", new_module.name);
-                    // log::debug!(target: "requires", "Module already in the cache: {}", new_module.compiled_modules.contains_key(&new_module.name));
-                    // log::debug!(target: "requires", "Compiled modules: {:?}", new_module.compiled_modules.keys().collect::<Vec<_>>());
-                }
-
-                // else {
-                //     log::debug!(target: "requires", "Found no provides, skipping compilation of module: {:?}", new_module.name);
-                // }
-            }
-        }
-
-        // new_exprs.pretty_print();
-
-        Ok(new_exprs)
-    }
-
-    // TODO: This should run again on itself, probably
-    fn compile_module(&mut self) -> Result<ExprKind> {
-        let mut ast = std::mem::take(&mut self.source_ast);
-        let mut provides = std::mem::take(&mut self.provides);
-        // Clone the requires... I suppose
-        let requires = self.require_objects.clone();
-
-        // info!(
-        //     target: "requires",
-        //     "Into compiled module: provides for syntax: {:?}",
-        //     self.provides_for_syntax
-        // );
-
-        // Attempt extracting the syntax transformers from this module
-        if let Some(kernel) = self.kernel.as_mut() {
-            kernel.load_syntax_transformers(&mut ast, self.name.to_str().unwrap().to_string())?
-        };
-
-        // Expand first with the macros from *this* module
-        ast = ast
-            .into_iter()
-            .map(|x| {
-                expand(x, &self.macro_map)
-                    .and_then(|x| {
-                        expand_kernel_in_env(
-                            x,
-                            self.kernel.as_mut(),
-                            self.builtin_modules.clone(),
-                            // Expanding macros in the environment?
-                            self.name.to_str().unwrap().to_string(),
-                        )
-                    })
-                    // Check here - I think it makes sense to expand the
-                    // internal macros again, given now we might have defmacro
-                    // style macros that get expanded into syntax-rules ones?
-                    .and_then(|x| expand(x, &self.macro_map))
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        // Expand provides for any macros that exist within there
-        provides = provides
-            .into_iter()
-            .map(|x| {
-                expand(x, &self.macro_map).and_then(|x| {
-                    // expand_kernel(x, self.kernel.as_mut(), self.builtin_modules.clone())
-                    expand_kernel_in_env(
-                        x,
-                        self.kernel.as_mut(),
-                        self.builtin_modules.clone(),
-                        // Expanding macros in the environment?
-                        self.name.to_str().unwrap().to_string(),
-                    )
-                })
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        let mut mangled_asts = Vec::new();
-
-        // Look for the modules in the requires for syntax
-        for require_object in self.require_objects.iter()
-        // .filter(|x| x.for_syntax)
-        {
-            let require_for_syntax = require_object.path.get_path();
-
-            let (module, in_scope_macros, mut name_mangler) = ModuleManager::find_in_scope_macros(
-                self.compiled_modules,
-                require_for_syntax.as_ref(),
-                &require_object,
-                &mut mangled_asts,
-            );
-
-            let kernel_macros_in_scope: HashSet<_> =
-                module.provides_for_syntax.iter().cloned().collect();
-
-            ast = ast
-                .into_iter()
-                .map(|x| {
-                    // First expand the in scope macros
-                    // These are macros
-                    let mut expander = Expander::new(&in_scope_macros);
-                    let mut first_round_expanded = expander.expand(x)?;
-                    let mut changed = false;
-
-                    // (first_round_expanded, changed) = expand_kernel_in_env_with_allowed(
-                    //     first_round_expanded,
-                    //     self.kernel.as_mut(),
-                    //     // We don't need to expand those here
-                    //     ModuleContainer::default(),
-                    //     module.name.to_str().unwrap().to_string(),
-                    //     &kernel_macros_in_scope,
-                    // )?;
-
-                    // If the kernel expander expanded into something - go ahead
-                    // and expand all of the macros in this
-                    // if changed || expander.changed {
-                    // Expand here?
-                    // first_round_expanded = expand(first_round_expanded, &module.macro_map)?;
-
-                    // Probably don't need this
-                    // (first_round_expanded, changed) = expand_kernel_in_env_with_change(
-                    //     first_round_expanded,
-                    //     self.kernel.as_mut(),
-                    //     ModuleContainer::default(),
-                    //     module.name.to_str().unwrap().to_string(),
-                    // )?;
-
-                    // name_mangler.visit(&mut first_round_expanded);
-                    // }
-
-                    if expander.changed || changed {
-                        expand(first_round_expanded, &module.macro_map)
-                    } else {
-                        Ok(first_round_expanded)
-                    }
-                })
-                .collect::<Result<_>>()?;
-
-            provides = provides
-                .into_iter()
-                .map(|x| {
-                    // First expand the in scope macros
-                    // These are macros
-                    let mut expander = Expander::new(&in_scope_macros);
-                    let first_round_expanded = expander.expand(x)?;
-
-                    if expander.changed {
-                        expand(first_round_expanded, &module.macro_map)
-                    } else {
-                        Ok(first_round_expanded)
-                    }
-                })
-                .collect::<Result<_>>()?;
-        }
-
-        // let requires_before = self.require_objects.len();
-
-        // self.collect_requires()?;
-
-        // if self.require_objects.len() > requires_before {
-        //     println!("EXPANDED INTO A REQUIRE");
-        // }
-
-        // TODO: Check HERE for whether there are more requires than were previously found.
-        // If so, we should go back and compile the module again
-
-        // TODO: @Matt - fix this hack
-        {
-            self.source_ast = ast;
-            self.provides = provides;
-
-            self.collect_provides();
-
-            // let requires_before = self.require_objects.len();
-
-            // self.collect_requires()?;
-
-            // if self.require_objects.len() > requires_before {
-            //     println!("EXPANDED INTO A REQUIRE");
-            // }
-
-            provides = std::mem::take(&mut self.provides);
-            ast = std::mem::take(&mut self.source_ast);
-        }
-
-        // Put the mangled asts at the top
-        // then include the ast there
-        mangled_asts.append(&mut ast);
-
-        mangled_asts = mangled_asts
-            .into_iter()
-            .map(lower_entire_ast)
-            // We want this to at least be flattened for querying later
-            .map(|x| x.map(FlattenBegin::flatten))
-            .collect::<std::result::Result<_, ParseError>>()?;
-
-        // Take ast, expand with self modules, then expand with each of the require for-syntaxes
-        // Then mangle the require-for-syntax, include the mangled directly in the ast
-
-        // TODO: Come back here - we're going to need to figure out the require objects
-        let mut module = CompiledModule::new(
-            self.name.clone(),
-            provides,
-            requires,
-            self.provides_for_syntax
-                .iter()
-                .map(|x| *x.atom_identifier().unwrap())
-                .collect(),
-            std::mem::take(&mut self.macro_map),
-            mangled_asts,
-        );
-
-        module.set_emitted(true);
-
-        // println!(
-        //     "-------------- Emitting module: {:?} ----------------------",
-        //     self.name
-        // );
-
-        let mut result =
-            module.to_top_level_module(self.compiled_modules, self.global_macro_map)?;
-
-        // println!("{}", result.to_pretty(60));
-
-        // println!("------------------ Finish ----------------------------------");
-
-        // let mut analysis = Analysis::from_exprs(&[result]);
-
-        // let mut semantic = SemanticAnalysis::from_analysis(&mut result, analysis);
-
-        // // This is definitely broken still
-        // semantic
-        //     .remove_unused_globals_with_prefix("mangler");
-
-        // log::debug!(target: "requires", "Adding compiled module: {:?}", self.name);
-
-        self.compiled_modules.insert(self.name.clone(), module);
-
-        Ok(result)
-    }
-
-    fn extract_macro_defs(&mut self) -> Result<()> {
-        let mut non_macros = Vec::new();
-        let exprs = std::mem::take(&mut self.source_ast);
-
-        for expr in exprs {
-            if let ExprKind::Macro(m) = expr {
-                let generated_macro = SteelMacro::parse_from_ast_macro(m)?;
-                let name = generated_macro.name();
-                self.macro_map.insert(*name, generated_macro);
-            } else {
-                non_macros.push(expr)
-            }
-        }
-        self.source_ast = non_macros;
-        Ok(())
-    }
-
-    // Takes out the (for-syntax) forms from the provides
-    fn filter_out_for_syntax_provides(&mut self, exprs: Vec<ExprKind>) -> Result<Vec<ExprKind>> {
-        let mut normal_provides = Vec::new();
-
-        for expr in exprs {
-            match &expr {
-                ExprKind::Atom(_) => {
-                    normal_provides.push(expr);
-                }
-                ExprKind::List(l) => {
-                    if let Some(for_syntax) = l.first_ident() {
-                        match *for_syntax {
-                            x if x == *FOR_SYNTAX => {
-                                if l.args.len() != 2 {
-                                    stop!(ArityMismatch => "provide expects a single identifier in the (for-syntax <ident>)")
-                                }
-
-                                // Collect the for syntax expressions
-                                // TODO -> remove this clone
-                                self.provides_for_syntax.push(l.args[1].clone());
-                            }
-                            x if x == *CONTRACT_OUT || x == *REQUIRE_IDENT_SPEC => {
-                                normal_provides.push(expr);
-                            }
-                            _ => {
-                                normal_provides.push(expr);
-                                // stop!(TypeMismatch => "provide expects either an identifier, (for-syntax <ident>), or (contract/out ...)")
-                            }
-                        }
-                    } else {
-                        stop!(TypeMismatch => "provide expects either an identifier or a (for-syntax <ident>)")
-                    }
-                }
-                _ => {
-                    stop!(TypeMismatch => "provide expects either a (for-syntax <ident>) or an ident")
-                }
-            }
-        }
-
-        Ok(normal_provides)
-    }
-
-    // TODO -> collect (provide (for-syntax ...))
-    // I think these will already be collected for the macro, however I think for syntax should be found earlier
-    // Otherwise the macro expansion will not be able to understand it
-    fn collect_provides(&mut self) -> Result<()> {
-        let mut non_provides = Vec::new();
-        let exprs = std::mem::take(&mut self.source_ast);
-
-        fn walk(
-            module_builder: &mut ModuleBuilder,
-            exprs: Vec<ExprKind>,
-            non_provides: &mut Vec<ExprKind>,
-        ) -> Result<()> {
-            for mut expr in exprs {
-                match &mut expr {
-                    ExprKind::List(l) => {
-                        if let Some(provide) = l.first_ident() {
-                            if *provide == *PROVIDE {
-                                if l.len() == 1 {
-                                    stop!(Generic => "provide expects at least one identifier to provide");
-                                }
-
-                                // Swap out the value inside the list
-                                let args = std::mem::take(&mut l.args);
-
-                                let filtered =
-                                    module_builder.filter_out_for_syntax_provides(args)?;
-
-                                l.args = filtered;
-
-                                module_builder.provides.push(expr);
-
-                                continue;
-                            }
-                        }
-                    }
-                    ExprKind::Begin(b) => {
-                        let exprs = std::mem::take(&mut b.exprs);
-                        walk(module_builder, exprs, non_provides)?;
-                    }
-                    _ => {}
-                }
-
-                non_provides.push(expr);
-            }
-
-            Ok(())
-        }
-
-        walk(self, exprs, &mut non_provides)?;
-
-        self.source_ast = non_provides;
-        Ok(())
-    }
-
-    fn parse_require_object(
-        &mut self,
-        home: &Option<PathBuf>,
-        r: &crate::parser::ast::Require,
-        atom: &ExprKind,
-    ) -> Result<RequireObject> {
-        let mut object = RequireObjectBuilder::default();
-
-        self.parse_require_object_inner(home, r, atom, &mut object)
-            .and_then(|_| object.build())
-    }
-
-    // TODO: Recursively crunch the requires to gather up the necessary information
-    fn parse_require_object_inner(
-        &mut self,
-        home: &Option<PathBuf>,
-        r: &crate::parser::ast::Require,
-        atom: &ExprKind,
-        require_object: &mut RequireObjectBuilder,
-    ) -> Result<()> {
-        match atom {
-            ExprKind::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::StringLiteral(s),
-                        span,
-                        ..
-                    },
-            }) => {
-                if require_object.path.is_some() {
-                    stop!(Generic => "require object only expects one path!")
-                }
-
-                // Try this?
-                if let Some(lib) = BUILT_INS.into_iter().cloned().find(|x| x.0 == s.as_str()) {
-                    // self.built_ins.push(PathBuf::from(lib.0));
-
-                    require_object.path = Some(PathOrBuiltIn::BuiltIn(lib.0.into()));
-
-                    return Ok(());
-                    // continue;
-                }
-
-                if self.custom_builtins.contains_key(s) {
-                    require_object.path = Some(PathOrBuiltIn::BuiltIn(s.clone().into()));
-
-                    return Ok(());
-                }
-
-                let mut current = self.name.clone();
-                if current.is_file() {
-                    current.pop();
-                }
-                current.push(s);
-
-                // // If the path exists on its own, we can continue
-                // // But theres the case where we're searching for a module on the STEEL_HOME
-                if !current.exists() {
-                    if let Some(mut home) = home.clone() {
-                        home.push(s);
-                        current = home;
-
-                        log::info!("Searching STEEL_HOME for {:?}", current);
-                    } else {
-                        stop!(Generic => format!("Module not found: {:?} with STEEL_HOME: {:?}", current, home); *span)
-                    }
-                }
-
-                // Get the absolute path and store that
-                // self.requires.push(current)
-
-                require_object.path = Some(PathOrBuiltIn::Path(current));
-            }
-
-            // TODO: Requires with qualifiers, that aren't just for-syntax
-            // Perhaps like:
-            // (with-prefix <xyz>)
-            ExprKind::List(l) => {
-                match l.first_ident() {
-                    Some(x) if *x == *ONLY_IN => {
-                        if l.args.len() < 2 {
-                            stop!(BadSyntax => "only-in expects a require-spec and optionally a list of ids to bind (maybe renamed)");
-                        }
-
-                        self.parse_require_object_inner(home, r, &l.args[1], require_object)?;
-
-                        for remaining in &l.args[2..] {
-                            match remaining {
-                                ExprKind::Atom(_) => {
-                                    require_object
-                                        .idents_to_import
-                                        .push(MaybeRenamed::Normal(remaining.clone()));
-                                }
-                                ExprKind::List(l) => {
-                                    if l.len() != 2 {
-                                        stop!(BadSyntax => "Expected a pair when renaming required identifiers");
-                                    }
-
-                                    let from = &l.args[0];
-                                    let to = &l.args[1];
-
-                                    if from.atom_identifier().is_none()
-                                        || to.atom_identifier().is_none()
-                                    {
-                                        stop!(BadSyntax => "only-in expected identifiers to rename");
-                                    }
-
-                                    // (<from> <to>)
-                                    require_object
-                                        .idents_to_import
-                                        .push(MaybeRenamed::Renamed(from.clone(), to.clone()));
-                                }
-                                _ => {
-                                    stop!(BadSyntax => "unexpected syntax in only-in form during module requires")
-                                }
-                            }
-                        }
-                    }
-
-                    Some(x) if *x == *PREFIX_IN => {
-                        if l.args.len() != 3 {
-                            stop!(BadSyntax => "prefix-in expects a prefix to prefix a given file or module"; r.location.span; r.location.source.clone());
-                        }
-
-                        if let Some(prefix) = l.args[1].atom_identifier() {
-                            match &mut require_object.prefix {
-                                Some(existing_prefix) => {
-                                    // Append the new symbol to the existing prefix
-                                    existing_prefix.push_str(prefix.resolve());
-                                }
-                                None => {
-                                    require_object.prefix = Some(prefix.resolve().to_string());
-                                }
-                            }
-
-                            self.parse_require_object_inner(home, r, &l.args[2], require_object)?;
-                        } else {
-                            stop!(TypeMismatch => "prefix-in expects an identifier to use for the prefix");
-                        }
-                    }
-
-                    Some(x) if *x == *FOR_SYNTAX => {
-                        // We're expecting something like (for-syntax "foo")
-                        if l.args.len() != 2 {
-                            stop!(BadSyntax => "for-syntax expects one string literal referring to a file or module"; r.location.span; r.location.source.clone());
-                        }
-
-                        if let Some(path) = l.args[1].string_literal() {
-                            if let Some(lib) = BUILT_INS.iter().find(|x| x.0 == path) {
-                                // self.built_ins.push(PathBuf::from(lib.0));
-
-                                require_object.path = Some(PathOrBuiltIn::BuiltIn(lib.0.into()));
-                                require_object.for_syntax = true;
-
-                                return Ok(());
-                                // continue;
-                            } else if self.custom_builtins.contains_key(path) {
-                                require_object.path =
-                                    Some(PathOrBuiltIn::BuiltIn(Cow::Owned(path.to_string())));
-                                require_object.for_syntax = true;
-
-                                return Ok(());
-                            } else {
-                                let mut current = self.name.clone();
-                                if current.is_file() {
-                                    current.pop();
-                                }
-                                current.push(path);
-
-                                if !current.exists() {
-                                    if let Some(mut home) = home.clone() {
-                                        home.push(path);
-                                        current = home;
-
-                                        log::info!("Searching STEEL_HOME for {:?}", current);
-                                    } else {
-                                        stop!(Generic => format!("Module not found: {:?}", current); r.location.span)
-                                    }
-                                }
-
-                                require_object.for_syntax = true;
-                                require_object.path = Some(PathOrBuiltIn::Path(current));
-                            }
-                        } else {
-                            stop!(BadSyntax => "for-syntax expects a string literal referring to a file or module"; r.location.span; r.location.source.clone());
-                        }
-                    }
-                    _ => {
-                        stop!(BadSyntax => "require accepts either a string literal or a for-syntax expression"; r.location.span; r.location.source.clone())
-                    }
-                }
-            }
-
-            _ => {
-                stop!(Generic => "require expected a string literal referring to a file/module"; r.location.span; r.location.source.clone())
-            }
-        }
-
-        Ok(())
-    }
-
-    fn collect_requires(&mut self) -> Result<()> {
-        // unimplemented!()
-
-        let mut exprs_without_requires = Vec::new();
-        let exprs = std::mem::take(&mut self.source_ast);
-
-        let home = std::env::var("STEEL_HOME")
-            .map(PathBuf::from)
-            .map(|mut x| {
-                x.push("cogs");
-                x
-            })
-            .ok();
-
-        fn walk(
-            module_builder: &mut ModuleBuilder,
-            home: &Option<PathBuf>,
-            exprs_without_requires: &mut Vec<ExprKind>,
-            exprs: Vec<ExprKind>,
-        ) -> Result<()> {
-            for expr in exprs {
-                match expr {
-                    // Include require/for-syntax here
-                    // This way we have some understanding of what dependencies a file has
-                    ExprKind::Require(r) => {
-                        for atom in &r.modules {
-                            // TODO: Consider making this not a reference for r
-                            let require_object =
-                                module_builder.parse_require_object(&home, &r, atom)?;
-
-                            module_builder.require_objects.push(require_object);
-                        }
-                    }
-                    ExprKind::Begin(b) => {
-                        walk(module_builder, home, exprs_without_requires, b.exprs)?
-                    }
-                    _ => exprs_without_requires.push(expr),
-                }
-            }
-
-            Ok(())
-        }
-
-        walk(self, &home, &mut exprs_without_requires, exprs)?;
-
-        self.source_ast = exprs_without_requires;
-        Ok(())
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn new_built_in(
-        name: PathBuf,
-        input: &str,
-        compiled_modules: &'a mut HashMap<PathBuf, CompiledModule>,
-        visited: &'a mut HashSet<PathBuf>,
-        file_metadata: &'a mut HashMap<PathBuf, SystemTime>,
-        sources: &'a mut Sources,
-        kernel: &'a mut Option<Kernel>,
-        builtin_modules: ModuleContainer,
-        global_macro_map: &'a HashMap<InternedString, SteelMacro>,
-        custom_builtins: &'a HashMap<String, String>,
-    ) -> Result<Self> {
-        ModuleBuilder::raw(
-            name,
-            compiled_modules,
-            visited,
-            file_metadata,
-            sources,
-            kernel,
-            builtin_modules,
-            global_macro_map,
-            custom_builtins,
-        )
-        .parse_builtin(input)
-    }
-
-    fn new_from_path(
-        name: PathBuf,
-        compiled_modules: &'a mut HashMap<PathBuf, CompiledModule>,
-        visited: &'a mut HashSet<PathBuf>,
-        file_metadata: &'a mut HashMap<PathBuf, SystemTime>,
-        sources: &'a mut Sources,
-        kernel: &'a mut Option<Kernel>,
-        builtin_modules: ModuleContainer,
-        global_macro_map: &'a HashMap<InternedString, SteelMacro>,
-        custom_builtins: &'a HashMap<String, String>,
-    ) -> Result<Self> {
-        ModuleBuilder::raw(
-            name,
-            compiled_modules,
-            visited,
-            file_metadata,
-            sources,
-            kernel,
-            builtin_modules,
-            global_macro_map,
-            custom_builtins,
-        )
-        .parse_from_path()
-    }
-
-    fn raw(
-        name: PathBuf,
-        compiled_modules: &'a mut HashMap<PathBuf, CompiledModule>,
-        visited: &'a mut HashSet<PathBuf>,
-        file_metadata: &'a mut HashMap<PathBuf, SystemTime>,
-        sources: &'a mut Sources,
-        kernel: &'a mut Option<Kernel>,
-        builtin_modules: ModuleContainer,
-        global_macro_map: &'a HashMap<InternedString, SteelMacro>,
-        custom_builtins: &'a HashMap<String, String>,
-    ) -> Self {
-        ModuleBuilder {
-            name,
-            main: false,
-            source_ast: Vec::new(),
-            // TODO: This used to be empty
-            macro_map: DEFAULT_PRELUDE_MACROS.with(|x| x.borrow().clone()),
-            // macro_map: global_macro_map.clone(),
-            require_objects: Vec::new(),
-            provides: Vec::new(),
-            provides_for_syntax: Vec::new(),
-            compiled_modules,
-            visited,
-            file_metadata,
-            sources,
-            kernel,
-            builtin_modules,
-            global_macro_map,
-            custom_builtins,
-        }
-    }
-
-    fn parse_builtin(mut self, input: &str) -> Result<Self> {
-        let parsed = Parser::new_from_source(input, self.name.clone(), None)
-            .without_lowering()
-            .map(|x| x.and_then(lower_macro_and_require_definitions))
-            .collect::<std::result::Result<Vec<_>, ParseError>>()?;
-
-        self.source_ast = parsed;
-
-        // self.source_ast.pretty_print();
-
-        Ok(self)
-    }
-
-    fn parse_from_path(mut self) -> Result<Self> {
-        log::info!("Opening: {:?}", self.name);
-
-        let mut file = std::fs::File::open(&self.name).map_err(|err| {
-            let mut err = crate::SteelErr::from(err);
-            err.prepend_message(&format!("Attempting to load module from: {:?}", self.name));
-            err
-        })?;
-        self.file_metadata
-            .insert(self.name.clone(), file.metadata()?.modified()?);
-
-        // TODO: DEFAULT MODULE LOADER PREFIX
-        let mut exprs = String::new();
-
-        // TODO: Don't do this - get the source from the cache?
-        // let mut exprs = PRELUDE_STRING.to_string();
-
-        let mut expressions = Parser::new(&PRELUDE_STRING, None)
-            .without_lowering()
-            .map(|x| x.and_then(lower_macro_and_require_definitions))
-            .collect::<std::result::Result<Vec<_>, ParseError>>()?;
-
-        // let expressions = Parser::new_from_source(, , )
-
-        // Add the modules here:
-
-        // exprs.push_str(ALL_MODULES);
-
-        file.read_to_string(&mut exprs)?;
-
-        let id = self.sources.add_source(exprs, Some(self.name.clone()));
-
-        {
-            // Fetch the exprs after adding them to the sources
-            // We did _just_ add it, so its fine to unwrap
-            let guard = self.sources.sources.lock().unwrap();
-
-            let exprs = guard.get(id).unwrap();
-
-            let mut parsed = Parser::new_from_source(&exprs, self.name.clone(), Some(id))
-                .without_lowering()
-                .map(|x| x.and_then(lower_macro_and_require_definitions))
-                .collect::<std::result::Result<Vec<_>, ParseError>>()?;
-
-            expressions.append(&mut parsed);
-
-            self.source_ast = expressions;
-        }
-
-        Ok(self)
-    }
-}
diff --git a/crates/steel-core/src/compiler/passes/analysis.rs b/crates/steel-core/src/compiler/passes/analysis.rs
deleted file mode 100644
index ff9a9a416..000000000
--- a/crates/steel-core/src/compiler/passes/analysis.rs
+++ /dev/null
@@ -1,5584 +0,0 @@
-use std::{
-    collections::{hash_map, HashMap, HashSet},
-    hash::BuildHasherDefault,
-};
-
-use im_rc::HashMap as ImmutableHashMap;
-use quickscope::ScopeMap;
-use steel_parser::{ast::PROTO_HASH_GET, parser::SourceId};
-
-use crate::{
-    compiler::{
-        map::SymbolMap,
-        modules::{ModuleManager, MANGLER_SEPARATOR},
-    },
-    parser::{
-        ast::{
-            Atom, Define, ExprKind, LambdaFunction, Let, List, Quote, STANDARD_MODULE_GET,
-            UNREADABLE_MODULE_GET,
-        },
-        expander::SteelMacro,
-        interner::InternedString,
-        parser::{RawSyntaxObject, SyntaxObject, SyntaxObjectId},
-        span::Span,
-        span_visitor::get_span,
-        tokens::TokenType,
-    },
-    steel_vm::primitives::MODULE_IDENTIFIERS,
-    stop, throw, SteelErr, SteelVal,
-};
-
-use super::{VisitorMutControlFlow, VisitorMutRefUnit, VisitorMutUnitRef};
-
-use fxhash::{FxHashMap, FxHashSet, FxHasher};
-
-#[derive(Clone, Copy, Debug, PartialEq)]
-pub enum IdentifierStatus {
-    Global,
-    Local,
-    LocallyDefinedFunction,
-    LetVar,
-    Captured,
-    Free,
-    HeapAllocated,
-}
-
-// TODO: Make these not just plain public variables
-#[derive(Debug, Clone)]
-pub struct SemanticInformation {
-    pub kind: IdentifierStatus,
-    pub set_bang: bool,
-    pub depth: usize,
-    pub shadows: Option<SyntaxObjectId>,
-    pub usage_count: usize,
-    pub span: Span,
-    // Referring to a local var definition
-    pub refers_to: Option<SyntaxObjectId>,
-    // If this is a top level define, what does this alias to?
-    pub aliases_to: Option<SyntaxObjectId>,
-    pub builtin: bool,
-    pub last_usage: bool,
-    pub stack_offset: Option<usize>,
-    pub escapes: bool,
-    // TODO: Move a bunch of these individual things into their own structs
-    // something like Option<CaptureInformation>
-    pub capture_index: Option<usize>,
-    pub read_capture_offset: Option<usize>,
-    pub captured_from_enclosing: bool,
-    pub heap_offset: Option<usize>,
-    pub read_heap_offset: Option<usize>,
-    pub is_shadowed: bool,
-    pub is_required_identifier: bool,
-}
-
-#[test]
-fn check_size_of_info() {
-    println!("{}", std::mem::size_of::<SemanticInformation>());
-}
-
-impl SemanticInformation {
-    pub fn new(kind: IdentifierStatus, depth: usize, span: Span) -> Self {
-        Self {
-            kind,
-            set_bang: false,
-            depth,
-            shadows: None,
-            usage_count: 0,
-            span,
-            refers_to: None,
-            aliases_to: None,
-            builtin: false,
-            last_usage: false,
-            stack_offset: None,
-            escapes: false,
-            capture_index: None,
-            read_capture_offset: None,
-            captured_from_enclosing: false,
-            heap_offset: None,
-            read_heap_offset: None,
-            is_shadowed: false,
-            is_required_identifier: false,
-        }
-    }
-
-    pub fn shadows(mut self, id: SyntaxObjectId) -> Self {
-        self.shadows = Some(id);
-        self
-    }
-
-    pub fn with_usage_count(mut self, count: usize) -> Self {
-        self.usage_count = count;
-        self
-    }
-
-    pub fn refers_to(mut self, id: SyntaxObjectId) -> Self {
-        self.refers_to = Some(id);
-        self
-    }
-
-    pub fn aliases_to(mut self, id: SyntaxObjectId) -> Self {
-        self.aliases_to = Some(id);
-        self
-    }
-
-    pub fn mark_builtin(&mut self) {
-        self.builtin = true;
-    }
-
-    pub fn mark_required(&mut self) {
-        self.is_required_identifier = true;
-    }
-
-    pub fn with_offset(mut self, offset: usize) -> Self {
-        self.stack_offset = Some(offset);
-        self
-    }
-
-    pub fn mark_escapes(&mut self) {
-        self.escapes = true;
-    }
-
-    pub fn with_capture_index(mut self, offset: usize) -> Self {
-        self.capture_index = Some(offset);
-        self
-    }
-
-    pub fn with_read_capture_offset(mut self, offset: usize) -> Self {
-        self.read_capture_offset = Some(offset);
-        self
-    }
-
-    pub fn with_heap_offset(mut self, offset: usize) -> Self {
-        self.heap_offset = Some(offset);
-        self
-    }
-
-    pub fn with_read_heap_offset(mut self, offset: usize) -> Self {
-        self.read_heap_offset = Some(offset);
-        self
-    }
-
-    pub fn with_captured_from_enclosing(&mut self, captured_from_enclosing: bool) {
-        self.captured_from_enclosing = captured_from_enclosing;
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct FunctionInformation {
-    // Just a mapping of the vars to their scope info - holds which vars are being
-    // captured by this function
-    captured_vars: FxHashMap<InternedString, ScopeInfo>,
-    arguments: FxHashMap<InternedString, ScopeInfo>,
-    // Keeps a mapping of vars to their scope info, if the variable was mutated
-    // if this variable was mutated and inevitably captured, we want to know
-    // mutated_vars: HashMap<String, ScopeInfo>,
-    // If this function is defined in the tail position / and or the alias to this function escapes,
-    // then this should be marked as true
-    pub escapes: bool,
-    // If this function is bound to a variable, this is the id of that bound value
-    pub aliases_to: Option<SyntaxObjectId>,
-
-    // Depth the function definition occurs at
-    pub depth: usize,
-}
-
-impl FunctionInformation {
-    pub fn new(
-        captured_vars: FxHashMap<InternedString, ScopeInfo>,
-        arguments: FxHashMap<InternedString, ScopeInfo>,
-    ) -> Self {
-        Self {
-            captured_vars,
-            arguments,
-            escapes: false,
-            aliases_to: None,
-            depth: 0,
-        }
-    }
-
-    pub fn captured_vars(&self) -> &FxHashMap<InternedString, ScopeInfo> {
-        &self.captured_vars
-    }
-
-    pub fn arguments(&self) -> &FxHashMap<InternedString, ScopeInfo> {
-        &self.arguments
-    }
-
-    pub fn escapes(mut self, escapes: bool) -> Self {
-        self.escapes = escapes;
-        self
-    }
-
-    pub fn depth(mut self, depth: usize) -> Self {
-        self.depth = depth;
-        self
-    }
-}
-
-#[derive(Debug, PartialEq, Clone)]
-pub enum CallKind {
-    Normal,
-    TailCall,
-    SelfTailCall(usize),
-}
-
-#[derive(Debug, Clone)]
-pub struct CallSiteInformation {
-    pub kind: CallKind,
-    pub span: Span,
-}
-
-impl CallSiteInformation {
-    pub fn new(kind: CallKind, span: Span) -> Self {
-        Self { kind, span }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct LetInformation {
-    pub stack_offset: usize,
-    pub function_context: Option<usize>,
-    pub arguments: FxHashMap<InternedString, ScopeInfo>,
-}
-
-impl LetInformation {
-    pub fn new(
-        stack_offset: usize,
-        function_context: Option<usize>,
-        arguments: FxHashMap<InternedString, ScopeInfo>,
-    ) -> Self {
-        Self {
-            stack_offset,
-            function_context,
-            arguments,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum SemanticInformationType {
-    Variable(SemanticInformation),
-    Function(FunctionInformation),
-    CallSite(CallSiteInformation),
-    Let(LetInformation),
-}
-
-// Populate the metadata about individual
-#[derive(Default, Debug, Clone)]
-pub struct Analysis {
-    // TODO: make these be specific IDs for semantic id, function id, and call info id
-    pub(crate) info: FxHashMap<SyntaxObjectId, SemanticInformation>,
-    pub(crate) function_info: FxHashMap<usize, FunctionInformation>,
-    pub(crate) call_info: FxHashMap<usize, CallSiteInformation>,
-    pub(crate) let_info: FxHashMap<usize, LetInformation>,
-}
-
-impl Analysis {
-    // Reuse the analysis allocation through the process!
-    pub fn clear(&mut self) {
-        self.info.clear();
-        self.function_info.clear();
-        self.call_info.clear();
-        self.let_info.clear();
-    }
-
-    pub fn identifier_info(&self) -> &FxHashMap<SyntaxObjectId, SemanticInformation> {
-        &self.info
-    }
-
-    pub fn fresh_from_exprs(&mut self, exprs: &[ExprKind]) {
-        self.clear();
-        self.run(exprs);
-    }
-
-    pub fn from_exprs(exprs: &[ExprKind]) -> Self {
-        let mut analysis = Analysis::default();
-        analysis.run(exprs);
-        analysis
-    }
-
-    pub fn populate_captures(&mut self, exprs: &[ExprKind]) {
-        // Resolve all mutated and captured vars so that they're mutated after they've been captured
-        let mutated_and_captured_vars = self
-            .function_info
-            .values()
-            .flat_map(|x| x.captured_vars.values())
-            .chain(self.let_info.values().flat_map(|x| x.arguments.values()))
-            .filter(|x| x.captured && x.mutated)
-            .map(|x| (x.id, x.clone()))
-            .collect::<FxHashMap<_, _>>();
-
-        self.function_info
-            .values_mut()
-            .flat_map(|x| x.captured_vars.values_mut())
-            .for_each(|x| {
-                if mutated_and_captured_vars.get(&x.id).is_some() {
-                    x.mutated = true;
-                    x.captured = true;
-                }
-            });
-
-        self.function_info
-            .values_mut()
-            .flat_map(|x| x.arguments.values_mut())
-            .for_each(|x| {
-                if mutated_and_captured_vars.get(&x.id).is_some() {
-                    x.mutated = true;
-                    x.captured = true;
-                }
-            });
-
-        self.run(exprs);
-    }
-
-    pub fn resolve_alias(&self, mut id: SyntaxObjectId) -> Option<SyntaxObjectId> {
-        while let Some(next) = self
-            .info
-            .get(&id)
-            .and_then(|x| x.aliases_to)
-            .and_then(|x| self.info.get(&x))
-            .and_then(|x| x.refers_to)
-        {
-            id = next;
-        }
-
-        Some(id)
-    }
-
-    pub fn visit_top_level_define_function_without_body(
-        &mut self,
-        scope: &mut ScopeMap<InternedString, ScopeInfo>,
-        define: &crate::parser::ast::Define,
-    ) {
-        let name = define.name.atom_identifier().unwrap();
-
-        let mut semantic_info = SemanticInformation::new(
-            IdentifierStatus::Global,
-            1,
-            define.name.atom_syntax_object().unwrap().span,
-        );
-
-        if is_a_builtin_definition(define) {
-            semantic_info.mark_builtin();
-        }
-
-        if is_a_require_definition(define) {
-            semantic_info.mark_required();
-        }
-
-        // If this variable name is already in scope, we should mark that this variable
-        // shadows the previous id
-        if let Some(shadowed_var) = scope.get(name) {
-            semantic_info = semantic_info.shadows(shadowed_var.id)
-        }
-
-        // log::trace!("Defining global: {:?}", define.name);
-        // println!("Defining global: {}", define.name);
-        define_var(scope, define);
-
-        self.insert(define.name.atom_syntax_object().unwrap(), semantic_info);
-    }
-
-    // TODO: This needs to just take an iterator?
-    pub fn run(&mut self, exprs: &[ExprKind]) {
-        let mut scope: ScopeMap<InternedString, ScopeInfo> = ScopeMap::new();
-
-        // TODO: Functions should be globally resolvable but top level identifiers cannot be used before they are defined
-        // The way this is implemented right now doesn't respect that
-        for expr in exprs.iter() {
-            if let ExprKind::Define(define) = expr {
-                if define.body.lambda_function().is_some() {
-                    self.visit_top_level_define_function_without_body(&mut scope, define);
-                }
-            }
-
-            if let ExprKind::Begin(b) = expr {
-                for expr in &b.exprs {
-                    if let ExprKind::Define(define) = expr {
-                        if define.body.lambda_function().is_some() {
-                            self.visit_top_level_define_function_without_body(&mut scope, define);
-                        }
-                    }
-                }
-            }
-        }
-
-        for expr in exprs {
-            let mut pass = AnalysisPass::new(self, &mut scope);
-
-            match expr {
-                ExprKind::Define(define) => {
-                    if define.body.lambda_function().is_some() {
-                        // Since we're at the top level, care should be taken to actually
-                        // refer to the defining context correctly
-                        pass.defining_context = define.name_id();
-                        pass.defining_context_depth = 0;
-                        // Continue with the rest of the body here
-                        pass.visit(&define.body);
-                        pass.defining_context = None;
-                    } else {
-                        pass.visit_top_level_define_value_without_body(define);
-                        pass.visit(&define.body);
-                    }
-                }
-                ExprKind::Begin(b) => {
-                    for expr in &b.exprs {
-                        if let ExprKind::Define(define) = expr {
-                            if define.body.lambda_function().is_some() {
-                                // Since we're at the top level, care should be taken to actually
-                                // refer to the defining context correctly
-                                pass.defining_context = define.name_id();
-                                pass.defining_context_depth = 0;
-                                // Continue with the rest of the body here
-                                pass.visit(&define.body);
-                                pass.defining_context = None;
-                            } else {
-                                pass.visit_top_level_define_value_without_body(define);
-                                pass.visit(&define.body);
-                            }
-                        } else {
-                            pass.visit(expr);
-                        }
-                    }
-                }
-                _ => {
-                    pass.visit(expr);
-                }
-            }
-        }
-    }
-
-    pub fn get_function_info(&self, function: &LambdaFunction) -> Option<&FunctionInformation> {
-        self.function_info.get(&function.syntax_object_id)
-    }
-
-    pub fn insert(&mut self, object: &SyntaxObject, metadata: SemanticInformation) {
-        self.info.insert(object.syntax_object_id, metadata);
-    }
-
-    pub fn update_with(&mut self, object: &SyntaxObject, metadata: SemanticInformation) {
-        let existing = self.info.get_mut(&object.syntax_object_id).unwrap();
-        existing.kind = metadata.kind;
-        existing.set_bang = existing.set_bang || metadata.set_bang;
-        existing.shadows = metadata.shadows;
-        existing.depth = metadata.depth;
-        existing.usage_count = metadata.usage_count;
-        existing.aliases_to = metadata.aliases_to;
-        existing.refers_to = metadata.refers_to;
-        existing.builtin = metadata.builtin;
-        existing.captured_from_enclosing = metadata.captured_from_enclosing;
-        existing.heap_offset = metadata.heap_offset;
-        existing.read_heap_offset = metadata.read_heap_offset;
-        existing.is_required_identifier = metadata.is_required_identifier;
-    }
-
-    pub fn get(&self, object: &SyntaxObject) -> Option<&SemanticInformation> {
-        self.info.get(&object.syntax_object_id)
-    }
-
-    pub fn get_mut(&mut self, id: &SyntaxObjectId) -> Option<&mut SemanticInformation> {
-        self.info.get_mut(id)
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ScopeInfo {
-    /// The ID of the variable, this is globally unique
-    pub id: SyntaxObjectId,
-    /// Whether or not this variable is captured by a scope
-    /// TODO: This needs to actually just mark the depth at which variable was captured, or something to signify
-    /// if a specific scope actually _uses_ the variable
-    pub captured: bool,
-    /// How many times has this variable been referenced
-    pub usage_count: usize,
-    /// Last touched by this ID
-    pub last_used: Option<SyntaxObjectId>,
-    /// Represents the position on the stack that this variable
-    /// should live at during the execution of the program
-    pub stack_offset: Option<usize>,
-    /// Does this variable escape its scope? As in, does the value outlive the scope
-    /// that it was defined in
-    pub escapes: bool,
-    /// If this is a captured var, the capture index
-    pub capture_offset: Option<usize>,
-    /// Was this var captured from the stack or from an enclosing function
-    pub captured_from_enclosing: bool,
-    /// Was this var mutated?
-    pub mutated: bool,
-    /// Heap offset
-    pub heap_offset: Option<usize>,
-    pub read_capture_offset: Option<usize>,
-    pub read_heap_offset: Option<usize>,
-    pub parent_heap_offset: Option<usize>,
-    pub local_heap_offset: Option<usize>,
-}
-
-impl ScopeInfo {
-    pub fn new(id: SyntaxObjectId) -> Self {
-        Self {
-            id,
-            captured: false,
-            usage_count: 0,
-            last_used: None,
-            stack_offset: None,
-            escapes: false,
-            capture_offset: None,
-            captured_from_enclosing: false,
-            mutated: false,
-            heap_offset: None,
-            read_capture_offset: None,
-            read_heap_offset: None,
-            parent_heap_offset: None,
-            local_heap_offset: None,
-        }
-    }
-
-    pub fn new_local(id: SyntaxObjectId, offset: usize) -> Self {
-        Self {
-            id,
-            captured: false,
-            usage_count: 0,
-            last_used: None,
-            stack_offset: Some(offset),
-            escapes: false,
-            capture_offset: None,
-            captured_from_enclosing: false,
-            mutated: false,
-            heap_offset: None,
-            read_capture_offset: None,
-            read_heap_offset: None,
-            parent_heap_offset: None,
-            local_heap_offset: None,
-        }
-    }
-
-    pub fn new_heap_allocated_var(
-        id: SyntaxObjectId,
-        stack_offset: usize,
-        heap_offset: usize,
-    ) -> Self {
-        Self {
-            id,
-            captured: true,
-            usage_count: 0,
-            last_used: None,
-            stack_offset: Some(stack_offset),
-            escapes: false,
-            capture_offset: None,
-            captured_from_enclosing: false,
-            mutated: true,
-            heap_offset: Some(heap_offset),
-            read_capture_offset: None,
-            read_heap_offset: Some(heap_offset),
-            parent_heap_offset: None,
-            local_heap_offset: None,
-        }
-    }
-}
-
-struct AnalysisPass<'a> {
-    info: &'a mut Analysis,
-    scope: &'a mut ScopeMap<InternedString, ScopeInfo>,
-    captures: ScopeMap<InternedString, ScopeInfo>,
-    tail_call_eligible: bool,
-    escape_analysis: bool,
-    defining_context: Option<SyntaxObjectId>,
-    // TODO: This should give us the depth (how many things we need to roll back)
-    defining_context_depth: usize,
-    stack_offset: usize,
-    function_context: Option<usize>,
-    contains_lambda_func: bool,
-    vars_used: im_rc::HashSet<InternedString>,
-    total_vars_used: im_rc::HashSet<InternedString>,
-    ids_referenced_in_tail_position: HashSet<SyntaxObjectId>,
-}
-
-fn define_var(
-    scope: &mut ScopeMap<InternedString, ScopeInfo>,
-    define: &crate::parser::ast::Define,
-) {
-    scope.define(
-        *define.name.atom_identifier().unwrap(),
-        ScopeInfo::new(define.name.atom_syntax_object().unwrap().syntax_object_id),
-    );
-}
-
-impl<'a> AnalysisPass<'a> {
-    pub fn new(info: &'a mut Analysis, scope: &'a mut ScopeMap<InternedString, ScopeInfo>) -> Self {
-        AnalysisPass {
-            info,
-            scope,
-            captures: ScopeMap::default(),
-            tail_call_eligible: false,
-            escape_analysis: false,
-            defining_context: None,
-            defining_context_depth: 0,
-            stack_offset: 0,
-            function_context: None,
-            contains_lambda_func: false,
-            vars_used: im_rc::HashSet::new(),
-            total_vars_used: im_rc::HashSet::new(),
-            ids_referenced_in_tail_position: HashSet::new(),
-        }
-    }
-}
-
-impl<'a> AnalysisPass<'a> {
-    // TODO: This needs to be fixed with interning
-    fn _get_possible_captures(
-        &self,
-        let_level_bindings: &[&InternedString],
-    ) -> HashSet<InternedString> {
-        self.scope
-            .iter()
-            .filter(|x| !x.1.captured)
-            .filter(|x| !let_level_bindings.contains(&x.0))
-            .map(|x| x.0.clone())
-            .collect()
-    }
-
-    fn get_captured_vars(
-        &self,
-        let_level_bindings: &[&InternedString],
-    ) -> FxHashMap<InternedString, ScopeInfo> {
-        self.scope
-            .iter()
-            .filter(|x| x.1.captured)
-            .filter(|x| !let_level_bindings.contains(&x.0))
-            .map(|x| (x.0.clone(), x.1.clone()))
-            .collect()
-    }
-
-    fn visit_top_level_define_value_without_body(&mut self, define: &crate::parser::ast::Define) {
-        let name = define.name.atom_identifier().unwrap();
-
-        let name_syntax_object = define.name.atom_syntax_object().unwrap();
-
-        let mut semantic_info =
-            SemanticInformation::new(IdentifierStatus::Global, 1, name_syntax_object.span);
-
-        // If this variable name is already in scope, we should mark that this variable
-        // shadows the previous id
-        if let Some(shadowed_var) = self.scope.get(name) {
-            semantic_info = semantic_info.shadows(shadowed_var.id);
-
-            if let Some(existing_analysis) = self.info.info.get_mut(&shadowed_var.id) {
-                if existing_analysis.builtin {
-                    existing_analysis.is_shadowed = true;
-                }
-            }
-        }
-
-        if is_a_builtin_definition(define) {
-            semantic_info.mark_builtin();
-        }
-
-        // println!("Defining global: {}", define.name);
-
-        if is_a_require_definition(define) {
-            semantic_info.mark_required();
-        }
-
-        if let Some(aliases) = define.is_an_alias_definition() {
-            semantic_info = semantic_info.aliases_to(aliases);
-        }
-
-        // println!("Defining global: {}", define.name);
-        define_var(self.scope, define);
-
-        self.info.insert(name_syntax_object, semantic_info);
-    }
-
-    // TODO: I really hate this identifier status if local nonsense
-    fn visit_define_without_body(
-        &mut self,
-        define: &crate::parser::ast::Define,
-        identifier_status_if_local: IdentifierStatus,
-    ) {
-        let name = define.name.atom_identifier().unwrap();
-
-        let mut semantic_info = SemanticInformation::new(
-            if self.scope.depth() == 1 {
-                IdentifierStatus::Global
-            } else {
-                identifier_status_if_local
-            },
-            self.scope.depth(),
-            define.name.atom_syntax_object().unwrap().span,
-        );
-
-        if is_a_builtin_definition(define) {
-            semantic_info.mark_builtin();
-        }
-
-        if is_a_require_definition(define) {
-            semantic_info.mark_required();
-        }
-
-        // If this variable name is already in scope, we should mark that this variable
-        // shadows the previous id
-        if let Some(shadowed_var) = self.scope.get(name) {
-            // log::debug!("Redefining previous variable: {:?}", name);
-            semantic_info = semantic_info.shadows(shadowed_var.id);
-        }
-
-        define_var(self.scope, define);
-
-        self.info
-            .insert(define.name.atom_syntax_object().unwrap(), semantic_info);
-    }
-
-    // Visit the function arguments, marking these as defining in our scope
-    // and also defaulting them to be local identifiers. This way, in the event of a set!
-    // we have something to refer to
-    fn visit_func_args(&mut self, lambda_function: &LambdaFunction, depth: usize) {
-        let alloc_capture_count = self
-            .info
-            .function_info
-            .get(&lambda_function.syntax_object_id)
-            .map(|x| {
-                x.captured_vars()
-                    .values()
-                    .filter(|x| x.captured && x.mutated)
-                    .count()
-            });
-
-        let mut mut_var_offset = 0;
-
-        for (index, arg) in lambda_function.args.iter().enumerate() {
-            let name = arg.atom_identifier().unwrap();
-            let id = arg.atom_syntax_object().unwrap().syntax_object_id;
-
-            // TODO: Don't need to do these repeated hash lookups over and over
-            // can coalesce this into one at the top of the args
-            let heap_alloc = if let Some(info) = self
-                .info
-                .function_info
-                .get(&lambda_function.syntax_object_id)
-            {
-                if let Some(info) = info.arguments.get(name) {
-                    // println!("Found information: {:#?}", info);
-                    info.mutated && info.captured
-                } else {
-                    false
-                }
-            } else {
-                false
-            };
-
-            // TODO: clean this up like a lot
-            if heap_alloc {
-                self.scope.define(
-                    *name,
-                    ScopeInfo::new_heap_allocated_var(
-                        id,
-                        index,
-                        mut_var_offset + alloc_capture_count.unwrap(),
-                    ),
-                );
-
-                // Throw in a dummy info so that no matter what, we have something to refer to
-                // in the event of a set!
-                // Later on in this function this gets updated accordingly
-                self.info.insert(
-                    arg.atom_syntax_object().unwrap(),
-                    SemanticInformation::new(
-                        IdentifierStatus::HeapAllocated,
-                        depth,
-                        arg.atom_syntax_object().unwrap().span,
-                    ),
-                );
-
-                mut_var_offset += 1;
-            } else {
-                self.scope.define(*name, ScopeInfo::new_local(id, index));
-
-                // Throw in a dummy info so that no matter what, we have something to refer to
-                // in the event of a set!
-                // Later on in this function this gets updated accordingly
-                self.info.insert(
-                    arg.atom_syntax_object().unwrap(),
-                    SemanticInformation::new(
-                        IdentifierStatus::Local,
-                        depth,
-                        arg.atom_syntax_object().unwrap().span,
-                    ),
-                );
-            }
-        }
-    }
-
-    fn pop_top_layer(&mut self) -> FxHashMap<InternedString, ScopeInfo> {
-        let arguments = self
-            .scope
-            .iter_top()
-            .map(|x| (x.0.clone(), x.1.clone()))
-            .collect::<FxHashMap<_, _>>();
-
-        self.scope.pop_layer();
-
-        arguments
-    }
-
-    fn find_and_mark_captured_arguments(
-        &mut self,
-        lambda_function: &LambdaFunction,
-        captured_vars: &FxHashMap<InternedString, ScopeInfo>,
-        depth: usize,
-        arguments: &FxHashMap<InternedString, ScopeInfo>,
-    ) {
-        for var in &lambda_function.args {
-            let ident = var.atom_identifier().unwrap();
-
-            let kind = if let Some(info) = captured_vars.get(ident) {
-                if info.mutated {
-                    IdentifierStatus::HeapAllocated
-                } else {
-                    IdentifierStatus::Captured
-                }
-            } else if let Some(info) = self.info.get(var.atom_syntax_object().unwrap()) {
-                match info.kind {
-                    IdentifierStatus::HeapAllocated => IdentifierStatus::HeapAllocated,
-                    _ => IdentifierStatus::Local,
-                }
-            } else {
-                IdentifierStatus::Local
-            };
-
-            let mut semantic_info =
-                SemanticInformation::new(kind, depth, var.atom_syntax_object().unwrap().span);
-
-            // Update the usage count to collect how many times the variable was referenced
-            // Inside of the scope in which the variable existed
-            // TODO: merge this into one
-            let count = arguments.get(ident).unwrap().usage_count;
-
-            // if count == 0 {
-            // log::debug!("Found unused argument: {:?}", ident);
-            // }
-
-            semantic_info = semantic_info.with_usage_count(count);
-
-            // If this variable name is already in scope, we should mark that this variable
-            // shadows the previous id
-            if let Some(shadowed_var) = self.scope.get(ident) {
-                semantic_info = semantic_info.shadows(shadowed_var.id)
-            }
-
-            self.info
-                .update_with(var.atom_syntax_object().unwrap(), semantic_info);
-        }
-    }
-
-    fn visit_with_tail_call_eligibility(&mut self, expr: &'a ExprKind, state: bool) {
-        let eligibility = self.tail_call_eligible;
-        self.tail_call_eligible = state;
-        self.visit(expr);
-        self.tail_call_eligible = eligibility;
-    }
-}
-
-impl<'a> VisitorMutUnitRef<'a> for AnalysisPass<'a> {
-    // TODO: define expressions are not handled by this for stack offset purposes
-    fn visit_define(&mut self, define: &'a crate::parser::ast::Define) {
-        self.visit_define_without_body(define, IdentifierStatus::Local);
-
-        let define_ctx = self.defining_context.take();
-
-        // Mark defining context
-        self.defining_context = define.name_id();
-        self.visit_with_tail_call_eligibility(&define.body, false);
-        self.defining_context = define_ctx;
-    }
-
-    // Quoted values are just constants - lets ignore them for now?
-    fn visit_quote(&mut self, _quote: &'a crate::parser::ast::Quote) {}
-
-    fn visit_if(&mut self, f: &'a crate::parser::ast::If) {
-        // Explicitly disallow a tail call in the test expression
-        // There is no way that this could be a tail call
-
-        self.visit_with_tail_call_eligibility(&f.test_expr, false);
-
-        self.visit(&f.then_expr);
-        self.visit(&f.else_expr);
-    }
-
-    fn visit_list(&mut self, l: &'a List) {
-        let eligibility = self.tail_call_eligible;
-        let escape = self.escape_analysis;
-
-        // In this case, each of the arguments (including the function itself) are not in the tail position
-        // However, the function call _itself_ might be in the tail position, so we save that state
-        self.tail_call_eligible = false;
-
-        // Save the spot in the recursion - here we might be in something like this:
-        // (lambda (x y)
-        //      (+ 10 (let ((z (function-call))) (+ x y z))))
-        // In this case the 10 will be on the stack, but will be reset after
-        // the function call.
-        let stack_offset = self.stack_offset;
-
-        for expr in &l.args[1..] {
-            self.escape_analysis = true;
-
-            self.visit(expr);
-
-            self.stack_offset += 1;
-        }
-
-        if !l.is_empty() {
-            // self.tail_call_eligible = eligibility;
-            self.escape_analysis = eligibility;
-
-            if let ExprKind::LambdaFunction(_) = &l.args[0] {
-                self.escape_analysis = false;
-            }
-
-            self.visit(&l.args[0]);
-        }
-
-        self.stack_offset = stack_offset;
-
-        self.tail_call_eligible = eligibility;
-        self.escape_analysis = escape;
-
-        // TODO: Come back here on cleanup
-        // This just checks that this is actually a real function call and not just an empty list
-        // Every actual call site should in fact have a real span, otherwise its a bit of a waste to include
-        // that information - it _has_ to at least be calling something
-        if !l.is_empty() {
-            // Mark the call site - see what happens
-            let mut call_site_kind = if eligibility && self.scope.depth() > 1 {
-                CallKind::TailCall
-            } else {
-                CallKind::Normal
-            };
-
-            let syntax_object = l.first().and_then(|x| x.atom_syntax_object());
-
-            if let Some(func) = syntax_object {
-                let span = func.span;
-
-                // Assuming this information is here, otherwise we'll panic for whatever reason the symbol is missing
-                // But this shouldn't happen given that we're checking this _after_ we visit the function
-                if let Some(func_info) = self.info.get(func) {
-                    // If we've managed to resolve this call site to the definition, then we should be able
-                    // to identify if this refers to the correct definition
-                    if call_site_kind == CallKind::TailCall
-                        && self.defining_context.is_some()
-                        && func_info.refers_to == self.defining_context
-                    {
-                        call_site_kind = CallKind::SelfTailCall(self.defining_context_depth);
-                    }
-
-                    self.info.call_info.insert(
-                        l.syntax_object_id,
-                        CallSiteInformation::new(call_site_kind, span),
-                    );
-                }
-            }
-        }
-    }
-
-    // TODO: -> understand stack offset here. Should begins drop everything inside?
-    fn visit_begin(&mut self, begin: &'a crate::parser::ast::Begin) {
-        // Collect all of the defines inside of the body first
-        for expr in &begin.exprs {
-            if let ExprKind::Define(define) = expr {
-                if define.body.lambda_function().is_some() {
-                    self.visit_define_without_body(
-                        define,
-                        IdentifierStatus::LocallyDefinedFunction,
-                    );
-                }
-            }
-        }
-
-        // TODO: Log the fact we have an empty begin body, or figure out what that is
-        if begin.exprs.is_empty() {
-            // self.stack_offset -= 1;
-
-            return;
-        }
-
-        let last = begin.exprs.len() - 1;
-
-        // TODO: Clean up this bad pattern
-        let eligibility = self.tail_call_eligible;
-        self.tail_call_eligible = false;
-
-        // After that, we can continue with everything but those
-        for (index, expr) in begin.exprs.iter().enumerate() {
-            if index == last {
-                self.tail_call_eligible = eligibility;
-            }
-
-            if let ExprKind::Define(define) = expr {
-                let define_ctx = self.defining_context.take();
-                let old_depth = self.defining_context_depth;
-                self.defining_context = define.name_id();
-                self.defining_context_depth = 0;
-
-                if define.body.lambda_function().is_some() {
-                    // Continue with the rest of the body here
-                    self.visit(&define.body);
-                } else {
-                    self.visit(expr);
-                }
-
-                self.defining_context = define_ctx;
-                self.defining_context_depth = old_depth;
-            } else {
-                self.visit(expr);
-            }
-
-            self.tail_call_eligible = false;
-        }
-
-        // Overall, 1 for the total
-
-        if !begin.exprs.is_empty() {
-            // println!("BUMPTING STACK OFFSET FOR BEGIN");
-
-            // let is_top_level = self.scope.depth() == 1;
-            // println!("Bumping stack")
-
-            // if is_top_level {
-            // println!("Top level begin bumping stack");
-            // }
-
-            // if !is_top_level {
-            // println!("BUMPING STACK OFFSET FOR BEGIN");
-            // self.stack_offset += 1;
-            // } else {
-            // println!("Skiping.. top level ");
-            // }
-
-            // self.stack_offset += 1;
-        }
-
-        self.tail_call_eligible = eligibility;
-    }
-
-    #[allow(dead_code, unused)]
-    fn visit_let(&mut self, l: &'a crate::parser::ast::Let) {
-        let eligibility = self.tail_call_eligible;
-        self.tail_call_eligible = false;
-
-        let mut stack_offset = self.stack_offset;
-        let rollback_offset = stack_offset;
-
-        for expr in l.expression_arguments() {
-            self.visit(expr);
-            self.stack_offset += 1;
-        }
-
-        self.tail_call_eligible = eligibility;
-
-        let is_top_level = self.scope.depth() == 1;
-
-        if is_top_level {
-            self.scope.push_layer();
-        }
-
-        let alloc_capture_count = self
-            .function_context
-            .and_then(|x| self.info.function_info.get(&x))
-            .map(|x| {
-                x.captured_vars()
-                    .values()
-                    .filter(|x| x.captured && x.mutated)
-                    .count()
-            });
-
-        // We don't want to include normal variables when keeping track
-        // of the offset
-        let mut mutable_var_offset = 0;
-
-        for arg in l.local_bindings() {
-            // println!("{}", arg);
-            // println!("{}", l);
-
-            let name = arg.atom_identifier().unwrap();
-            let id = arg.atom_syntax_object().unwrap().syntax_object_id;
-
-            let heap_alloc = if let Some(info) = self.info.let_info.get(&l.syntax_object_id) {
-                if let Some(info) = info.arguments.get(name) {
-                    info.mutated && info.captured
-                } else {
-                    false
-                }
-            } else {
-                false
-            };
-
-            #[allow(clippy::diverging_sub_expression)]
-            if heap_alloc {
-                self.scope.define(
-                    *name,
-                    ScopeInfo::new_heap_allocated_var(
-                        id,
-                        todo!("Need to include the stack offset here!"),
-                        mutable_var_offset + alloc_capture_count.unwrap(),
-                    ),
-                );
-
-                // Throw in a dummy info so that no matter what, we have something to refer to
-                // in the event of a set!
-                // Later on in this function this gets updated accordingly
-                self.info.insert(
-                    arg.atom_syntax_object().unwrap(),
-                    SemanticInformation::new(
-                        IdentifierStatus::HeapAllocated,
-                        self.scope.depth(),
-                        arg.atom_syntax_object().unwrap().span,
-                    ),
-                );
-
-                mutable_var_offset += 1;
-            } else {
-                // println!("---------------");
-                // println!("Defining: {} @ stack offset: {}", name, stack_offset);
-                // println!("Rollback offset: {}", rollback_offset);
-                // println!("{}", l);
-                // println!("Top Level: {}", is_top_level);
-
-                self.scope
-                    .define(*name, ScopeInfo::new_local(id, stack_offset));
-
-                self.info.insert(
-                    arg.atom_syntax_object().unwrap(),
-                    SemanticInformation::new(
-                        IdentifierStatus::LetVar,
-                        self.scope.depth(),
-                        arg.atom_syntax_object().unwrap().span,
-                    ),
-                );
-            }
-
-            stack_offset += 1;
-        }
-
-        self.visit(&l.body_expr);
-
-        // This is a little silly but I'm not sure why I can't call the default method on the FxHashMap directly
-        let mut arguments = FxHashMap::with_capacity_and_hasher(
-            l.bindings.len(),
-            BuildHasherDefault::<FxHasher>::default(),
-        );
-
-        for arg in l.local_bindings() {
-            let name = arg.atom_identifier().unwrap();
-
-            // dbg!(name.resolve());
-            // dbg!(self.scope.keys().map(|x| x.resolve()).collect::<Vec<_>>());
-
-            arguments.insert(*name, self.scope.remove(name).unwrap());
-        }
-
-        if let hash_map::Entry::Vacant(e) = self.info.let_info.entry(l.syntax_object_id) {
-            e.insert(LetInformation::new(
-                // self.stack_offset,
-                rollback_offset,
-                self.function_context,
-                arguments,
-            ));
-        }
-
-        if is_top_level {
-            self.scope.pop_layer();
-        }
-
-        self.stack_offset = rollback_offset;
-    }
-
-    fn visit_lambda_function(&mut self, lambda_function: &'a crate::parser::ast::LambdaFunction) {
-        let stack_offset_rollback = self.stack_offset;
-
-        // The captures correspond to what variables _this_ scope should decide to capture, and also
-        // arbitrarily decide the index for that capture
-        self.captures.push_layer();
-
-        // In this case, we've actually already seen this function. This works if we're on the second pass
-        // of running this analysis with the same information
-        if let Some(function_info) = self
-            .info
-            .function_info
-            .get_mut(&lambda_function.syntax_object_id)
-        {
-            // TODO: see if this was necessary
-            if function_info.escapes {
-                self.defining_context = None;
-            }
-
-            let vars = &mut function_info.captured_vars;
-
-            // TODO:
-            // If this var is both captured and mutated, lets separate it for a different kind
-            // of allocation - this way we can actually separately allocate where these go. Since it is possible
-            // that a variable is both captured, and mutated by both the closure and the stack, we want to
-            // make sure that things that get captured and mutated end up on the heap, and both references
-            // point to the same thing
-
-            // Handle the immutable variables being patched in
-            {
-                let mut sorted_vars = vars.iter_mut().filter(|x| !x.1.mutated).collect::<Vec<_>>();
-                sorted_vars.sort_by_key(|x| x.1.id);
-
-                // So for now, we sort by id, then map these directly to indices that will live in the
-                // corresponding captured closure
-                for (index, (key, value)) in sorted_vars.iter_mut().enumerate() {
-                    // If we've already captured this variable, mark it as being captured from the enclosing environment
-                    // TODO: If there is shadowing, this might not work?
-                    if let Some(captured_var) = self.captures.get(key) {
-                        // TODO: If the key already exists, we need to check if we're shadowing
-                        // the variable - I think we can do this by checking what the variable shadows?
-
-                        // Check if this variable shadows another one. If so, we defer to the
-                        // notion that this is a fresh variable
-                        // if let Some(analysis) = self.captures.contains_key_at_top(key) {
-                        if self.captures.depth_of(key).unwrap() > 1 {
-                            value.capture_offset = Some(index);
-                            value.read_capture_offset = Some(index);
-                            let mut value = value.clone();
-                            value.captured_from_enclosing = false;
-
-                            self.captures.define(key.clone(), value);
-
-                            continue;
-                        }
-
-                        value.capture_offset = captured_var.read_capture_offset;
-
-                        value.read_capture_offset = Some(index);
-
-                        let mut value = value.clone();
-                        value.captured_from_enclosing = true;
-
-                        self.captures.define(key.clone(), value)
-                    } else {
-                        value.capture_offset = Some(index);
-                        value.read_capture_offset = Some(index);
-                        let mut value = value.clone();
-                        value.captured_from_enclosing = false;
-
-                        self.captures.define(key.clone(), value);
-                    }
-                }
-            }
-
-            {
-                let mut captured_and_mutated =
-                    vars.iter_mut().filter(|x| x.1.mutated).collect::<Vec<_>>();
-                captured_and_mutated.sort_by_key(|x| x.1.id);
-
-                for (index, (key, value)) in captured_and_mutated.iter_mut().enumerate() {
-                    // value.heap_offset = Some(index);
-
-                    // If we've already captured this variable, mark it as being captured from the enclosing environment
-                    // TODO: If there is shadowing, this might not work?
-                    if self.captures.contains_key(key) {
-                        if self.captures.depth_of(key).unwrap() > 1 {
-                            value.heap_offset = value.stack_offset;
-                            value.read_heap_offset = Some(index);
-
-                            value.parent_heap_offset = value.stack_offset;
-                            value.local_heap_offset = Some(index);
-
-                            let mut value = value.clone();
-                            value.captured_from_enclosing = false;
-
-                            self.captures.define(key.clone(), value);
-
-                            continue;
-                        }
-
-                        // TODO: If theres weird bugs here, match behavior of the captures from above
-                        // i.e. heap offset just patches in the read offset from the parent
-                        value.heap_offset = self.captures.get(key).and_then(|x| x.read_heap_offset);
-
-                        // value.read_heap_offset =
-                        //     self.captures.get(key).and_then(|x| x.read_heap_offset);
-
-                        value.read_heap_offset = Some(index);
-
-                        value.parent_heap_offset =
-                            self.captures.get(key).and_then(|x| x.local_heap_offset);
-
-                        value.local_heap_offset = Some(index);
-
-                        let mut value = value.clone();
-                        value.captured_from_enclosing = true;
-
-                        self.captures.define(key.clone(), value);
-                    } else {
-                        value.heap_offset = value.stack_offset;
-                        value.read_heap_offset = Some(index);
-
-                        value.parent_heap_offset = value.stack_offset;
-                        value.local_heap_offset = Some(index);
-
-                        let mut value = value.clone();
-                        value.captured_from_enclosing = false;
-
-                        self.captures.define(key.clone(), value);
-                    }
-                }
-            }
-        }
-
-        // We're entering a new scope since we've entered a lambda function
-        self.scope.push_layer();
-
-        let let_level_bindings = lambda_function.arguments().unwrap();
-        let depth = self.scope.depth();
-
-        self.visit_func_args(lambda_function, depth);
-
-        self.stack_offset = lambda_function.args.len();
-
-        let function_context = self.function_context.take();
-        self.function_context = Some(lambda_function.syntax_object_id);
-
-        self.defining_context_depth += 1;
-
-        // Set the single used to this scope to be a new set
-        self.vars_used = im_rc::HashSet::new();
-
-        self.contains_lambda_func = false;
-
-        // TODO: Better abstract this pattern - perhaps have the function call be passed in?
-        self.visit_with_tail_call_eligibility(&lambda_function.body, true);
-
-        let lambda_bottoms_out = !self.contains_lambda_func;
-
-        self.contains_lambda_func = true;
-
-        for var in &self.vars_used {
-            self.total_vars_used.insert(var.clone());
-        }
-
-        self.defining_context_depth -= 1;
-
-        self.function_context = function_context;
-
-        // TODO: @Matt: 11/3/2022 -> Seems like theres kind of a bad problem here.
-        // This map that we're getting is much bigger than expected
-        // Perhaps take the diff of the vars before visiting this, and after? Then reset the state after visiting this tree?
-        let mut captured_vars = self.get_captured_vars(&let_level_bindings);
-
-        for (var, value) in self.captures.iter() {
-            if let Some(scope_info) = captured_vars.get_mut(var) {
-                scope_info.captured_from_enclosing = value.captured_from_enclosing;
-            }
-        }
-
-        if log::log_enabled!(log::Level::Trace) {
-            log::trace!("Captured variables: {:?}", captured_vars);
-        }
-
-        // Get the arguments to get the counts
-        // Pop the layer here - now, we check if any of the arguments below actually already exist
-        // in scope. If thats the case, we've shadowed and should mark it accordingly.
-        let arguments = self.pop_top_layer();
-
-        // Pop off of the captures
-        self.captures.pop_layer();
-
-        // Mark the last usage of the variable after the values go out of scope
-        // TODO: This should get moved to every tail call -> if its a tail call, mark
-        // the last usage of the variables there. That way, all exit points of the function
-        // actually get marked
-
-        for id in arguments.values().filter_map(|x| x.last_used) {
-            self.info.get_mut(&id).unwrap().last_usage = true;
-        }
-
-        // println!("{:#?}", arguments);
-
-        // Using the arguments, mark the vars that have been captured
-        self.find_and_mark_captured_arguments(lambda_function, &captured_vars, depth, &arguments);
-
-        // If we've already seen this function, lets not do anything just quite yet
-        if let Some(info) = self
-            .info
-            .function_info
-            .get_mut(&lambda_function.syntax_object_id)
-        {
-            let mut slated_for_removal = Vec::new();
-
-            if lambda_bottoms_out {
-                captured_vars.retain(|x: &InternedString, _| self.vars_used.contains(x));
-
-                for var in info.captured_vars.keys() {
-                    if !captured_vars.contains_key(var) {
-                        slated_for_removal.push(var.clone());
-                    }
-                }
-
-                for var in slated_for_removal {
-                    info.captured_vars.remove(&var);
-                }
-
-                // println!("Captured vars dropped: {}", before - captured_vars.len());
-            }
-
-            for (var, value) in captured_vars {
-                if let Some(scope_info) = info.captured_vars.get_mut(&var) {
-                    scope_info.captured_from_enclosing = value.captured_from_enclosing;
-                    scope_info.heap_offset = value.heap_offset;
-                };
-            }
-
-            self.stack_offset = stack_offset_rollback;
-
-            return;
-        } else {
-            // Capture the information and store it in the semantic analysis for this individual function
-            self.info.function_info.insert(
-                lambda_function.syntax_object_id,
-                FunctionInformation::new(captured_vars, arguments)
-                    .escapes(self.escape_analysis)
-                    .depth(self.scope.depth()),
-            );
-        }
-
-        self.stack_offset = stack_offset_rollback;
-    }
-
-    fn visit_set(&mut self, s: &'a crate::parser::ast::Set) {
-        let name = s.variable.atom_identifier();
-        // let id = s.variable.atom_syntax_object().map(|x| x.syntax_object_id);
-
-        if let Some(info) = s
-            .variable
-            .atom_syntax_object()
-            .and_then(|x| self.info.get(x))
-        {
-            if info.refers_to == self.defining_context {
-                self.defining_context = None;
-            }
-        }
-
-        self.visit_with_tail_call_eligibility(&s.expr, false);
-
-        if let Some(name) = name {
-            // Mark that we've used this
-            self.vars_used.insert(*name);
-
-            // Gather the id of the variable that is in fact mutated
-            if let Some(scope_info) = self.scope.get_mut(name) {
-                // Bump the usage count
-                // TODO Also mark this as mutated
-                scope_info.usage_count += 1;
-
-                let id = scope_info.id;
-                if let Some(var) = self.info.get_mut(&id) {
-                    var.set_bang = true;
-                    scope_info.mutated = true;
-                    // scope_info.read_heap_offset = var.read_heap_offset;
-
-                    // while let Some(reference) = var.refers_to.and_then(|x| self.info.get_mut(&x)) {
-                    //     reference.set_bang = true;
-                    //     var = reference;
-                    // }
-
-                    // var.refers
-                }
-                // else {
-                //     log::debug!("Unable to find var: {name} in info map to update to set!");
-                // }
-            }
-            // else {
-            //     log::debug!("Variable not yet in scope: {name}");
-            // }
-        }
-
-        self.visit(&s.variable);
-    }
-
-    fn visit_atom(&mut self, a: &'a crate::parser::ast::Atom) {
-        let name = a.ident();
-        let depth = self.scope.depth();
-        // Snag the current id of this node - we're gonna want this for later
-        let current_id = a.syn.syntax_object_id;
-
-        // TODO: Check if this is actually a constant - if it is, mark it accordingly and lift it out
-
-        if let Some(ident) = name {
-            // Mark that we've seen this one
-            self.vars_used.insert(*ident);
-            // Mark that this was perhaps used in tail position
-            self.ids_referenced_in_tail_position.insert(current_id);
-
-            // Check if its a global var - otherwise, we want to check if its a free
-            // identifier
-            if let Some(depth) = self.scope.height_of(ident) {
-                if depth == 0 {
-                    // Mark the parent as used
-                    let global_var = self.scope.get_mut(ident).unwrap();
-                    global_var.usage_count += 1;
-
-                    self.info.get_mut(&global_var.id).unwrap().usage_count += 1;
-
-                    let mut semantic_information =
-                        SemanticInformation::new(IdentifierStatus::Global, depth, a.syn.span)
-                            .with_usage_count(1)
-                            .refers_to(global_var.id);
-
-                    // if self.info.info.get(&global_var.id).unwrap().builtin {
-                    //     println!("FOUND USAGE OF BUILTIN: {}", ident);
-                    // }
-
-                    // TODO: We _really_ should be providing the built-ins in a better way thats not
-                    // passing around a thread local
-                    if crate::steel_vm::primitives::PRELUDE_MODULE
-                        .with(|x| x.contains(ident.resolve()))
-                    {
-                        semantic_information.mark_builtin()
-                    }
-
-                    self.info.insert(&a.syn, semantic_information);
-
-                    return;
-                }
-            }
-
-            // If this contains a key at the top, then it shouldn't be marked as captured by this scope
-            if self.scope.contains_key_at_top(ident) {
-                // Set it to not be captured if its contained at the top level
-                // self.scope.get_mut(ident).unwrap().captured = false;
-
-                let mut_ref = self.scope.get_mut(ident).unwrap();
-
-                // Not sure if this is going to be a problem...
-                // Because if its captured at this stage, I think we want it to be marked as captured
-                // TODO:
-                // mut_ref.captured = false;
-                mut_ref.usage_count += 1;
-
-                // Mark this as last touched by this identifier
-                mut_ref.last_used = Some(current_id);
-
-                // In the event there is a local define, we want to count the usage here
-                if let Some(local_define) = self.info.get_mut(&mut_ref.id) {
-                    local_define.usage_count = mut_ref.usage_count;
-                }
-
-                let mut semantic_info =
-                    SemanticInformation::new(IdentifierStatus::Local, depth, a.syn.span)
-                        .with_usage_count(1)
-                        .refers_to(mut_ref.id);
-
-                if let Some(stack_offset) = mut_ref.stack_offset {
-                    semantic_info = semantic_info.with_offset(stack_offset);
-                } else {
-                    // log::debug!("Stack offset missing from local define")
-                }
-
-                if mut_ref.captured && mut_ref.mutated {
-                    semantic_info.kind = IdentifierStatus::HeapAllocated;
-                    semantic_info.heap_offset = mut_ref.heap_offset;
-                    semantic_info.read_heap_offset = mut_ref.read_heap_offset;
-                }
-
-                self.info.insert(&a.syn, semantic_info);
-
-                return;
-            }
-
-            // This is the result of some fancy fancy stuff
-            // We are going to do two of these passes to resolve captures, where the first pass does a holistic
-            // analysis of captures for each closure. Then we can do a top down analysis
-            // which populates the closures with their capture positions, and then when we do analysis the
-            // second time, we'll have closure references populated.
-            if let Some(captured) = self.captures.get_mut(ident) {
-                // TODO: Fill in this information here - when the vars are captured in the immediate enclosing,
-                // we want to do stuff....
-
-                captured.captured = true;
-                captured.usage_count += 1;
-
-                // TODO: Make sure we want to mark this identifier as last used
-                captured.last_used = Some(current_id);
-
-                let mut identifier_status = if captured.mutated {
-                    IdentifierStatus::HeapAllocated
-                } else if let Some(info) = self.info.get(&a.syn) {
-                    if info.kind == IdentifierStatus::HeapAllocated {
-                        IdentifierStatus::HeapAllocated
-                    } else {
-                        IdentifierStatus::Captured
-                    }
-                } else {
-                    IdentifierStatus::Captured
-                };
-
-                // We also want to mark the current var thats actually in scope as last used as well
-                if let Some(in_scope) = self.scope.get_mut(ident) {
-                    in_scope.last_used = Some(current_id);
-                    in_scope.captured = true;
-
-                    // if identifier_status == IdentifierStatus::HeapAllocated {
-                    //     in_scope.read_heap_offset = captured.read_heap_offset;
-                    // }
-                }
-
-                if let Some(local_define) = self.info.get_mut(&captured.id) {
-                    local_define.usage_count = captured.usage_count;
-
-                    // If this _is_ in fact a locally defined function, we don't want to capture it
-                    // This is something that is going to get lifted to the top environment anyway
-                    if local_define.kind == IdentifierStatus::LocallyDefinedFunction {
-                        captured.captured = false;
-                        identifier_status = IdentifierStatus::LocallyDefinedFunction;
-                    }
-                }
-
-                let mut semantic_info =
-                    SemanticInformation::new(identifier_status, depth, a.syn.span)
-                        .with_usage_count(1)
-                        .refers_to(captured.id);
-
-                // TODO: Merge the behavior of all of these separate cases into one
-                semantic_info.with_captured_from_enclosing(captured.captured_from_enclosing);
-
-                // If we're getting captured and mutated, then we should be fine to do these checks
-                // exclusively
-                if let Some(capture_offset) = captured.read_capture_offset {
-                    semantic_info = semantic_info.with_read_capture_offset(capture_offset);
-                    semantic_info =
-                        semantic_info.with_capture_index(captured.capture_offset.unwrap());
-                }
-
-                if let Some(heap_offset) = captured.read_heap_offset {
-                    // semantic_info = semantic_info.with_heap_offset(heap_offset);
-                    semantic_info = semantic_info.with_read_heap_offset(heap_offset);
-                } else {
-                    // log::debug!("Stack offset missing from local define")
-                }
-
-                if let Some(heap_offset) = captured.heap_offset {
-                    // semantic_info = semantic_info.with_heap_offset(heap_offset);
-                    semantic_info = semantic_info.with_heap_offset(heap_offset);
-                } else {
-                    // log::debug!("Stack offset missing from local define")
-                }
-
-                // if semantic_info.kind == IdentifierStatus::HeapAllocated
-                //     && semantic_info.read_heap_offset.is_none()
-                // {
-                //     panic!("Missing read heap offset here");
-                // }
-
-                // println!("Variable {} refers to {}", ident, is_captured.id);
-
-                self.info.insert(&a.syn, semantic_info);
-
-                return;
-            }
-
-            // Otherwise, go ahead and mark it as captured if we can find a reference to it
-            // TODO: @Matt - There is an opportunity here to also check extra information. If the
-            // variables exists in the local scope - i.e, the var has been patched in via a closure,
-            // we could 1. do closure conversion on it via rewriting, or could 2. automatically
-            // patch those vars in
-            if let Some(is_captured) = self.scope.get_mut(ident) {
-                is_captured.captured = true;
-                is_captured.usage_count += 1;
-
-                // TODO: Make sure we want to mark this identifier as last used
-                is_captured.last_used = Some(current_id);
-
-                let mut identifier_status = IdentifierStatus::Captured;
-
-                if let Some(local_define) = self.info.get_mut(&is_captured.id) {
-                    local_define.usage_count = is_captured.usage_count;
-
-                    // If this _is_ in fact a locally defined function, we don't want to capture it
-                    // This is something that is going to get lifted to the top environment anyway
-                    if local_define.kind == IdentifierStatus::LocallyDefinedFunction {
-                        // is_captured.captured = false;
-                        identifier_status = IdentifierStatus::LocallyDefinedFunction;
-                    }
-                }
-
-                let mut semantic_info =
-                    SemanticInformation::new(identifier_status, depth, a.syn.span)
-                        .with_usage_count(1)
-                        .refers_to(is_captured.id);
-                // .with_offset(
-                //     is_captured
-                //         .stack_offset
-                //         .expect("Local variables should have an offset"),
-                // );
-
-                if let Some(stack_offset) = is_captured.stack_offset {
-                    semantic_info = semantic_info.with_offset(stack_offset);
-                } else {
-                    // log::debug!("Stack offset missing from local define")
-                }
-
-                // println!("Variable {} refers to {}", ident, is_captured.id);
-
-                self.info.insert(&a.syn, semantic_info);
-
-                return;
-            }
-
-            // TODO: Check if we've already marked it as free - also count its usage!
-
-            if let Some(analysis) = self.info.info.get_mut(&a.syn.syntax_object_id) {
-                analysis.usage_count += 1;
-            } else {
-                let mut semantic_info =
-                    SemanticInformation::new(IdentifierStatus::Free, depth, a.syn.span);
-
-                // TODO: We _really_ should be providing the built-ins in a better way thats not
-                // passing around a thread local
-                if crate::steel_vm::primitives::PRELUDE_MODULE.with(|x| x.contains(ident.resolve()))
-                {
-                    semantic_info.mark_builtin();
-                    semantic_info.kind = IdentifierStatus::Global
-                }
-
-                // Otherwise, we've hit a free variable at this point
-                // TODO: WE don't need to do this?
-                self.info.info.insert(a.syn.syntax_object_id, semantic_info);
-            }
-
-            // let mut semantic_info =
-            //     SemanticInformation::new(IdentifierStatus::Free, depth, a.syn.span);
-
-            // // TODO: We _really_ should be providing the built-ins in a better way thats not
-            // // passing around a thread local
-            // if crate::steel_vm::primitives::PRELUDE_MODULE.with(|x| x.contains(ident.resolve())) {
-            //     semantic_info.mark_builtin();
-            //     semantic_info.kind = IdentifierStatus::Global
-            // }
-
-            // // Otherwise, we've hit a free variable at this point
-            // // TODO: WE don't need to do this?
-            // self.info.insert(&a.syn, semantic_info);
-
-            // println!("Free identifier: {}", a);
-        }
-    }
-}
-
-impl<'a> VisitorMutUnitRef<'a> for Analysis {
-    fn visit_atom(&mut self, a: &'a crate::parser::ast::Atom) {
-        if log::log_enabled!(log::Level::Trace) {
-            log::trace!(
-                "Id: {:?}, Atom: {:?}, Semantic Information: {:?}",
-                a.syn.syntax_object_id,
-                a.syn.ty,
-                self.get(&a.syn)
-            );
-        }
-    }
-
-    fn visit_lambda_function(&mut self, lambda_function: &'a crate::parser::ast::LambdaFunction) {
-        for arg in &lambda_function.args {
-            if let Some(arg) = arg.atom_syntax_object() {
-                if log::log_enabled!(log::Level::Trace) {
-                    log::trace!(
-                        "Id: {:?}, Atom in function argument: {:?}, Semantic Information: {:?}",
-                        arg.syntax_object_id,
-                        arg.ty,
-                        self.get(arg)
-                    );
-                }
-            }
-        }
-
-        self.visit(&lambda_function.body);
-    }
-}
-
-pub fn query_top_level_define_on_condition<A: AsRef<str>>(
-    exprs: &[ExprKind],
-    name: A,
-    mut func: impl FnMut(&str, &str) -> bool,
-) -> Option<&crate::parser::ast::Define> {
-    let mut found_defines = Vec::new();
-    for expr in exprs {
-        match expr {
-            ExprKind::Define(d) => match d.name.atom_identifier() {
-                Some(n) if func(name.as_ref(), n.resolve()) => found_defines.push(d.as_ref()),
-                _ => {}
-            },
-
-            ExprKind::Begin(b) => {
-                for expr in b.exprs.iter() {
-                    if let ExprKind::Define(d) = expr {
-                        match d.name.atom_identifier() {
-                            Some(n) if func(name.as_ref(), n.resolve()) => {
-                                found_defines.push(d.as_ref())
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-            }
-
-            _ => {}
-        }
-    }
-
-    if found_defines.len() > 1 {
-        log::debug!(
-            "Multiple defines found, unable to find one unique value to associate with a name"
-        );
-        return None;
-    }
-
-    if found_defines.len() == 1 {
-        return found_defines.into_iter().next();
-    }
-
-    None
-}
-
-pub fn query_top_level_define<A: AsRef<str>>(
-    exprs: &[ExprKind],
-    name: A,
-) -> Option<&crate::parser::ast::Define> {
-    let mut found_defines = Vec::new();
-    for expr in exprs {
-        match expr {
-            ExprKind::Define(d) => match d.name.atom_identifier() {
-                Some(n) if name.as_ref() == n.resolve() => found_defines.push(d.as_ref()),
-                _ => {}
-            },
-
-            ExprKind::Begin(b) => {
-                for expr in b.exprs.iter() {
-                    if let ExprKind::Define(d) = expr {
-                        match d.name.atom_identifier() {
-                            Some(n) if name.as_ref() == n.resolve() => {
-                                found_defines.push(d.as_ref())
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-            }
-
-            _ => {}
-        }
-    }
-
-    if found_defines.len() > 1 {
-        log::debug!(
-            "Multiple defines found, unable to find one unique value to associate with a name"
-        );
-        return None;
-    }
-
-    if found_defines.len() == 1 {
-        return found_defines.into_iter().next();
-    }
-
-    None
-}
-
-struct FindCallSiteById<'a, F> {
-    id: SyntaxObjectId,
-    analysis: &'a Analysis,
-    func: F,
-    modified: bool,
-}
-
-impl<'a, F> FindCallSiteById<'a, F> {
-    pub fn _new(id: SyntaxObjectId, analysis: &'a Analysis, func: F) -> Self {
-        Self {
-            id,
-            analysis,
-            func,
-            modified: false,
-        }
-    }
-
-    // TODO: clean this up a bit
-    pub fn is_required_call_site(&self, l: &List) -> bool {
-        if let Some(refers_to) = l
-            .args
-            .first()
-            .and_then(|x| x.atom_syntax_object())
-            .and_then(|x| self.analysis.get(x))
-            .and_then(|x| x.refers_to)
-        {
-            refers_to == self.id
-        } else {
-            false
-        }
-    }
-}
-
-impl<'a, F> VisitorMutRefUnit for FindCallSiteById<'a, F>
-where
-    F: FnMut(&Analysis, &mut crate::parser::ast::List) -> bool,
-{
-    fn visit_list(&mut self, l: &mut List) {
-        // Go downward and visit each of the arguments (including the function call)
-        for arg in &mut l.args {
-            self.visit(arg);
-        }
-
-        // If we're a match, call the function
-        if self.is_required_call_site(l) {
-            self.modified |= (self.func)(self.analysis, l)
-        }
-    }
-}
-
-struct FindUsages<'a, F> {
-    id: SyntaxObjectId,
-    analysis: &'a Analysis,
-    func: F,
-    modified: bool,
-}
-
-impl<'a, F> FindUsages<'a, F> {
-    pub fn new(id: SyntaxObjectId, analysis: &'a Analysis, func: F) -> Self {
-        Self {
-            id,
-            analysis,
-            func,
-            modified: false,
-        }
-    }
-}
-
-impl<'a, F> VisitorMutRefUnit for FindUsages<'a, F>
-where
-    F: FnMut(&Analysis, &mut crate::parser::ast::Atom) -> bool,
-{
-    fn visit_atom(&mut self, a: &mut Atom) {
-        if let Some(refers_to) = self.analysis.get(&a.syn).and_then(|x| x.refers_to) {
-            if refers_to == self.id {
-                self.modified |= (self.func)(self.analysis, a)
-            }
-        }
-    }
-}
-
-struct FindCallSites<'a, F> {
-    name: &'a str,
-    analysis: &'a Analysis,
-    func: F,
-}
-
-impl<'a, F> FindCallSites<'a, F> {
-    pub fn new(name: &'a str, analysis: &'a Analysis, func: F) -> Self {
-        Self {
-            name,
-            analysis,
-            func,
-        }
-    }
-}
-impl<'a, F> FindCallSites<'a, F> {
-    fn is_required_global_function_call(&self, l: &List) -> bool {
-        if let Some(name) = l.first_ident() {
-            if let Some(semantic_info) = self.analysis.get(l.args[0].atom_syntax_object().unwrap())
-            {
-                return name.resolve() == self.name
-                    && semantic_info.kind == IdentifierStatus::Global;
-            }
-        }
-
-        false
-    }
-}
-
-impl<'a, F> VisitorMutUnitRef<'a> for FindCallSites<'a, F>
-where
-    F: FnMut(&Analysis, &crate::parser::ast::List),
-{
-    fn visit_list(&mut self, l: &'a crate::parser::ast::List) {
-        if self.is_required_global_function_call(l) {
-            (self.func)(self.analysis, l)
-        }
-
-        for arg in &l.args {
-            self.visit(arg);
-        }
-    }
-}
-
-impl<'a, F> VisitorMutRefUnit for FindCallSites<'a, F>
-where
-    F: FnMut(&Analysis, &mut crate::parser::ast::List),
-{
-    fn visit_list(&mut self, l: &mut crate::parser::ast::List) {
-        if self.is_required_global_function_call(l) {
-            (self.func)(self.analysis, l)
-        }
-
-        for arg in &mut l.args {
-            self.visit(arg);
-        }
-    }
-}
-
-struct RefreshVars;
-
-impl VisitorMutRefUnit for RefreshVars {
-    fn visit_atom(&mut self, a: &mut Atom) {
-        a.syn.syntax_object_id = SyntaxObjectId::fresh();
-    }
-}
-
-struct MutateCallSites<'a, F> {
-    name: &'a str,
-    analysis: &'a Analysis,
-    func: F,
-}
-
-impl<'a, F> MutateCallSites<'a, F> {
-    pub fn new(name: &'a str, analysis: &'a Analysis, func: F) -> Self {
-        Self {
-            name,
-            analysis,
-            func,
-        }
-    }
-}
-
-impl<'a, F> VisitorMutRefUnit for MutateCallSites<'a, F>
-where
-    F: FnMut(&Analysis, &mut ExprKind),
-{
-    fn visit(&mut self, expr: &mut ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            list @ ExprKind::List(_) => {
-                if let ExprKind::List(l) = &list {
-                    if let Some(name) = l.first_ident() {
-                        if let Some(semantic_info) =
-                            self.analysis.get(l.args[0].atom_syntax_object().unwrap())
-                        {
-                            if name.resolve() == self.name
-                                && semantic_info.kind == IdentifierStatus::Global
-                            {
-                                // At this point, call out to the user given function - if we do in fact mutate
-                                // where the value points to, we should return a full node that needs to be visited
-                                (self.func)(self.analysis, list);
-
-                                // TODO: Analysis should maybe be re run here - mutations might invalidate the analysis
-                                // This might make it worth rerunning the analysis
-
-                                return self.visit(list);
-                            }
-                        }
-                    }
-                }
-
-                if let ExprKind::List(l) = list {
-                    return self.visit_list(l);
-                }
-
-                unreachable!()
-            }
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-}
-
-struct LetCallSites<'a, F> {
-    analysis: &'a Analysis,
-    func: F,
-}
-
-impl<'a, F> LetCallSites<'a, F> {
-    pub fn new(analysis: &'a Analysis, func: F) -> Self {
-        Self { analysis, func }
-    }
-}
-
-impl<'a, F> VisitorMutRefUnit for LetCallSites<'a, F>
-where
-    F: FnMut(&Analysis, &mut ExprKind) -> bool,
-{
-    fn visit(&mut self, expr: &mut ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            let_expr @ ExprKind::Let(_) => {
-                if let ExprKind::Let(l) = let_expr {
-                    self.visit_let(l);
-                }
-
-                if let ExprKind::Let(_) = &let_expr {
-                    if (self.func)(self.analysis, let_expr) {
-                        // log::debug!("Modified let expression");
-                    }
-                }
-            }
-        }
-    }
-}
-
-// TODO: This will need to get changed in the event we actually modify _what_ the mutable pointer points to
-// Right now, if we want to modify a call site, we can only change it to a call site - what we _should_ do is have it be able to point
-// back to any arbitrary value, and subsequently change l to point to that value by doing another level of the recursion
-// Something like:
-// where F: FnMut(&mut ExprKind) -> ()
-// To do this, the main visit loop would need to be goofed with in the visitor, and we pass in the reference to the wrapped object, rather than the underlying one
-struct AnonymousFunctionCallSites<'a, F> {
-    analysis: &'a Analysis,
-    func: F,
-}
-
-impl<'a, F> AnonymousFunctionCallSites<'a, F> {
-    pub fn new(analysis: &'a Analysis, func: F) -> Self {
-        Self { analysis, func }
-    }
-}
-
-impl<'a, F> VisitorMutRefUnit for AnonymousFunctionCallSites<'a, F>
-where
-    F: FnMut(&Analysis, &mut ExprKind) -> bool,
-{
-    fn visit(&mut self, expr: &mut ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            list @ ExprKind::List(_) => {
-                // Bottom up approach - visit everything first, then, on the way back up,
-                // modify the value
-                if let ExprKind::List(l) = list {
-                    self.visit_list(l);
-                }
-
-                if let ExprKind::List(l) = &list {
-                    if l.is_anonymous_function_call() {
-                        // TODO: rerunning analysis might be worth it here - we want to be able to trigger a re run if a mutation would cause a change
-                        // In the state of the analysis
-                        if (self.func)(self.analysis, list) {
-                            // return self.visit(list);
-                            // log::debug!("Modified anonymous function call site!");
-                        }
-                    }
-                }
-            }
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-}
-
-struct RemoveUnusedDefineImports<'a> {
-    analysis: &'a Analysis,
-    depth: usize,
-}
-
-impl<'a> RemoveUnusedDefineImports<'a> {
-    pub fn new(analysis: &'a Analysis) -> Self {
-        Self { analysis, depth: 0 }
-    }
-}
-
-// This should just be a function on the define, not a method - so that it can be moved
-// into a different crate
-pub(crate) fn is_a_builtin_definition(def: &Define) -> bool {
-    if let ExprKind::List(l) = &def.body {
-        match l.first_ident() {
-            Some(func) if *func == *UNREADABLE_MODULE_GET || *func == *STANDARD_MODULE_GET => {
-                // return true
-
-                if let Some(module) = l.second_ident() {
-                    return MODULE_IDENTIFIERS.contains(module);
-                }
-            }
-            _ => {}
-        }
-    }
-
-    false
-}
-
-pub(crate) fn is_a_require_definition(def: &Define) -> bool {
-    if let ExprKind::List(l) = &def.body {
-        match l.first_ident() {
-            Some(func) if *func == *PROTO_HASH_GET => {
-                return true;
-            }
-            _ => {}
-        }
-    }
-
-    false
-}
-
-impl<'a> VisitorMutRefUnit for RemoveUnusedDefineImports<'a> {
-    fn visit_lambda_function(&mut self, lambda_function: &mut LambdaFunction) {
-        self.depth += 1;
-        self.visit(&mut lambda_function.body);
-        self.depth -= 1;
-    }
-
-    fn visit_begin(&mut self, begin: &mut crate::parser::ast::Begin) {
-        // Only remove internal definitions here
-        if self.depth > 0 {
-            let mut exprs_to_drop = Vec::new();
-
-            for (idx, expr) in begin.exprs.iter().enumerate() {
-                if let ExprKind::Define(d) = expr {
-                    if is_a_builtin_definition(&d) {
-                        if let Some(analysis) =
-                            self.analysis.get(d.name.atom_syntax_object().unwrap())
-                        {
-                            if analysis.usage_count == 0 {
-                                exprs_to_drop.push(idx);
-                            }
-                        }
-                    }
-                }
-            }
-
-            for idx in exprs_to_drop.iter().rev() {
-                // println!("Removing: {:?}", begin.exprs.get(*idx));
-                begin.exprs.remove(*idx);
-            }
-
-            if begin.exprs.is_empty() {
-                begin.exprs.push(ExprKind::Quote(Box::new(Quote::new(
-                    ExprKind::atom("void".to_string()),
-                    RawSyntaxObject::default(TokenType::Quote),
-                ))));
-            }
-
-            // println!("Resulting expr: {:?}", begin);
-        }
-
-        for expr in &mut begin.exprs {
-            self.visit(expr);
-        }
-    }
-}
-
-struct RemovedUnusedImports<'a> {
-    analysis: &'a Analysis,
-}
-
-impl<'a> RemovedUnusedImports<'a> {
-    pub fn new(analysis: &'a Analysis) -> Self {
-        Self { analysis }
-    }
-}
-
-impl<'a> VisitorMutRefUnit for RemovedUnusedImports<'a> {
-    fn visit_list(&mut self, l: &mut List) {
-        let mut unused_arguments = Vec::new();
-
-        if l.is_anonymous_function_call() {
-            let argument_count = l.args.len() - 1;
-            if let Some(func) = l.first_func() {
-                if argument_count != func.args.len() {
-                    println!("-- Static arity mismatch -- Should actually error here");
-                } else {
-                    unused_arguments = func
-                        .args
-                        .iter()
-                        .enumerate()
-                        .filter(|x| {
-                            self.analysis
-                                .get(x.1.atom_syntax_object().unwrap())
-                                .unwrap()
-                                .usage_count
-                                == 0
-                        })
-                        .map(|x| x.0)
-                        .filter(|x| match l.args.get(*x) {
-                            Some(ExprKind::List(l)) => l.is_a_builtin_expr(),
-                            Some(ExprKind::Quote(_)) => true,
-                            Some(ExprKind::Atom(a)) => matches!(
-                                a.syn.ty,
-                                TokenType::NumberLiteral(_)
-                                    | TokenType::IntegerLiteral(_)
-                                    | TokenType::BooleanLiteral(_)
-                            ),
-                            _ => false,
-                        })
-                        .collect();
-                }
-            }
-        }
-
-        if let Some(func) = l.first_func_mut() {
-            for index in unused_arguments.iter().rev() {
-                func.args.remove(*index);
-            }
-        }
-
-        for index in unused_arguments.iter().rev() {
-            l.args.remove(index + 1);
-        }
-
-        // println!("Resulting expression: {}", l);
-
-        for arg in &mut l.args {
-            self.visit(arg);
-        }
-    }
-}
-
-struct FreeIdentifierVisitor<'a> {
-    analysis: &'a Analysis,
-    // Check if identifiers is in the globals list before deciding to reject it
-    globals: &'a SymbolMap,
-
-    diagnostics: Vec<(InternedString, &'a SemanticInformation)>,
-}
-
-impl<'a> VisitorMutUnitRef<'a> for FreeIdentifierVisitor<'a> {
-    fn visit_atom(&mut self, a: &'a Atom) {
-        if let Some(info) = self.analysis.get(&a.syn) {
-            if info.kind == IdentifierStatus::Free {
-                if let Some(ident) = a.ident() {
-                    if self.globals.get(ident).is_err() {
-                        self.diagnostics.push((*ident, info));
-                    }
-                }
-            }
-        }
-    }
-}
-
-// TODO: Don't need the analysis at all
-struct IdentifierFinder<'a> {
-    ids: &'a mut HashMap<SyntaxObjectId, Option<InternedString>>,
-}
-
-impl<'a> VisitorMutUnitRef<'a> for IdentifierFinder<'a> {
-    fn visit_atom(&mut self, a: &'a Atom) {
-        if let Some(ident) = a.ident() {
-            self.ids
-                .get_mut(&a.syn.syntax_object_id)
-                .map(|value| *value = Some(*ident));
-        }
-    }
-}
-
-struct FindContextsWithOffset<'a> {
-    analysis: &'a Analysis,
-    offset: usize,
-    source_id: SourceId,
-    contexts: Vec<SemanticInformationType>,
-}
-
-impl<'a> VisitorMutUnitRef<'a> for FindContextsWithOffset<'a> {
-    fn visit_lambda_function(&mut self, lambda_function: &'a LambdaFunction) {
-        if lambda_function.location.span.end >= self.offset {
-            return;
-        }
-
-        let mut span = get_span(&lambda_function.body);
-
-        span.start = lambda_function.location.span.start;
-
-        log::debug!("Lambda function span: {:?} - offset: {}", span, self.offset);
-
-        // This counts, save analysis.
-        // TODO: Memoize the span analysis, this is not performant
-        if span.range().contains(&self.offset) {
-            // TODO: Don't clone this
-            if let Some(info) = self.analysis.get_function_info(lambda_function) {
-                if lambda_function.location.span.source_id == Some(self.source_id) {
-                    self.contexts
-                        .push(SemanticInformationType::Function(info.clone()));
-                }
-            }
-
-            self.visit(&lambda_function.body);
-        }
-    }
-
-    fn visit_let(&mut self, l: &'a Let) {
-        if l.location.span.end >= self.offset {
-            return;
-        }
-
-        let mut span = get_span(&l.body_expr);
-        span.start = l.location.span.start;
-
-        if span.range().contains(&self.offset) {
-            if let Some(info) = self.analysis.let_info.get(&l.syntax_object_id) {
-                if l.location.span.source_id() == Some(self.source_id) {
-                    self.contexts
-                        .push(SemanticInformationType::Let(info.clone()));
-                }
-            }
-
-            l.bindings.iter().for_each(|x| self.visit(&x.1));
-            self.visit(&l.body_expr);
-        }
-    }
-}
-
-struct GlobalDefinitionFinder<'a> {
-    analysis: &'a Analysis,
-    globals: Vec<(InternedString, Span)>,
-}
-
-impl<'a> VisitorMutUnitRef<'a> for GlobalDefinitionFinder<'a> {
-    fn visit_atom(&mut self, a: &'a Atom) {
-        if let Some(info) = self.analysis.get(&a.syn) {
-            if info.kind == IdentifierStatus::Global {
-                self.globals.push((*a.ident().unwrap(), info.span));
-            }
-        }
-    }
-}
-
-struct UnusedArguments<'a> {
-    analysis: &'a Analysis,
-    unused_args: Vec<(InternedString, Span)>,
-}
-
-impl<'a> UnusedArguments<'a> {
-    pub fn new(analysis: &'a Analysis) -> Self {
-        Self {
-            analysis,
-            unused_args: Vec::new(),
-        }
-    }
-}
-
-impl<'a> VisitorMutUnitRef<'a> for UnusedArguments<'a> {
-    fn visit_lambda_function(&mut self, lambda_function: &'a LambdaFunction) {
-        for arg in &lambda_function.args {
-            if let Some(syntax_object) = arg.atom_syntax_object() {
-                if let Some(info) = self.analysis.get(syntax_object) {
-                    if info.usage_count == 0 {
-                        self.unused_args
-                            .push((*arg.atom_identifier().unwrap(), syntax_object.span));
-                    }
-                }
-            }
-        }
-
-        self.visit(&lambda_function.body);
-    }
-}
-
-/// Takes functions that have one argument that is used one time, and inline the function
-/// body and replace the call site.
-// struct InlineFunctionsWithArgumentsUsedOnce<'a> {
-//     analysis: &'a Analysis,
-//     functions_to_inline: FxHashMap<InternedString, ExprKind>,
-// }
-
-// struct FunctionInliner {
-//     variable_to_substitute: ExprKind,
-// }
-
-// impl FunctionInliner {
-
-// }
-
-// TODO: If its _not_ a pure function, we need to both assert that the function
-// does not escape, and then find the captured arguments, assert that those also
-// are immutable captures, and then modify the callsites to pass in those variables
-// as well.
-struct LiftPureFunctionsToGlobalScope<'a> {
-    analysis: &'a Analysis,
-    lifted_functions: Vec<ExprKind>,
-}
-
-impl<'a> LiftPureFunctionsToGlobalScope<'a> {
-    pub fn new(analysis: &'a Analysis) -> Self {
-        Self {
-            analysis,
-            lifted_functions: Vec::new(),
-        }
-    }
-}
-
-fn atom(name: String) -> ExprKind {
-    ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-        name.into(),
-    ))))
-}
-
-impl<'a> VisitorMutRefUnit for LiftPureFunctionsToGlobalScope<'a> {
-    fn visit(&mut self, expr: &mut ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            lambda @ ExprKind::LambdaFunction(_) => {
-                // Do this bottom up - visit the children and on the way up we're going to
-                // apply the transformation
-                if let ExprKind::LambdaFunction(l) = lambda {
-                    for var in &mut l.args {
-                        self.visit(var);
-                    }
-                    self.visit(&mut l.body);
-                }
-
-                if let ExprKind::LambdaFunction(l) = lambda {
-                    if let Some(info) = self.analysis.get_function_info(l) {
-                        // println!("depth: {}", info.depth);
-
-                        // We don't need to lift top level functions to the top level already
-                        if info.depth == 1 {
-                            return;
-                        }
-
-                        for arg in info.arguments().values() {
-                            if arg.mutated {
-                                return;
-                            }
-                        }
-
-                        // If we have no captured variables, this is a pure function for our purposes
-                        if info.captured_vars.is_empty() {
-                            // TODO: If the function is of the shape:
-                            // (lambda (x) (function-call x))
-                            // Don't lift - just replace the lambda with the body, and replace the argument
-                            // with the right thing
-
-                            // Name the closure something mangled, but something we can refer to later
-                            let constructed_name = "##__lifted_pure_function".to_string()
-                                + l.syntax_object_id.to_string().as_ref();
-
-                            // Point the reference to a dummy list - this is just an ephemeral placeholder
-                            let mut dummy = ExprKind::List(List::new(Vec::new()));
-
-                            // Have the lambda now actually point to this dummy list
-                            std::mem::swap(lambda, &mut dummy);
-
-                            // Construct the global definition, this is something like
-                            //
-                            // (define ##__lifted_pure_function42 (lambda (x) 10))
-                            //
-                            // This is going to go into our vec of lifted functions
-                            let constructed_definition = ExprKind::Define(Box::new(Define::new(
-                                atom(constructed_name.clone()),
-                                dummy,
-                                SyntaxObject::default(TokenType::Define),
-                            )));
-
-                            self.lifted_functions.push(constructed_definition);
-
-                            // Now update the reference to just point straight to a variable reference
-                            // This _should_ be globally unique
-                            *lambda = atom(constructed_name);
-                        }
-                    }
-                }
-            }
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => {
-                if l.is_anonymous_function_call() {
-                    if let Some((f, rest)) = l.args.split_first_mut() {
-                        if let ExprKind::LambdaFunction(f) = f {
-                            self.visit(&mut f.body);
-                        }
-
-                        for expr in rest {
-                            self.visit(expr);
-                        }
-                    }
-                } else {
-                    for expr in &mut l.args {
-                        self.visit(expr);
-                    }
-                }
-
-                // self.visit_list(l)
-            }
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-}
-
-struct ElideSingleArgumentLambdaApplications<'a> {
-    analysis: &'a Analysis,
-    re_run_analysis: bool,
-}
-
-impl<'a> VisitorMutRefUnit for ElideSingleArgumentLambdaApplications<'a> {
-    fn visit(&mut self, expr: &mut ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            application @ ExprKind::List(_) => {
-                if let ExprKind::List(l) = application {
-                    for expr in &mut l.args {
-                        self.visit(expr);
-                    }
-
-                    if !l.is_anonymous_function_call() {
-                        return;
-                    }
-
-                    if l.args.len() != 2 {
-                        return;
-                    }
-
-                    if l.args[1].atom_identifier().is_none() {
-                        return;
-                    }
-
-                    let mut replacement: Option<ExprKind> = None;
-
-                    if let ExprKind::LambdaFunction(lf) = &l.args[0] {
-                        if lf.args.len() != 1 {
-                            return;
-                        }
-
-                        if let Some(info) = self.analysis.get_function_info(&lf) {
-                            for arg in info.arguments().values() {
-                                if arg.mutated {
-                                    return;
-                                }
-                            }
-
-                            if !info.captured_vars.is_empty() {
-                                return;
-                            }
-
-                            if let ExprKind::List(lst) = &lf.body {
-                                if lst.len() == 2
-                                    && lst.args[0].atom_identifier().is_some()
-                                    && lst.args[1].atom_identifier() == lf.args[0].atom_identifier()
-                                {
-                                    self.re_run_analysis = true;
-
-                                    replacement = Some(lst.args[0].clone());
-                                }
-                            }
-                        }
-                    } else {
-                        unreachable!();
-                    }
-
-                    if let Some(replacement) = replacement {
-                        l.args[0] = replacement;
-                    }
-                }
-            }
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-}
-
-fn box_argument(ident: ExprKind) -> ExprKind {
-    ExprKind::List(List::new(vec![ExprKind::atom("#%box"), ident]))
-}
-
-fn unbox_argument(ident: ExprKind) -> ExprKind {
-    ExprKind::List(List::new(vec![ExprKind::atom("#%unbox"), ident]))
-}
-
-fn setbox_argument(ident: ExprKind, expr: ExprKind) -> ExprKind {
-    ExprKind::List(List::new(vec![ExprKind::atom("#%set-box!"), ident, expr]))
-}
-
-struct ReplaceSetOperationsWithBoxes<'a> {
-    analysis: &'a Analysis,
-}
-
-impl<'a> VisitorMutRefUnit for ReplaceSetOperationsWithBoxes<'a> {
-    fn visit(&mut self, expr: &mut ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(_) => {}
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => {
-                if let Some(analysis) = self.analysis.get(&a.syn) {
-                    if analysis.kind == IdentifierStatus::HeapAllocated {
-                        let mut dummy = ExprKind::List(List::new(Vec::new()));
-                        std::mem::swap(&mut dummy, expr);
-
-                        *expr = unbox_argument(dummy);
-                    }
-                }
-            }
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => {
-                if let Some(analysis) = self.analysis.get(s.variable.atom_syntax_object().unwrap())
-                {
-                    if analysis.kind != IdentifierStatus::HeapAllocated {
-                        self.visit(&mut s.expr);
-
-                        return;
-                    }
-                }
-
-                // Go ahead and drop down the expression
-                self.visit(&mut s.expr);
-
-                let mut set_expr = ExprKind::List(List::new(Vec::new()));
-                std::mem::swap(&mut s.expr, &mut set_expr);
-
-                let mut dummy_ident = ExprKind::List(List::new(Vec::new()));
-                std::mem::swap(&mut dummy_ident, &mut s.variable);
-
-                let new_set_expr = setbox_argument(dummy_ident, set_expr);
-
-                *expr = new_set_expr;
-            }
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-
-    fn visit_define(&mut self, define: &mut Define) {
-        self.visit(&mut define.body);
-    }
-
-    fn visit_lambda_function(&mut self, lambda_function: &mut LambdaFunction) {
-        // Visit the body first, unwind the recursion on the way up
-        self.visit(&mut lambda_function.body);
-
-        let function_info = self
-            .analysis
-            .function_info
-            .get(&lambda_function.syntax_object_id);
-
-        if let Some(function_info) = function_info {
-            let mut mutable_variables = Vec::new();
-
-            // Which arguments do we need to wrap up
-            for var in &lambda_function.args {
-                if let Some(ident) = var.atom_identifier() {
-                    if let Some(arg) = function_info.arguments().get(ident) {
-                        if arg.captured && arg.mutated {
-                            mutable_variables.push(var.clone());
-                        }
-                    }
-                } else {
-                    unreachable!()
-                }
-            }
-
-            if !mutable_variables.is_empty() {
-                let mut body = ExprKind::List(List::new(Vec::new()));
-
-                std::mem::swap(&mut lambda_function.body, &mut body);
-
-                let wrapped_lambda = LambdaFunction::new(
-                    mutable_variables.clone(),
-                    body,
-                    lambda_function.location.clone(),
-                );
-
-                // Box the values!
-                let mut mutable_variables: Vec<_> =
-                    mutable_variables.into_iter().map(box_argument).collect();
-
-                mutable_variables.insert(0, ExprKind::LambdaFunction(Box::new(wrapped_lambda)));
-                lambda_function.body = ExprKind::List(List::new(mutable_variables));
-            }
-        }
-    }
-}
-
-struct LiftLocallyDefinedFunctions<'a> {
-    analysis: &'a Analysis,
-    lifted_functions: Vec<ExprKind>,
-}
-
-impl<'a> LiftLocallyDefinedFunctions<'a> {
-    pub fn new(analysis: &'a Analysis) -> Self {
-        Self {
-            analysis,
-            lifted_functions: Vec::new(),
-        }
-    }
-}
-
-impl<'a> VisitorMutRefUnit for LiftLocallyDefinedFunctions<'a> {
-    fn visit_begin(&mut self, begin: &mut crate::parser::ast::Begin) {
-        // Traverse down the tree first - start bubbling up the lifted functions
-        // on the way back up
-        for expr in &mut begin.exprs {
-            self.visit(expr);
-        }
-
-        let mut functions: Vec<(usize, String, SyntaxObjectId)> = Vec::new();
-
-        for (index, expr) in begin.exprs.iter().enumerate() {
-            if let ExprKind::Define(define) = expr {
-                let ident = define.name.atom_syntax_object().unwrap();
-                if let Some(info) = define
-                    .body
-                    .lambda_function()
-                    .and_then(|func| self.analysis.get_function_info(func))
-                {
-                    let ident_info = self.analysis.get(ident).unwrap();
-
-                    if ident_info.depth > 1 {
-                        if !info.captured_vars.is_empty() {
-                            if log::log_enabled!(log::Level::Trace) {
-                                log::trace!(
-                                target: "lambda-lifting",
-                                    "Found a local function which captures variables: {} - captures vars: {:#?}",
-                                    define.name,
-                                    info.captured_vars
-                                );
-                            }
-
-                            // for (var, _) in info.captured_vars() {
-                            // log::debug!(target: "lambda-lifting", "{}", var.resolve());
-                            // }
-
-                            if info.captured_vars().len() == 1 {
-                                // TODO: Check if the number of captured vars is 1, and if that 1 is equivalent to the
-                                // define name. If it is, then we should just mark this as a pure local function, because
-                                // then we can lift it and be happy about it!
-
-                                for (_, info) in info.captured_vars() {
-                                    if info.id == define.name_id().unwrap() {
-                                        log::trace!(target: "lambda-lifting", "Local define where it only captures itself!");
-
-                                        functions.push((
-                                            index,
-                                            define.name.atom_identifier().unwrap().to_string(),
-                                            define.name_id().unwrap(),
-                                        ));
-                                    }
-                                }
-                            }
-
-                            // println!("{}", define.body);
-                        } else {
-                            log::trace!(target: "lambda-lifting", "Found a pure local function: {}", define.name);
-                            functions.push((
-                                index,
-                                define.name.atom_identifier().unwrap().to_string(),
-                                define.name_id().unwrap(),
-                            ));
-                        }
-                    }
-                }
-            }
-        }
-
-        for (index, _name, _id) in functions.into_iter().rev() {
-            // let constructed_name =
-            //     "##lambda-lifting##".to_string() + &name + id.0.to_string().as_str();
-
-            // let mut dummy_define = ExprKind::Define(Box::new(Define::new(
-            //     ExprKind::atom(name),
-            //     ExprKind::atom(constructed_name),
-            //     SyntaxObject::default(TokenType::Define),
-            // )));
-
-            // let mut removed_function = begin.exprs.get_mut(index).unwrap();
-
-            // std::mem::swap(&mut dummy_define, &mut removed_function);
-
-            let removed_function = begin.exprs.remove(index);
-            self.lifted_functions.push(removed_function);
-        }
-    }
-}
-
-struct CollectReferences {
-    idents: fxhash::FxHashSet<InternedString>,
-}
-
-impl<'a> VisitorMutUnitRef<'a> for CollectReferences {
-    fn visit_atom(&mut self, a: &'a Atom) {
-        if let TokenType::Identifier(ident) = a.syn.ty {
-            if ident.resolve().starts_with("mangler") {
-                self.idents.insert(ident);
-            }
-        }
-    }
-}
-
-struct ReplaceBuiltinUsagesInsideMacros<'a> {
-    identifiers_to_replace: &'a mut HashSet<InternedString>,
-    analysis: &'a Analysis,
-}
-
-impl<'a> VisitorMutRefUnit for ReplaceBuiltinUsagesInsideMacros<'a> {
-    fn visit_define(&mut self, define: &mut Define) {
-        self.visit(&mut define.body);
-    }
-
-    fn visit_atom(&mut self, a: &mut Atom) {
-        if let Some(info) = self.analysis.get(&a.syn) {
-            if info.kind != IdentifierStatus::Global && info.kind != IdentifierStatus::Free {
-                return;
-            }
-        }
-
-        if let Some(ident) = a.ident_mut() {
-            if self.identifiers_to_replace.contains(ident) {
-                if let Some((_, builtin_name)) = ident.resolve().split_once(MANGLER_SEPARATOR) {
-                    // println!("RENAMING: {}", ident);
-
-                    *ident = ("#%prim.".to_string() + builtin_name).into();
-                }
-            }
-        }
-    }
-}
-
-struct ReplaceBuiltinUsagesWithReservedPrimitiveReferences<'a> {
-    analysis: &'a Analysis,
-    identifiers_to_replace: &'a mut HashSet<InternedString>,
-}
-
-impl<'a> ReplaceBuiltinUsagesWithReservedPrimitiveReferences<'a> {
-    pub fn new(
-        analysis: &'a Analysis,
-        identifiers_to_replace: &'a mut HashSet<InternedString>,
-    ) -> Self {
-        Self {
-            analysis,
-            identifiers_to_replace,
-        }
-    }
-}
-
-impl<'a> VisitorMutRefUnit for ReplaceBuiltinUsagesWithReservedPrimitiveReferences<'a> {
-    #[inline]
-    fn visit_define(&mut self, define: &mut Define) {
-        // Don't visit the name!
-        self.visit(&mut define.body);
-    }
-
-    fn visit_atom(&mut self, a: &mut Atom) {
-        if let Some(info) = self.analysis.get(&a.syn) {
-            // println!("Visiting: {}", a);
-            // println!("{:#?}", info);
-
-            // Don't even touch non globals
-            if info.kind != IdentifierStatus::Global && info.kind != IdentifierStatus::Free {
-                // println!("Skipping: {}", a);
-
-                return;
-            }
-
-            // println!("Visiting: {}", a);
-            // println!("{:#?}", info);
-
-            // if a.ident()
-            //     .map(|x| x.resolve().ends_with("get-test-mode"))
-            //     .unwrap_or_default()
-            // {
-            //     println!("Visiting: {}", a);
-            //     println!("{:#?}", info);
-            // }
-
-            if info.builtin && !info.is_shadowed && info.shadows.is_none() {
-                // todo!()
-
-                // println!("FOUND UNSHADOWED USAGE OF BUILTIN: {}", a);
-
-                if let Some(ident) = a.ident_mut() {
-                    if let Some((_, builtin_name)) = ident.resolve().split_once(MANGLER_SEPARATOR) {
-                        // let original = *ident;
-
-                        self.identifiers_to_replace.insert(*ident);
-
-                        *ident = ("#%prim.".to_string() + builtin_name).into();
-
-                        // println!("top level - MUTATED IDENT TO BE: {} -> {}", original, ident);
-                    }
-                }
-            } else {
-                // Check if this _refers_ to a builtin
-                // println!("Visiting: {}", a);
-                // println!("{:#?}", info);
-
-                if let Some(refers_to) = info.refers_to {
-                    if let Some(info) = self.analysis.info.get(&refers_to) {
-                        if info.builtin && !info.is_shadowed && info.shadows.is_none() {
-                            // todo!()
-
-                            // println!("FOUND UNSHADOWED USAGE OF BUILTIN: {}", a);
-
-                            if let Some(ident) = a.ident_mut() {
-                                if let Some((_, builtin_name)) =
-                                    ident.resolve().split_once(MANGLER_SEPARATOR)
-                                {
-                                    // let original = *ident;
-
-                                    self.identifiers_to_replace.insert(*ident);
-
-                                    *ident = ("#%prim.".to_string() + builtin_name).into();
-
-                                    // println!("MUTATED IDENT TO BE: {} -> {}", original, ident);
-
-                                    // println!("{:#?}", info);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-struct ExprContainsIds<'a> {
-    analysis: &'a Analysis,
-    ids: &'a HashSet<SyntaxObjectId>,
-}
-
-impl<'a> ExprContainsIds<'a> {
-    pub fn contains(
-        analysis: &'a Analysis,
-        ids: &'a HashSet<SyntaxObjectId>,
-        expr: &ExprKind,
-    ) -> bool {
-        matches!(
-            ExprContainsIds { analysis, ids }.visit(expr),
-            std::ops::ControlFlow::Break(_)
-        )
-    }
-}
-
-impl<'a> VisitorMutControlFlow for ExprContainsIds<'a> {
-    fn visit_atom(&mut self, a: &Atom) -> std::ops::ControlFlow<()> {
-        if let Some(refers_to) = self.analysis.get(&a.syn).and_then(|x| x.refers_to) {
-            if self.ids.contains(&refers_to) {
-                return std::ops::ControlFlow::Break(());
-            }
-        }
-
-        std::ops::ControlFlow::Continue(())
-    }
-}
-
-struct FlattenAnonymousFunctionCalls<'a> {
-    analysis: &'a Analysis,
-}
-
-impl<'a> FlattenAnonymousFunctionCalls<'a> {
-    pub fn flatten(analysis: &'a Analysis, exprs: &mut Vec<ExprKind>) {
-        for expr in exprs {
-            Self { analysis }.visit(expr);
-        }
-    }
-}
-
-impl<'a> VisitorMutRefUnit for FlattenAnonymousFunctionCalls<'a> {
-    fn visit_list(&mut self, l: &mut List) {
-        // let mut replacement_body: Option<ExprKind> = None;
-        let mut args = Vec::new();
-
-        let mut inner_body = None;
-        let mut changed = false;
-
-        // This is an anonymous function call
-        if let Some(function_a) = l.first_func_mut() {
-            // The body is also just an anonymous function call
-            if let ExprKind::List(inner_l) = &mut function_a.body {
-                let arg_ids = function_a
-                    .args
-                    .iter()
-                    .map(|x| x.atom_syntax_object().unwrap().syntax_object_id)
-                    .collect::<HashSet<_>>();
-
-                let all_dont_contain_references = inner_l.args[1..]
-                    .iter()
-                    .all(|x| !ExprContainsIds::contains(self.analysis, &arg_ids, x));
-
-                if all_dont_contain_references {
-                    if let Some(function_b) = inner_l.first_func_mut() {
-                        // Then we should be able to flatten the function into one
-
-                        // TODO: Check that any of the vars we're using are used in the body expression
-                        // They can only be used in the argument position
-
-                        let mut dummy = ExprKind::empty();
-
-                        // Extract the inner body
-                        std::mem::swap(&mut function_b.body, &mut dummy);
-
-                        inner_body = Some(dummy);
-
-                        // TODO: This doesn't work quite yet -
-                        function_a.args.append(&mut function_b.args);
-                        args.extend(inner_l.args.drain(1..));
-
-                        changed = true;
-                    }
-                }
-            }
-
-            if let Some(new_body) = inner_body {
-                function_a.body = new_body;
-            }
-        }
-
-        l.args.append(&mut args);
-
-        if changed {
-            self.visit_list(l);
-        } else {
-            // Visit the children after
-            for expr in &mut l.args {
-                self.visit(expr)
-            }
-        }
-    }
-}
-
-struct FunctionCallCollector<'a> {
-    analysis: &'a Analysis,
-    functions: FxHashMap<InternedString, FxHashSet<InternedString>>,
-    black_box: InternedString,
-    context: Option<InternedString>,
-    constants: ImmutableHashMap<InternedString, SteelVal>,
-    should_mangle: bool,
-}
-
-impl<'a> FunctionCallCollector<'a> {
-    pub fn mangle(
-        analysis: &'a Analysis,
-        exprs: &mut Vec<ExprKind>,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        should_mangle: bool,
-    ) -> FxHashMap<InternedString, FxHashSet<InternedString>> {
-        let black_box: InternedString = "#%black-box".into();
-
-        let mut collector = Self {
-            analysis,
-            functions: FxHashMap::default(),
-            context: None,
-            black_box,
-            constants,
-            should_mangle,
-        };
-
-        // TODO: @Matt - This needs to get the
-        for expr in exprs.iter() {
-            match expr {
-                ExprKind::Define(define) => {
-                    if let ExprKind::LambdaFunction(_) = &define.body {
-                        let name = define.name.atom_identifier().unwrap().clone();
-
-                        collector.functions.entry(name).or_default();
-                    }
-                }
-                ExprKind::Begin(b) => {
-                    for expr in &b.exprs {
-                        if let ExprKind::Define(define) = expr {
-                            if let ExprKind::LambdaFunction(_) = &define.body {
-                                let name = define.name.atom_identifier().unwrap().clone();
-
-                                collector.functions.entry(name).or_default();
-                            }
-                        }
-                    }
-                }
-                _ => {}
-            }
-
-            // if let ExprKind::Define(define) = expr {
-            //     if let ExprKind::LambdaFunction(_) = &define.body {
-            //         let name = define.name.atom_identifier().unwrap().clone();
-
-            //         collector.functions.entry(name).or_default();
-            //     }
-            // }
-        }
-
-        for expr in exprs {
-            collector.visit(expr);
-        }
-
-        collector.functions
-    }
-}
-
-impl<'a> VisitorMutRefUnit for FunctionCallCollector<'a> {
-    fn visit_define(&mut self, define: &mut Define) {
-        if let ExprKind::LambdaFunction(f) = &mut define.body {
-            let name = define.name.atom_identifier().unwrap().clone();
-
-            self.functions.entry(name).or_default();
-
-            self.context = Some(name);
-
-            self.visit_lambda_function(f);
-
-            // let should_remove = if let Some(callers) = self
-            //     .context
-            //     .as_ref()
-            //     .and_then(|ctx| self.functions.get(ctx))
-            // {
-            //     callers.is_empty()
-            // } else {
-            //     true
-            // };
-
-            // if should_remove {
-            //     self.functions.remove(&self.context.unwrap());
-            // }
-
-            self.context = None;
-        } else {
-            self.visit(&mut define.body);
-        }
-    }
-
-    fn visit_list(&mut self, l: &mut List) {
-        let mut mangle = false;
-
-        if let Some(function) = l.first() {
-            if let ExprKind::Atom(a) = function {
-                if let Some(info) = self.analysis.get(&a.syn) {
-                    // At this point... we don't care if its a free identifier
-                    if info.kind == IdentifierStatus::Global || info.kind == IdentifierStatus::Free
-                    {
-                        if let Some(function) = a.ident() {
-                            // If this isn't a function that has been locally defined,
-                            // then we want to mangle the definition of it
-                            if !self.functions.contains_key(function)
-                                && !self.constants.contains_key(function)
-                            {
-                                // Remove this function from the possible list
-                                self.context
-                                    .as_ref()
-                                    .and_then(|ctx| self.functions.remove(ctx));
-
-                                mangle = true;
-                            } else {
-                                // Mark that this
-                                self.context
-                                    .as_ref()
-                                    .and_then(|ctx| self.functions.get_mut(ctx))
-                                    .map(|calls| calls.insert(function.clone()));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Adjust the function call to be a reference to the black box function
-        if self.should_mangle && mangle {
-            *l.first_ident_mut().unwrap() = self.black_box.clone()
-        }
-
-        for expr in &mut l.args {
-            self.visit(expr);
-        }
-    }
-
-    // Any set expr needs to get purged
-    fn visit_set(&mut self, s: &mut crate::parser::ast::Set) {
-        if let Some(function) = s.variable.atom_identifier() {
-            if self.functions.contains_key(function) {
-                self.functions.remove(function);
-            }
-        }
-    }
-}
-
-// TODO: There might be opportunity to parallelize this here - perhaps shard the analysis between threads
-// across some subset of expressions and then merge afterwards
-pub struct SemanticAnalysis<'a> {
-    // We want to reserve the right to add or remove expressions from the program as needed
-    pub exprs: &'a mut Vec<ExprKind>,
-    pub analysis: Analysis,
-}
-
-pub enum RequiredIdentifierInformation<'a> {
-    Resolved(&'a SemanticInformation),
-    // Raw Identifier, Full path
-    Unresolved(InternedString, String),
-}
-
-impl<'a> SemanticAnalysis<'a> {
-    pub fn into_analysis(self) -> Analysis {
-        self.analysis
-    }
-
-    pub fn from_analysis(exprs: &'a mut Vec<ExprKind>, analysis: Analysis) -> Self {
-        Self { exprs, analysis }
-    }
-
-    pub fn new(exprs: &'a mut Vec<ExprKind>) -> Self {
-        let analysis = Analysis::from_exprs(exprs);
-        Self { exprs, analysis }
-    }
-
-    pub fn populate_captures(&mut self) {
-        self.analysis.populate_captures(self.exprs);
-    }
-
-    pub fn get(&self, object: &SyntaxObject) -> Option<&SemanticInformation> {
-        self.analysis.get(object)
-    }
-
-    pub fn get_identifier(&self, identifier: SyntaxObjectId) -> Option<&SemanticInformation> {
-        self.analysis.info.get(&identifier)
-    }
-
-    // Syntax object must be the id associated with a given require define statement
-    pub fn resolve_required_identifier(
-        &self,
-        identifier: SyntaxObjectId,
-    ) -> Option<RequiredIdentifierInformation<'_>> {
-        for expr in self.exprs.iter() {
-            match expr {
-                ExprKind::Define(d) => {
-                    if is_a_require_definition(&d) && d.name_id() == Some(identifier) {
-                        let module = d
-                            .body
-                            .list()
-                            .and_then(|x| x.get(1))
-                            .and_then(|x| x.atom_identifier())
-                            .map(|x| x.resolve())?;
-
-                        let prefix = module.trim_start_matches("__module-").to_string()
-                            + d.name.atom_identifier()?.resolve();
-
-                        let top_level_define = self.query_top_level_define(&prefix);
-
-                        match top_level_define {
-                            Some(top_level_define) => {
-                                return self
-                                    .get_identifier(top_level_define.name_id()?)
-                                    .map(RequiredIdentifierInformation::Resolved);
-                            }
-                            None => {
-                                return Some(RequiredIdentifierInformation::Unresolved(
-                                    *d.name.atom_identifier()?,
-                                    prefix,
-                                ))
-                            }
-                        }
-                    }
-                }
-                ExprKind::Begin(b) => {
-                    for expr in &b.exprs {
-                        if let ExprKind::Define(d) = expr {
-                            if is_a_require_definition(&d) && d.name_id() == Some(identifier) {
-                                let module = d
-                                    .body
-                                    .list()
-                                    .and_then(|x| x.get(1))
-                                    .and_then(|x| x.atom_identifier())
-                                    .map(|x| x.resolve())?;
-
-                                let prefix = module.trim_start_matches("__module-").to_string()
-                                    + d.name.atom_identifier()?.resolve();
-
-                                let top_level_define = self.query_top_level_define(&prefix);
-
-                                match top_level_define {
-                                    Some(top_level_define) => {
-                                        return self
-                                            .get_identifier(top_level_define.name_id()?)
-                                            .map(RequiredIdentifierInformation::Resolved);
-                                    }
-                                    None => {
-                                        return Some(RequiredIdentifierInformation::Unresolved(
-                                            *d.name.atom_identifier()?,
-                                            prefix,
-                                        ))
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        None
-    }
-
-    // Syntax object must be the id associated with a given require define statement
-    pub fn resolve_required_identifiers(
-        &self,
-        identifiers: HashSet<SyntaxObjectId>,
-    ) -> Vec<(SyntaxObjectId, RequiredIdentifierInformation<'_>)> {
-        let mut results = Vec::new();
-
-        let mut resolve_identifier = |d: &Define| -> Option<()> {
-            if is_a_require_definition(&d) && identifiers.contains(&d.name_id().unwrap()) {
-                let module = d
-                    .body
-                    .list()
-                    .and_then(|x| x.get(1))
-                    .and_then(|x| x.atom_identifier())
-                    .map(|x| x.resolve())?;
-
-                let prefix = module.trim_start_matches("__module-").to_string()
-                    + d.name.atom_identifier()?.resolve();
-
-                let top_level_define = self.query_top_level_define(&prefix);
-
-                match top_level_define {
-                    Some(top_level_define) => {
-                        results.push((
-                            d.name_id()?,
-                            self.get_identifier(top_level_define.name_id()?)
-                                .map(RequiredIdentifierInformation::Resolved)?,
-                        ));
-                    }
-                    None => {
-                        results.push((
-                            d.name_id()?,
-                            RequiredIdentifierInformation::Unresolved(
-                                *d.name.atom_identifier()?,
-                                prefix,
-                            ),
-                        ));
-                    }
-                }
-            }
-
-            None
-        };
-
-        for expr in self.exprs.iter() {
-            match expr {
-                ExprKind::Define(d) => {
-                    resolve_identifier(&d);
-                }
-                ExprKind::Begin(b) => {
-                    for expr in &b.exprs {
-                        if let ExprKind::Define(d) = expr {
-                            resolve_identifier(&d);
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        results
-    }
-
-    pub fn query_top_level_define<A: AsRef<str>>(
-        &self,
-        name: A,
-    ) -> Option<&crate::parser::ast::Define> {
-        query_top_level_define(self.exprs, name)
-    }
-
-    // Takes the function call, and inlines it at the call sites. In theory, with constant evaluation and
-    // dead code elimination, this should help streamline some of the more complex cases. This is also just a start.
-    pub fn inline_function_call<A: AsRef<str>>(&mut self, name: A) -> Result<(), SteelErr> {
-        // TODO: Cloning here is expensive. We should strive to make these trees somehow share the nodes a bit more elegantly.
-        // As it stands, each time we close a syntax tree, we're going to do a deep clone of the whole thing, which we really don't
-        // want to do.
-        let top_level_define_body = self.query_top_level_define(name.as_ref()).ok_or_else(
-            throw!(TypeMismatch => format!("Cannot inline free identifier!: {}", name.as_ref())),
-        )?.body.lambda_function().ok_or_else(throw!(TypeMismatch => format!("Cannot inline non function for: {}", name.as_ref())))?.clone();
-
-        self.find_call_sites_and_modify_with(
-            name.as_ref(),
-            |_: &Analysis, lst: &mut crate::parser::ast::List| {
-                lst.args[0] = ExprKind::LambdaFunction(Box::new(top_level_define_body.clone()));
-            },
-        );
-
-        Ok(())
-    }
-
-    pub fn get_global_id<A: AsRef<str>>(&self, name: A) -> Option<SyntaxObjectId> {
-        self.query_top_level_define(name)?
-            .name
-            .atom_syntax_object()
-            .map(|x| x.syntax_object_id)
-    }
-
-    pub fn find_let_call_sites_and_mutate_with<F>(&mut self, func: F)
-    where
-        F: FnMut(&Analysis, &mut ExprKind) -> bool,
-    {
-        let mut let_call_sites = LetCallSites::new(&self.analysis, func);
-        for expr in self.exprs.iter_mut() {
-            let_call_sites.visit(expr);
-        }
-    }
-
-    /// In this case, `let` also translates directly to an anonymous function call
-    pub fn find_anonymous_function_calls_and_mutate_with<F>(&mut self, func: F)
-    where
-        F: FnMut(&Analysis, &mut ExprKind) -> bool,
-    {
-        let mut anonymous_function_call_sites =
-            AnonymousFunctionCallSites::new(&self.analysis, func);
-        for expr in self.exprs.iter_mut() {
-            anonymous_function_call_sites.visit(expr);
-        }
-    }
-
-    pub fn replace_mutable_captured_variables_with_boxes(&mut self) -> &mut Self {
-        let mut replacer = ReplaceSetOperationsWithBoxes {
-            analysis: &self.analysis,
-        };
-
-        for expr in self.exprs.iter_mut() {
-            replacer.visit(expr);
-        }
-
-        self
-    }
-
-    /// Find all local pure functions, except those defined already at the top level and those defined with 'define',
-    /// and replace them with a globally defined function. This means we're not going to be recreating
-    /// the function _on every instance_ and instead can just grab them each time.
-    /// TODO: @Matt - figure out a way to simplify the construction of closures as well - perhaps introduce
-    /// some sort of combinator for closures as well.
-    pub fn lift_all_local_functions(&mut self) -> &mut Self {
-        let mut lifter = LiftPureFunctionsToGlobalScope::new(&self.analysis);
-
-        for expr in self.exprs.iter_mut() {
-            lifter.visit(expr);
-        }
-
-        if !lifter.lifted_functions.is_empty() {
-            // This is a silly little way to put the lifted functions actually at the top of
-            // the expression list
-            lifter.lifted_functions.append(self.exprs);
-
-            *self.exprs = lifter.lifted_functions;
-
-            // log::debug!("Re-running the analysis after lifting local functions");
-            self.analysis.fresh_from_exprs(&self.exprs);
-            self.analysis.populate_captures(self.exprs);
-        }
-
-        self
-    }
-
-    pub(crate) fn replace_non_shadowed_globals_with_builtins(
-        &mut self,
-        macros: &mut HashMap<InternedString, SteelMacro>,
-        module_manager: &mut ModuleManager,
-        table: &mut HashSet<InternedString>,
-    ) -> &mut Self {
-        let mut replacer =
-            ReplaceBuiltinUsagesWithReservedPrimitiveReferences::new(&self.analysis, table);
-
-        for expr in self.exprs.iter_mut() {
-            replacer.visit(expr);
-        }
-
-        let mut macro_replacer = ReplaceBuiltinUsagesInsideMacros {
-            identifiers_to_replace: replacer.identifiers_to_replace,
-            analysis: &self.analysis,
-        };
-
-        for steel_macro in macros.values_mut() {
-            if !steel_macro.is_mangled() {
-                for expr in steel_macro.exprs_mut() {
-                    macro_replacer.visit(expr);
-                }
-
-                steel_macro.mark_mangled();
-            }
-        }
-
-        for module in module_manager.modules_mut() {
-            for steel_macro in module.1.macro_map.values_mut() {
-                if !steel_macro.is_mangled() {
-                    for expr in steel_macro.exprs_mut() {
-                        macro_replacer.visit(expr);
-                    }
-                }
-
-                steel_macro.mark_mangled();
-            }
-        }
-
-        for expr in self.exprs.iter_mut() {
-            macro_replacer.visit(expr);
-        }
-
-        self.analysis.fresh_from_exprs(self.exprs);
-
-        self
-    }
-
-    pub(crate) fn remove_unused_globals_with_prefix(
-        &mut self,
-        prefix: &str,
-        macros: &HashMap<InternedString, SteelMacro>,
-        module_manager: &ModuleManager,
-    ) -> &mut Self {
-        let module_get_interned: InternedString = "%module-get%".into();
-        let proto_hash_get: InternedString = "%proto-hash-get%".into();
-
-        let steel_constant_module: InternedString = "%-builtin-module-steel/constants".into();
-        let void: InternedString = "void".into();
-
-        let mut collected = CollectReferences {
-            idents: fxhash::FxHashSet::default(),
-        };
-
-        for steel_macro in macros.values() {
-            // if !steel_macro.is_mangled() {
-            for expr in steel_macro.exprs() {
-                collected.visit(expr);
-            }
-            // }
-        }
-
-        for module in module_manager.modules() {
-            for steel_macro in module.1.macro_map.values() {
-                // if !steel_macro.is_mangled() {
-                for expr in steel_macro.exprs() {
-                    collected.visit(expr);
-                }
-                // }
-            }
-        }
-
-        let found = collected.idents;
-
-        // for ident in &found {
-        //     println!("{}", ident);
-        // }
-
-        self.exprs.retain_mut(|expression| {
-            match expression {
-                ExprKind::Define(define) => {
-                    if let Some(name) = define.name.atom_identifier() {
-                        if name.resolve().starts_with(prefix) {
-                            if let Some(analysis) = define
-                                .name
-                                .atom_syntax_object()
-                                .and_then(|x| self.analysis.get(x))
-                            {
-                                if analysis.usage_count == 0 {
-                                    if let Some(func) =
-                                        define.body.list().and_then(|x| x.first_ident())
-                                    {
-                                        if *func == module_get_interned || *func == proto_hash_get {
-                                            // If this is found inside of a macro, do not remove it
-                                            if found.contains(&name) {
-                                                // println!("Keeping: {}", name);
-                                                return true;
-                                            }
-
-                                            // println!("REMOVING: {}", name);
-
-                                            return false;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                ExprKind::Begin(b) => {
-                    let mut offset = 0;
-                    let total_length = b.exprs.len();
-
-                    b.exprs.retain_mut(|expression| {
-                        if let ExprKind::Define(define) = expression {
-                            if let Some(name) = define.name.atom_identifier() {
-                                if name.resolve().starts_with(prefix) {
-                                    if let Some(analysis) = define
-                                        .name
-                                        .atom_syntax_object()
-                                        .and_then(|x| self.analysis.get(x))
-                                    {
-                                        if analysis.usage_count == 0 {
-                                            if let Some(func) =
-                                                define.body.list().and_then(|x| x.first_ident())
-                                            {
-                                                // (%module-get%
-                                                //         %-builtin-module-steel/constants
-                                                //         (quote
-                                                //           void))
-
-                                                if *func == module_get_interned
-                                                    || *func == proto_hash_get
-                                                {
-                                                    // If this is found inside of a macro, do not remove it
-                                                    if found.contains(&name) {
-                                                        // println!("Keeping: {}", name);
-                                                        offset += 1;
-                                                        return true;
-                                                    }
-
-                                                    // println!("REMOVING: {}", name);
-
-                                                    offset += 1;
-                                                    return false;
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        } else {
-                            if let ExprKind::List(l) = expression {
-                                if let Some(func) = l.first_ident() {
-                                    if *func == module_get_interned {
-                                        if l[1].atom_identifier() == Some(&steel_constant_module) {
-                                            if let ExprKind::Quote(q) = &l[2] {
-                                                if q.expr.atom_identifier() == Some(&void)
-                                                    && offset < total_length
-                                                {
-                                                    offset += 1;
-                                                    return false;
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        offset += 1;
-                        return true;
-                    });
-                }
-                _ => {}
-            }
-
-            return true;
-        });
-
-        // self.exprs.push(ExprKind::ident("void"));
-
-        // log::debug!("Re-running the semantic analysis after removing unused globals");
-
-        self.analysis.fresh_from_exprs(self.exprs);
-
-        self
-    }
-
-    /// Find lets without arguments and replace these with just the body of the function.
-    /// For instance:
-    /// ```scheme
-    /// (let () (+ 1 2 3 4 5)) ;; => (+ 1 2 3 4 5)
-    /// ```
-    ///
-    /// The other function - `replace_pure_empty_lets_with_body` explicitly refers to anonymous functions
-    /// that lets are naively translated to, so something like this:
-    ///
-    /// ```scheme
-    /// ((lambda () (+ 1 2 3 4 5)))
-    /// ```
-    ///
-    pub fn replace_no_argument_lets_with_body(&mut self) -> &mut Self {
-        let mut re_run_analysis = false;
-
-        let func = |_: &Analysis, anon: &mut ExprKind| {
-            if let ExprKind::Let(l) = anon {
-                if l.bindings.is_empty() {
-                    let mut dummy = ExprKind::List(List::new(Vec::new()));
-                    std::mem::swap(&mut l.body_expr, &mut dummy);
-                    *anon = dummy;
-
-                    re_run_analysis = true;
-
-                    return true;
-                }
-            } else {
-                unreachable!()
-            }
-
-            false
-        };
-
-        self.find_let_call_sites_and_mutate_with(func);
-
-        if re_run_analysis {
-            // log::debug!("Re-running the semantic analysis after modifying let call sites");
-
-            self.analysis.fresh_from_exprs(self.exprs);
-        }
-
-        self
-    }
-
-    pub fn run_black_box(
-        &mut self,
-        constants: ImmutableHashMap<InternedString, SteelVal>,
-        should_mangle: bool,
-    ) -> FxHashMap<InternedString, FxHashSet<InternedString>> {
-        let map = FunctionCallCollector::mangle(
-            &self.analysis,
-            &mut self.exprs,
-            constants,
-            should_mangle,
-        );
-
-        // These are all of the global functions referenced
-        let global_keys_that_reference_non_constant_function = map
-            .iter()
-            .filter(|(_, v)| v.is_empty())
-            .map(|x| x.0.clone())
-            .collect::<FxHashSet<_>>();
-
-        // Only constant evaluatable functions should be ones that references _other_ const functions
-        map.into_iter()
-            // This can be better - but this more or less excludes anything recursive from being evaluated
-            // by the constant evaluator.
-            .filter(|(k, v)| !v.contains(k))
-            .filter(|(_, v)| {
-                !v.is_empty() && v.is_disjoint(&global_keys_that_reference_non_constant_function)
-            })
-            .collect()
-
-        // map.drain().filter(|x| )
-
-        // map
-    }
-
-    /// Find anonymous function calls with no arguments that don't capture anything,
-    /// and replace this with just the body of the function. For instance:
-    ///
-    /// ```scheme
-    /// (let () (+ 1 2 3 4 5)) ;; => (+ 1 2 3 4 5)
-    ///
-    /// ```
-    pub fn replace_pure_empty_lets_with_body(&mut self) -> &mut Self {
-        let mut re_run_analysis = false;
-
-        let func = |analysis: &Analysis, anon: &mut ExprKind| {
-            if let ExprKind::List(l) = anon {
-                let arg_count = l.args.len() - 1;
-                let function = l.args.get_mut(0).unwrap();
-
-                if let ExprKind::LambdaFunction(f) = function {
-                    let analysis = analysis.get_function_info(f).unwrap();
-
-                    if analysis.captured_vars.is_empty() {
-                        // log::debug!("Found a function that does not capture variables");
-
-                        if f.args.is_empty() && arg_count == 0 {
-                            // Take out the body of the function - we're going to want to use that now
-                            let mut dummy = ExprKind::List(List::new(Vec::new()));
-                            std::mem::swap(&mut f.body, &mut dummy);
-                            *anon = dummy;
-
-                            re_run_analysis = true;
-
-                            // We changed the function call - we should adjust accordingly
-                            return true;
-                        }
-                    }
-                } else {
-                    unreachable!()
-                }
-            } else {
-                unreachable!()
-            }
-
-            false
-        };
-
-        self.find_anonymous_function_calls_and_mutate_with(func);
-
-        if re_run_analysis {
-            // log::debug!("Re-running the semantic analysis after modifications");
-
-            // self.analysis = Analysis::from_exprs(self.exprs);
-            self.analysis.fresh_from_exprs(self.exprs);
-        }
-
-        self
-    }
-
-    pub fn replace_anonymous_function_calls_with_plain_lets(&mut self) -> &mut Self {
-        let mut re_run_analysis = false;
-
-        let func = |_: &Analysis, anon: &mut ExprKind| {
-            if let ExprKind::List(l) = anon {
-                // Don't replace anonymous function calls that have rest args - those are not yet handled
-                // with a blind let replacement
-                if let ExprKind::LambdaFunction(f) = l.args.get(0).unwrap() {
-                    if f.rest {
-                        return false;
-                    }
-                }
-
-                let function = l.args.remove(0);
-
-                if let ExprKind::LambdaFunction(mut f) = function {
-                    let mut function_body = ExprKind::List(List::new(Vec::new()));
-                    std::mem::swap(&mut f.body, &mut function_body);
-
-                    let let_expr = Let::new(
-                        f.args
-                            .iter()
-                            .zip(l.args.iter())
-                            .map(|x| (x.0.clone(), x.1.clone()))
-                            .collect(),
-                        function_body,
-                        f.location.clone(),
-                    );
-
-                    *anon = ExprKind::Let(let_expr.into());
-
-                    re_run_analysis = true;
-                    // log::debug!("Replaced anonymous function call with let");
-
-                    true
-                } else {
-                    unreachable!()
-                }
-            } else {
-                unreachable!()
-            }
-
-            // false
-        };
-
-        self.find_anonymous_function_calls_and_mutate_with(func);
-
-        if re_run_analysis {
-            // log::debug!("Re-running the semantic analysis after modifications");
-
-            self.analysis.fresh_from_exprs(self.exprs);
-        }
-
-        self
-    }
-
-    pub fn refresh_variables(&mut self) -> &mut Self {
-        for expr in self.exprs.iter_mut() {
-            RefreshVars.visit(expr);
-        }
-
-        self.analysis.fresh_from_exprs(self.exprs);
-
-        self
-    }
-
-    // Modify the call site to point to another kind of expression
-    pub fn find_call_sites_and_mutate_with<F>(&mut self, name: &str, func: F)
-    where
-        F: FnMut(&Analysis, &mut ExprKind),
-    {
-        let mut find_call_sites = MutateCallSites::new(name, &self.analysis, func);
-
-        for expr in self.exprs.iter_mut() {
-            find_call_sites.visit(expr);
-        }
-    }
-
-    // Locate the call sites of the given global function name, and calls the given function
-    // on the node
-    pub fn find_call_sites_and_call<F>(&self, name: &str, func: F)
-    where
-        F: FnMut(&Analysis, &crate::parser::ast::List),
-    {
-        let mut find_call_sites = FindCallSites::new(name, &self.analysis, func);
-
-        for expr in self.exprs.iter() {
-            find_call_sites.visit(expr);
-        }
-    }
-
-    // Locate the call sites of the given global function, and calls the given function
-    // on the node
-    pub fn find_call_sites_and_modify_with<F>(&mut self, name: &str, func: F)
-    where
-        F: FnMut(&Analysis, &mut crate::parser::ast::List),
-    {
-        let mut find_call_sites = FindCallSites::new(name, &self.analysis, func);
-
-        for expr in self.exprs.iter_mut() {
-            find_call_sites.visit(expr);
-        }
-    }
-
-    pub fn last_usages(&self) -> impl Iterator<Item = &'_ SemanticInformation> {
-        self.analysis.info.values().filter(|x| x.last_usage)
-    }
-
-    pub fn free_identifiers(&self) -> impl Iterator<Item = &'_ SemanticInformation> {
-        self.analysis
-            .info
-            .values()
-            .filter(|x| x.kind == IdentifierStatus::Free)
-    }
-
-    pub fn free_identifiers_with_globals<'b: 'a>(
-        &self,
-        globals: &'b SymbolMap,
-    ) -> Vec<(InternedString, &'_ SemanticInformation)> {
-        let mut visitor = FreeIdentifierVisitor {
-            analysis: &self.analysis,
-            globals,
-            diagnostics: Vec::new(),
-        };
-
-        for expr in self.exprs.iter() {
-            visitor.visit(expr);
-        }
-
-        visitor.diagnostics
-    }
-
-    pub fn unused_variables(&self) -> impl Iterator<Item = &'_ SemanticInformation> {
-        self.analysis.info.values().filter(|x| {
-            x.usage_count == 0
-                && matches!(x.kind, IdentifierStatus::Local | IdentifierStatus::Global)
-        })
-    }
-
-    pub fn unused_local_variables(&self) -> impl Iterator<Item = &'_ SemanticInformation> {
-        self.analysis
-            .info
-            .values()
-            .filter(|x| x.usage_count == 0 && matches!(x.kind, IdentifierStatus::Local))
-    }
-
-    pub fn global_defs(&self) -> impl Iterator<Item = &'_ SemanticInformation> {
-        self.analysis
-            .info
-            .values()
-            .filter(|x| x.kind == IdentifierStatus::Global)
-    }
-
-    pub fn find_global_defs(&self) -> Vec<(InternedString, Span)> {
-        let mut global_finder = GlobalDefinitionFinder {
-            analysis: &self.analysis,
-            globals: Vec::new(),
-        };
-
-        for expr in self.exprs.iter() {
-            global_finder.visit(expr);
-        }
-
-        global_finder.globals
-    }
-
-    pub fn built_ins(&self) -> impl Iterator<Item = &'_ SemanticInformation> {
-        self.analysis.info.values().filter(|x| x.builtin)
-    }
-
-    pub fn find_free_identifiers(&self) -> impl Iterator<Item = &'_ SemanticInformation> {
-        self.analysis
-            .info
-            .values()
-            .filter(|x| x.kind == IdentifierStatus::Free)
-    }
-
-    pub fn find_unused_arguments(&self) -> Vec<(InternedString, Span)> {
-        let mut unused = UnusedArguments::new(&self.analysis);
-
-        for expr in self.exprs.iter() {
-            unused.visit(expr);
-        }
-
-        unused.unused_args
-    }
-
-    pub fn find_identifier_at_offset(
-        &self,
-        offset: usize,
-        source_id: SourceId,
-    ) -> Option<(&SyntaxObjectId, &SemanticInformation)> {
-        self.analysis.info.iter().find(|(_, x)| {
-            x.span.range().contains(&offset) && x.span.source_id() == Some(source_id)
-        })
-    }
-
-    // Find semantic context where this offset exist.
-    pub fn find_contexts_with_offset(
-        &self,
-        offset: usize,
-        source_id: SourceId,
-    ) -> Vec<SemanticInformationType> {
-        let mut context_finder = FindContextsWithOffset {
-            analysis: &self.analysis,
-            offset,
-            contexts: Vec::new(),
-            source_id,
-        };
-
-        for expr in self.exprs.iter() {
-            context_finder.visit(expr);
-        }
-
-        context_finder.contexts
-    }
-
-    // Convert the syntax object ids back to interned strings. Could end up
-    // returning nothing if the ids are not found in the target AST, which could
-    // happen if the analysis gets invalidated by refreshing the vars.
-    pub fn syntax_object_ids_to_identifiers<'b>(
-        &self,
-        ids: &'a mut HashMap<SyntaxObjectId, Option<InternedString>>,
-    ) -> &mut HashMap<SyntaxObjectId, Option<InternedString>> {
-        let mut identifier_finder = IdentifierFinder { ids };
-
-        for expr in self.exprs.iter() {
-            identifier_finder.visit(expr);
-        }
-
-        identifier_finder.ids
-    }
-
-    /// Converts function applications of the form:
-    ///
-    /// ((lambda (x) (global-function-call x)) foo)
-    ///
-    /// Into:
-    ///
-    /// (global-function-call foo)
-    ///
-    /// Note: It is important to run this before lambda lifting, since currently
-    /// all `lets` are implemented naively as lambdas.
-    pub fn elide_single_argument_lambda_applications(&mut self) -> &mut Self {
-        let mut elider = ElideSingleArgumentLambdaApplications {
-            analysis: &self.analysis,
-            re_run_analysis: false,
-        };
-
-        for expr in self.exprs.iter_mut() {
-            elider.visit(expr);
-        }
-
-        if elider.re_run_analysis {
-            // log::debug!(
-            //     "Re-running the semantic analysis after modifications during lambda lifting"
-            // );
-
-            self.analysis.fresh_from_exprs(self.exprs);
-            self.analysis.populate_captures(self.exprs);
-        }
-
-        self
-    }
-
-    pub fn check_if_values_are_redefined(&mut self) -> Result<&mut Self, SteelErr> {
-        let mut non_builtin_definitions = HashSet::new();
-
-        for expr in self.exprs.iter() {
-            match expr {
-                ExprKind::Define(d) => {
-                    if is_a_builtin_definition(d) || is_a_require_definition(d) {
-                        continue;
-                    }
-
-                    let name = d.name.atom_identifier().unwrap();
-
-                    if non_builtin_definitions.contains(name) {
-                        stop!(BadSyntax => format!("Variable re defined within the top level definition: {}", name); d.location.span);
-                    }
-
-                    non_builtin_definitions.insert(d.name.atom_identifier().unwrap());
-                }
-                ExprKind::Begin(b) => {
-                    for e in &b.exprs {
-                        if let ExprKind::Define(d) = e {
-                            if is_a_builtin_definition(d) || is_a_require_definition(d) {
-                                continue;
-                            }
-
-                            let name = d.name.atom_identifier().unwrap();
-
-                            if non_builtin_definitions.contains(name) {
-                                stop!(BadSyntax => format!("Variable re defined within the top level definition: {}", name); d.location.span);
-                            }
-
-                            non_builtin_definitions.insert(d.name.atom_identifier().unwrap());
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-
-        Ok(self)
-    }
-
-    // TODO: Right now this lifts and renames, but it does not handle
-    // The extra arguments necessary for this to work
-    pub fn lift_pure_local_functions(&mut self) -> &mut Self {
-        let mut overall_lifted = Vec::new();
-        let mut re_run_analysis = false;
-
-        let exprs_len = self.exprs.len();
-
-        // Window in to the individual values - we're going to want to get access to each of the other ones individually
-        for i in 0..exprs_len {
-            let mut local_funcs = LiftLocallyDefinedFunctions::new(&self.analysis);
-
-            // Just borrow for exactly how long we need it for
-            local_funcs.visit(self.exprs.get_mut(i).unwrap());
-
-            if !local_funcs.lifted_functions.is_empty() {
-                re_run_analysis = true;
-            }
-
-            // Move out the local functions
-            let mut local_functions = local_funcs.lifted_functions;
-
-            let ids = local_functions
-                .iter()
-                .map(|x| {
-                    if let ExprKind::Define(d) = x {
-                        // log::debug!("Found a local function to lift: {}", d.name);
-                        d.name.atom_syntax_object().unwrap().syntax_object_id
-                    } else {
-                        unreachable!()
-                    }
-                })
-                .collect::<Vec<_>>();
-
-            for id in ids {
-                let mut find_call_site_by_id =
-                    FindUsages::new(id, &self.analysis, |_: &Analysis, usage: &mut Atom| {
-                        if let Some(ident) = usage.ident_mut() {
-                            *ident = ("##lambda-lifting##".to_string()
-                                + ident.resolve()
-                                + id.0.to_string().as_str())
-                            .into();
-                            true
-                        } else {
-                            false
-                        }
-                    });
-
-                // Mutate the call sites of the original expression we were visiting
-                // Similar to here - just borrow exactly how long we need it for
-                find_call_site_by_id.visit(self.exprs.get_mut(i).unwrap());
-                // Now also mutate the bodies of any of the functions as well
-                for local_function in &mut local_functions {
-                    find_call_site_by_id.visit(local_function);
-                    // println!("Function: {}", local_function);
-
-                    // Also update the name
-                    if let ExprKind::Define(define) = local_function {
-                        if let Some(syntax_object) = define.name.atom_syntax_object() {
-                            if syntax_object.syntax_object_id != id {
-                                continue;
-                            }
-                        }
-
-                        if let Some(name) = define.name.atom_identifier_mut() {
-                            *name = ("##lambda-lifting##".to_string()
-                                + name.resolve()
-                                + id.0.to_string().as_str())
-                            .into();
-                        } else {
-                            unreachable!("This should explicitly be an identifier here - perhaps a macro was invalid?");
-                        }
-                    } else {
-                        unreachable!("These should only be defines by design");
-                    }
-                }
-
-                // Visit the other ones
-                for j in 0..exprs_len {
-                    if i != j {
-                        // println!("Revisiting: {}", self.exprs.get_mut(j).unwrap());
-                        find_call_site_by_id.visit(self.exprs.get_mut(j).unwrap());
-                    }
-                }
-
-                // Also visit those that have been lifted out
-                // for expr in &mut overall_lifted {
-                //     println!("Visiting: {}", expr);
-                //     find_call_site_by_id.visit(expr);
-                // }
-
-                // Check if we need to re run this analysis - if we've made any modifications up to this point, we
-                // Need to re run the analysis afterwards
-                re_run_analysis |= find_call_site_by_id.modified;
-            }
-
-            // Put the lifted expressions back at the end - they _probably_ should go to the front, but for now
-            // Lets just put them at the back
-            overall_lifted.append(&mut local_functions);
-        }
-
-        // Same as the above - just getting around a double mutable borrow.
-        // Move the lifted functions to the back of the original expression list
-        // self.exprs.append(&mut overall_lifted);
-
-        overall_lifted.append(self.exprs);
-        *self.exprs = overall_lifted;
-
-        if re_run_analysis {
-            // log::debug!(
-            //     "Re-running the semantic analysis after modifications during lambda lifting"
-            // );
-
-            self.analysis.fresh_from_exprs(self.exprs);
-            // = Analysis::from_exprs(self.exprs);
-            // self.analysis.populate_captures(self.exprs);
-        }
-
-        self
-    }
-
-    pub fn resolve_alias(&self, id: SyntaxObjectId) -> Option<SyntaxObjectId> {
-        self.analysis.resolve_alias(id)
-    }
-
-    pub fn flatten_anonymous_functions(&mut self) {
-        FlattenAnonymousFunctionCalls::flatten(&self.analysis, self.exprs);
-    }
-
-    pub fn remove_unused_imports(&mut self) {
-        let mut unused = RemovedUnusedImports::new(&self.analysis);
-        for expr in self.exprs.iter_mut() {
-            unused.visit(expr);
-        }
-    }
-
-    pub fn remove_unused_define_imports(&mut self) {
-        let mut unused = RemoveUnusedDefineImports::new(&self.analysis);
-        for expr in self.exprs.iter_mut() {
-            unused.visit(expr);
-        }
-    }
-}
-
-#[cfg(test)]
-mod analysis_pass_tests {
-
-    use crate::{
-        parser::{ast::AstTools, parser::Parser},
-        rerrs::ErrorKind,
-    };
-
-    use super::*;
-
-    #[test]
-    fn test_unused_arguments() {
-        let script = r#"
-            
-(define ##lambda-lifting##loop119067
-  (λ (port sum)
-    (%plain-let
-     ((next-line (read-line-from-port port)))
-     (if (equal? (quote eof) next-line)
-         sum
-         (##lambda-lifting##loop119067
-          port
-          (+ sum
-             (%plain-let ((digits (filter char-digit? next-line)))
-                         (%plain-let ((first-digit (first digits)) (second-digit (last digits)))
-                                     (string->number (list->string (list first-digit
-                                                                         second-digit)))))))))))
-
-(define ##lambda-lifting##trie-contains-inner?119977
-  (λ (node char-list)
-    (if (empty? char-list)
-        #true
-        (if (char=? (trie-char node) (car char-list))
-            (%plain-let ((children-matched
-                          (map (λ (node4)
-                                 (##lambda-lifting##trie-contains-inner?119977 node4 (cdr char-list)))
-                               (trie-children node))))
-                        (if (empty? children-matched) #true (list? (member #true children-matched))))
-            #false))))
-
-(define ##lambda-lifting##loop120600
-  (λ (port sum)
-    (%plain-let ((next-line (read-line-from-port port)))
-                (if (equal? (quote eof) next-line)
-                    sum
-                    (##lambda-lifting##loop120600 port (+ sum (process-line next-line)))))))
-
-(define scan
-  (λ (path) (%plain-let ((file (open-input-file path))) (##lambda-lifting##loop119067 file 0))))
-
-(displayln (scan "aoc/day1.data"))
-
-(define word-map
-  (transduce (list (cons "one" "1")
-                   (cons "two" "2")
-                   (cons "three" "3")
-                   (cons "four" "4")
-                   (cons "five" "5")
-                   (cons "six" "6")
-                   (cons "seven" "7")
-                   (cons "eight" "8")
-                   (cons "nine" "9")
-                   (cons "1" "1")
-                   (cons "2" "2")
-                   (cons "3" "3")
-                   (cons "4" "4")
-                   (cons "5" "5")
-                   (cons "6" "6")
-                   (cons "7" "7")
-                   (cons "8" "8")
-                   (cons "9" "9"))
-             (mapping (λ (pair) (cons (string->list (car pair)) (cadr pair))))
-             (into-hashmap)))
-
-(define sample
-  (map
-   symbol->string
-   (quote
-    (two1nine eightwothree abcone2threexyz xtwone3four 4nineeightseven2 zoneight234 7pqrstsixteen))))
-
-(displayln sample)
-
-(begin
-  (define ___trie-options___
-    (hash (quote #:transparent)
-          #true
-          (quote #:name)
-          (quote trie)
-          (quote #:fields)
-          (quote (char children end-word? word-up-to))
-          (quote #:printer)
-          (λ (obj printer-function)
-            (begin
-              (display "(")
-              (display (symbol->string (quote trie)))
-              (display " ")
-              (printer-function (trie-char obj))
-              (display " ")
-              (printer-function (trie-children obj))
-              (display " ")
-              (printer-function (trie-end-word? obj))
-              (display " ")
-              (printer-function (trie-word-up-to obj))
-              (display ")")))
-          (quote #:mutable)
-          #false))
-  (define trie (quote unintialized))
-  (define struct:trie (quote uninitialized))
-  (define trie? (quote uninitialized))
-  (define trie-char (quote uninitialized))
-  (define trie-children (quote uninitialized))
-  (define trie-end-word? (quote uninitialized))
-  (define trie-word-up-to (quote uninitialized))
-  (%plain-let ((prototypes (make-struct-type (quote trie) 4)))
-              (%plain-let ((struct-type-descriptor (list-ref prototypes 0))
-                           (constructor-proto (list-ref prototypes 1))
-                           (predicate-proto (list-ref prototypes 2))
-                           (getter-proto (list-ref prototypes 3)))
-                          (begin
-                            (set! struct:trie struct-type-descriptor)
-                            (#%vtable-update-entry! struct-type-descriptor #false ___trie-options___)
-                            (set! trie constructor-proto)
-                            (set! trie? predicate-proto)
-                            (set! trie-char (λ (this) (getter-proto this 0)))
-                            (set! trie-children (λ (this) (getter-proto this 1)))
-                            (set! trie-end-word? (λ (this) (getter-proto this 2)))
-                            (set! trie-word-up-to (λ (this) (getter-proto this 3)))
-                            void))))
-
-(define empty (quote ()))
-
-(define empty-trie (trie void empty #false empty))
-
-(define flatten
-  (λ (lst)
-    (if (null? lst)
-        empty
-        (if (list? lst) (append (flatten (car lst)) (flatten (cdr lst))) (list lst)))))
-
-(define create-children
-  (λ (char-list lst prefix-chars)
-    (if (= (length char-list) 1)
-        (handle-last-letter char-list lst prefix-chars)
-        (handle-intern-letter char-list lst prefix-chars))))
-
-(define handle-last-letter
-  (λ (char-list lst prefix-chars)
-    (%plain-let
-     ((char (first char-list)))
-     (%plain-let
-      ((next-prefix (push-back prefix-chars char)))
-      (if (empty? lst)
-          (list (trie char empty #true next-prefix))
-          (if (< char (trie-char (first lst)))
-              (cons (trie char empty #true next-prefix) lst)
-              (if (equal? char (trie-char (first lst)))
-                  (cons (trie char (trie-children (first lst)) #true next-prefix) (rest lst))
-                  (cons (first lst) (create-children char-list (rest lst) prefix-chars)))))))))
-
-(define handle-intern-letter
-  (λ (char-list lst prefix-chars)
-    (%plain-let
-     ((char (first char-list)))
-     (%plain-let
-      ((next-prefix (push-back prefix-chars char)))
-      (if (empty? lst)
-          (list (trie char (create-children (rest char-list) empty next-prefix) #false next-prefix))
-          (if (< char (trie-char (first lst)))
-              (cons
-               (trie char (create-children (rest char-list) empty next-prefix) #false next-prefix)
-               lst)
-              (if (equal? char (trie-char (first lst)))
-                  (cons
-                   (trie char
-                         (create-children (rest char-list) (trie-children (first lst)) next-prefix)
-                         (trie-end-word? (first lst))
-                         (trie-word-up-to (first lst)))
-                   (rest lst))
-                  (cons (first lst) (create-children char-list (rest lst) prefix-chars)))))))))
-
-(define insert
-  (λ (root-trie word)
-    (%plain-let ((char-list (string->list word)))
-                (trie (trie-char root-trie)
-                      (create-children char-list (trie-children root-trie) empty)
-                      (trie-end-word? root-trie)
-                      (trie-word-up-to root-trie)))))
-
-(define trie<? (λ (trie-node1 trie-node2) (< (trie-char trie-node1) (trie-char trie-node2))))
-
-(define build-trie-from-list-of-words
-  (λ (trie list-of-words)
-    (if (= (length list-of-words) 1)
-        (insert trie (first list-of-words))
-        (build-trie-from-list-of-words (insert trie (first list-of-words)) (rest list-of-words)))))
-
-(define trie-sort
-  (λ (list-of-words)
-    (%plain-let ((new-trie (build-trie-from-list-of-words empty-trie list-of-words)))
-                (pre-order new-trie))))
-
-(define pre-order
-  (λ (trie-node)
-    (if (trie-end-word? trie-node)
-        (cons (list->string (trie-word-up-to trie-node))
-              (flatten (map pre-order (trie-children trie-node))))
-        (flatten (map pre-order (trie-children trie-node))))))
-
-(define trie-contains-prefix?
-  (λ (root word)
-    (%plain-let
-     ((root-word-char-list (if (string? word) (string->list word) word)))
-     (list? (member #true
-                    (map (λ (node)
-                           (##lambda-lifting##trie-contains-inner?119977 node root-word-char-list))
-                         (trie-children root)))))))
-
-(define my-trie
-  (build-trie-from-list-of-words empty-trie
-                                 (quote ("one" "two"
-                                               "three"
-                                               "four"
-                                               "five"
-                                               "six"
-                                               "seven"
-                                               "eight"
-                                               "nine"
-                                               "1"
-                                               "2"
-                                               "3"
-                                               "4"
-                                               "5"
-                                               "6"
-                                               "7"
-                                               "8"
-                                               "9"))))
-
-(define check-slices
-  (λ (trie-root word-map line)
-    (%plain-let
-     ((line-length (length line)) (loop 123))
-     (%plain-let
-      ((loop4 (#%box loop)))
-      (%plain-let ((_____loop0 (λ (offset amount accum)
-                                 (if (> (+ offset amount) line-length)
-                                     (reverse accum)
-                                     (if (trie-contains-prefix? trie-root (slice line offset amount))
-                                         (if (hash-contains? word-map (slice line offset amount))
-                                             ((#%unbox loop4)
-                                              (+ offset 1)
-                                              1
-                                              (cons (hash-get word-map (slice line offset amount))
-                                                    accum))
-                                             ((#%unbox loop4) offset (+ 1 amount) accum))
-                                         ((#%unbox loop4) (+ 1 offset) 1 accum))))))
-                  (begin
-                    (#%set-box! loop4 _____loop0)
-                    ((#%unbox loop4) 0 1 (quote ()))))))))
-
-(define process-line
-  (λ (line)
-    (%plain-let ((result (check-slices my-trie word-map (string->list line))))
-                (string->number (apply string-append (list (first result) (last result)))))))
-
-(define scan2
-  (λ (path) (%plain-let ((file (open-input-file path))) (##lambda-lifting##loop120600 file 0))))
-
-(displayln (scan2 "aoc/day1.data"))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let analysis = SemanticAnalysis::new(&mut exprs);
-        // analysis.replace_pure_empty_lets_with_body();
-
-        // Log the free identifiers
-        let free_vars = analysis.find_unused_arguments();
-
-        for var in free_vars {
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "unused arguments".to_string(),
-                var.1,
-            );
-        }
-    }
-
-    #[test]
-    fn test_free_identifiers() {
-        let script = r#"
-
-(begin
- (define ___mcons-options___
-        (hash
-           (quote
-             #:fields)
-           (quote
-             (mcar mcdr))
-           (quote
-             #:transparent)
-           #false
-           (quote
-             #:name)
-           (quote
-             mcons)
-           (quote
-             #:printer)
-           (λ (obj printer)
-             (if (mlist? obj)
-               (begin
-                (simple-display "'")
-                     (printer (mcons->list obj)))
-               (begin
-                (simple-display "'(")
-                     (printer (mcons-mcar obj))
-                     (simple-display " . ")
-                     (printer (mcons-mcdr obj))
-                     (simple-display ")"))))
-           (quote
-             #:mutable)
-           #true))
-      (define mcons
-        (quote
-          unintialized))
-      (define struct:mcons
-        (quote
-          uninitialized))
-      (define mcons?
-        (quote
-          uninitialized))
-      (define mcons-mcar
-        (quote
-          uninitialized))
-      (define mcons-mcdr
-        (quote
-          uninitialized))
-      (define set-mcons-mcar!
-        (quote
-          unintialized))
-      (define set-mcons-mcdr!
-        (quote
-          unintialized))
-      (%plain-let ((prototypes (make-struct-type
-             (quote
-               mcons)
-             2)))
-        (%plain-let ((struct-type-descriptor (list-ref
-               prototypes
-               0))
-            (constructor-proto (list-ref prototypes 1))
-            (predicate-proto (list-ref prototypes 2))
-            (getter-proto (list-ref prototypes 3)))
-          (begin
-           (set! struct:mcons struct-type-descriptor)
-                (#%vtable-update-entry!
-                   struct-type-descriptor
-                   #false
-                   ___mcons-options___)
-                (set! mcons
-                  (λ (mcar mcdr)
-                    (constructor-proto
-                       (#%box mcar)
-                       (#%box mcdr))))
-                (set! mcons? predicate-proto)
-                (set! mcons-mcar
-                  (λ (this)
-                    (#%unbox (getter-proto this 0))))
-                (set! mcons-mcdr
-                  (λ (this)
-                    (#%unbox (getter-proto this 1))))
-                (set! set-mcons-mcar!
-                  (λ (this value)
-                    (#%set-box!
-                       (getter-proto this 0)
-                       value)))
-                (set! set-mcons-mcdr!
-                  (λ (this value)
-                    (#%set-box!
-                       (getter-proto this 1)
-                       value)))
-                void))))
-
-(define ##lambda-lifting##loop118915
-  (λ (mutable-cons3 builder)
-    (if (not
-         (mcons?
-            (%plain-let ((result (mcons-mcdr
-                   mutable-cons3)))
-              (begin
-               (simple-display
-                       (quote
-                         (mcons-mcdr mutable-cons)))
-                    (simple-display " = ")
-                    (simple-displayln result)
-                    result))))
-      (#%prim.cons (mcons-mcar mutable-cons3) builder)
-      (##lambda-lifting##loop118915
-         (mcons-mcdr mutable-cons3)
-         (#%prim.cons
-            (mcons-mcar mutable-cons3)
-            builder)))))
-
-(define set-car!
-  set-mcons-mcar!)
-
-(define set-cdr!
-  set-mcons-mcdr!)
-
-(define mcons->list
-  (λ (mutable-cons)
-    (reverse
-       (##lambda-lifting##loop118915
-          mutable-cons
-          (quote
-            ())))))
-
-(define mlist?
-  (λ (cell)
-    (%plain-let ((next (mcons-mcdr cell)))
-      (%plain-let ((z (mcons? next)))
-        (if z z (null? next))))))
-
-(define pair?
-  (λ (x)
-    (%plain-let ((z (mcons? x)))
-      (if z z (#%prim.pair? x)))))
-
-(define cons
-  (λ (a b !!dummy-rest-arg!!)
-    (%plain-let ((!!dummy-rest-arg!!3 (apply
-           %keyword-hash
-           !!dummy-rest-arg!!)))
-      (%plain-let ((mutable (%plain-let ((mutable (hash-try-get
-                 !!dummy-rest-arg!!3
-                 (quote
-                   #:mutable))))
-            (if (hash-contains?
-                 !!dummy-rest-arg!!3
-                 (quote
-                   #:mutable))
-              mutable
-              #false))))
-        (if mutable
-          (mcons a b)
-          (if (list? b)
-            (#%prim.cons a b)
-            (if (mcons? b)
-              (mcons a b)
-              (#%prim.cons a b))))))))
-
-(define car
-  (λ (a)
-    (if (mcons? a) (mcons-mcar a) (#%prim.car a))))
-
-(define cdr
-  (λ (a)
-    (if (mcons? a) (mcons-mcdr a) (#%prim.cdr a))))
-            
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.replace_pure_empty_lets_with_body();
-
-        // Log the free identifiers
-        let free_vars = analysis.find_free_identifiers();
-
-        for var in free_vars {
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "Free identifier".to_string(),
-                var.span,
-            );
-        }
-    }
-
-    #[test]
-    fn local_defines() {
-        let script = r#"
-        (define (applesauce x y z) (list x y z))
-
-        (define (bananas blegh) (applesauce blegh 10 20))
-
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.populate_captures();
-
-        // Inline top level definition -> naively just replace the value with the updated value
-        // This should allow constant propagation to take place. TODO: Log optimization misses
-        analysis.inline_function_call("applesauce").unwrap();
-
-        analysis.exprs.pretty_print();
-
-        // analysis.
-
-        // for var in analysis.last_usages() {
-        //     crate::rerrs::report_info(
-        //         ErrorKind::FreeIdentifier.to_error_code(),
-        //         "input.rkt",
-        //         script,
-        //         format!("last usage"),
-        //         var.span,
-        //     );
-        // }
-    }
-
-    #[test]
-    fn transducer_last_usages() {
-        let script = r#"
-        
-        (define tmap
-            (λ (f)
-              (λ (reducer)
-                (λ args
-                  (let ((l (length args)))
-                    (if (= l (length (quote ())))
-                      (apply (λ () (reducer)) args)
-                      (if (= l (length (quote (result))))
-                        (apply (λ (result) (reducer result)) args)
-                        (if (= l (length (quote (result input))))
-                          (apply
-                             (λ (result input)
-                               (reducer result (f input)))
-                             args)
-                          (error! "Arity mismatch")))))))))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.populate_captures();
-
-        for var in analysis.last_usages() {
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "last usage".to_string(),
-                var.span,
-            );
-        }
-    }
-
-    #[test]
-    fn escaping_functions() {
-        let script = r#"
-        (define generate-one-element-at-a-time
-            (λ (lst)
-              ((λ (control-state)
-                   ((λ (control-state0)
-                        (begin
-                         (set! control-state control-state0)
-                          (λ ()
-                            (call/cc control-state))))
-                      (λ (return)
-                        (begin
-                         (for-each
-                             (λ (element)
-                               (set! return
-                                 (call/cc
-                                    (λ (resume-here)
-                                      (begin
-                                       (set! control-state resume-here)
-                                        (return element))))))
-                             lst)
-                          (return (quote you-fell-off-the-end))))))
-                 123)))
-
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.populate_captures();
-
-        let let_vars = analysis
-            .analysis
-            .info
-            .values()
-            .filter(|x| x.kind == IdentifierStatus::HeapAllocated);
-
-        for var in let_vars {
-            println!("{var:?}");
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "let-var".to_string(),
-                var.span,
-            );
-        }
-    }
-
-    #[test]
-    fn last_usages_test() {
-        let script = r#"
-        (define Y 
-            (lambda (f)
-                ((lambda (x) (x x))
-                (lambda (x) (f (lambda (y) ((x x) y)))))))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.populate_captures();
-
-        for var in analysis.last_usages() {
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "last usage".to_string(),
-                var.span,
-            );
-        }
-    }
-
-    #[test]
-    fn mutated_and_captured() {
-        let script = r#"
-            (define (foo x)
-                (lambda (y) 
-                    (displayln x)
-                    (set! x y)))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.populate_captures();
-    }
-
-    #[test]
-    fn local_vars() {
-        let script = r#"
-            (define (applesauce)
-                (+ 10 20 30 
-                    (%plain-let ((a 10) (b 20))
-                        (+ a b))))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-
-        let analysis = SemanticAnalysis::new(&mut exprs);
-
-        let let_vars = analysis
-            .analysis
-            .info
-            .values()
-            .filter(|x| x.kind == IdentifierStatus::Local);
-
-        for var in let_vars {
-            println!("{var:?}");
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "let-var".to_string(),
-                var.span,
-            );
-        }
-    }
-
-    #[test]
-    fn tail_call_eligible_test_with_let() {
-        let script = r#"
-            (define (loop value accum)
-                ;; This should not get registered as a tail call
-                (loop value (cons value accum))
-                (let ((applesauce 10))
-                    (if #true
-                        (if #true
-                            (loop value (cons value accum))
-                            (loop value (cons value accum)))
-                        (loop value accum))))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.populate_captures();
-
-        let tail_calls = analysis
-            .analysis
-            .call_info
-            .values()
-            .filter(|x| matches!(x.kind, CallKind::SelfTailCall(_)))
-            .collect::<Vec<_>>();
-
-        assert_eq!(tail_calls.len(), 3);
-
-        for var in tail_calls {
-            println!("{var:?}");
-
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "tail call".to_string(),
-                var.span,
-            );
-        }
-    }
-
-    #[test]
-    fn tail_call_eligible_test_apply() {
-        let script = r#"
-        (define list-transduce
-            (λ args
-              (displayln args)
-              (let ((l (length args)))
-                (if (= l (length (quote (xform f coll))))
-                  (apply
-                     (λ (xform f coll)
-                       (displayln f)
-                       (displayln (multi-arity? f))
-                       (displayln list-transduce)
-                       (list-transduce xform f (f) coll))
-                     args)
-                  (if (= l (length (quote (xform f init coll))))
-                    (apply
-                       (λ (xform f init coll)
-                         (let ((xf (xform f)))
-                           (let ((result (list-reduce xf init coll)))
-                             (xf result))))
-                       args)
-                    (error! "Arity mismatch"))))))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.populate_captures();
-
-        let tail_calls = analysis
-            .analysis
-            .call_info
-            .values()
-            .filter(|x| matches!(x.kind, CallKind::SelfTailCall(_)));
-
-        for var in tail_calls {
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "tail call".to_string(),
-                var.span,
-            );
-        }
-    }
-
-    #[test]
-    fn tail_call_eligible_test() {
-        let script = r#"
-            (begin
-                (define loop1
-                    (λ (x)
-                    (if (= x 100) x (loop1 (+ x 1))))))
-
-            (define (loop value accum)
-                ;; This should not get registered as a tail call
-                (loop value (cons value accum))
-                (if #true
-                    (if #true
-                        (loop value (cons value accum))
-                        (loop value (cons value accum)))
-                    (loop value accum)))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut analysis = SemanticAnalysis::new(&mut exprs);
-        analysis.populate_captures();
-
-        let tail_calls = analysis
-            .analysis
-            .call_info
-            .values()
-            .filter(|x| matches!(x.kind, CallKind::SelfTailCall(_)));
-
-        for var in tail_calls {
-            crate::rerrs::report_info(
-                ErrorKind::FreeIdentifier.to_error_code(),
-                "input.rkt",
-                script,
-                "tail call".to_string(),
-                var.span,
-            );
-        }
-    }
-
-    #[test]
-    fn find_last_usages() {
-        let script = r#"
-            (define (loop value accum)
-                (+ value accum)
-                (loop value (cons value accum)))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let analysis = SemanticAnalysis::new(&mut exprs);
-
-        let last_usages = analysis.last_usages().collect::<Vec<_>>();
-        // In this case, we should be identifying just the two usages for
-        // value and accum in the recursive call
-        assert_eq!(last_usages.len(), 2);
-    }
-
-    #[test]
-    fn analysis_pass_finds_call_sites() {
-        let script = r#"
-            (define (foo) (+ 1 2 3 4 5))
-            (define (test) (let ((a 10) (b 20)) (foo)))
-            (foo)
-            (foo)
-            (begin
-                (foo)
-                (foo)
-                (foo))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let analysis = SemanticAnalysis::new(&mut exprs);
-
-        let mut count = 0;
-
-        analysis.find_call_sites_and_call("foo", |_, _| count += 1);
-
-        assert_eq!(count, 6);
-    }
-
-    #[test]
-    fn resolve_alias() {
-        let script = r#"
-            (define list (%module-get%))
-            (define alias-list list)
-            (define alias-list2 alias-list)
-            (define alias-list3 alias-list2)
-            (define alias-list4 alias-list3)
-        "#;
-
-        // let mut analysis = Analysis::default();
-        let mut exprs = Parser::parse(script).unwrap();
-        {
-            let analysis = SemanticAnalysis::new(&mut exprs);
-
-            let list_id = analysis
-                .query_top_level_define("list")
-                .and_then(|x| x.name_id())
-                .unwrap();
-
-            let alias_list_4_id = analysis
-                .query_top_level_define("alias-list4")
-                .and_then(|x| x.name_id())
-                .unwrap();
-
-            let found = analysis.resolve_alias(alias_list_4_id);
-
-            assert_eq!(list_id, found.unwrap());
-        }
-    }
-
-    #[test]
-    fn test_capture() {
-        let script = r#"
-
-            (define (adder x y z)
-                (set! x 100)
-                (lambda ()
-                    (+ x y z)
-                    (lambda ()
-                        (+ x y z)
-                        (lambda ()
-                            (+ x y z)
-                            (lambda () (+ x y z))))))
-
-        "#;
-
-        // let mut analysis = Analysis::default();
-        let mut exprs = Parser::parse(script).unwrap();
-        {
-            let mut analysis = SemanticAnalysis::new(&mut exprs);
-            analysis.populate_captures();
-
-            // This _should_ print I think 4 lambdas that will have captured x -> each one should actually cascade the capture downward, copying in each value directly
-            // Since x is an immutable capture, we're okay with this
-            for function in analysis
-                .analysis
-                .function_info
-                .values()
-                .filter(|x| !x.captured_vars().is_empty())
-            {
-                println!("{:?}", function.captured_vars());
-            }
-
-            println!("{:?}", analysis.analysis.info.get(&SyntaxObjectId(2)));
-
-            // println!("{:#?}", escaping_functions);
-        }
-    }
-
-    #[test]
-    fn test_complicated_escape_analysis() {
-        let script = r#"
-
-            (define (func-lift x) x)
-
-            (define (adder x)
-
-                ;; x == 2
-
-                (define func (lambda () x))
-                ;; This is pretty eligible for some sort of
-                ;; lifting? closure conversion?
-                (define func 
-                    (let ((a 10) (b 20) (c 30))
-                        (lambda () (+ a b c))))
-
-                (func) -> (func-lift x) ;; replace known callsites with the lifted version
-                (func) -> (func-lift x)
-
-                (set! x 20)
-
-                (func) -> (func-lift x)
-                (func) -> (func-lift x)
-
-                func ;; replace last callsite with something like
-                     ;; (lambda () x) -> doesn't interfere with previous calls, and now captures the var
-                )
-        "#;
-
-        // let mut analysis = Analysis::default();
-        let mut exprs = Parser::parse(script).unwrap();
-        {
-            let analysis = SemanticAnalysis::new(&mut exprs);
-
-            let escaping_functions = analysis
-                .analysis
-                .function_info
-                .values()
-                .filter(|x| x.escapes)
-                .collect::<Vec<_>>();
-
-            println!("{escaping_functions:#?}");
-        }
-    }
-
-    #[test]
-    fn test_lifting_local_functions_to_global_scope() {
-        let script = r#"
-            (define (test)
-                (mapping (lambda (x) 10) (list 1 2 3 4 5)))        
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-
-        {
-            let mut analysis = SemanticAnalysis::new(&mut exprs);
-
-            analysis.lift_all_local_functions();
-        }
-
-        for expr in exprs {
-            println!("{}", expr.to_pretty(60))
-        }
-    }
-
-    #[test]
-    fn test_rudimentary_escape_analysis() {
-        let script = r#"
-            (define (adder x)
-                
-                (map (lambda (y) (+ x y)) (list 1 2 3 4 5))
-
-                (black-box (lambda (y) (+ x y))))
-        "#;
-
-        // let mut analysis = Analysis::default();
-        let mut exprs = Parser::parse(script).unwrap();
-        {
-            let analysis = SemanticAnalysis::new(&mut exprs);
-
-            let escaping_functions = analysis
-                .analysis
-                .function_info
-                .values()
-                .filter(|x| x.escapes)
-                .collect::<Vec<_>>();
-
-            println!("{escaping_functions:#?}");
-        }
-    }
-
-    #[test]
-    fn test_black_box_mangling() {
-        let script = r#"
-            (define (fib n) 
-                (if (<= n 2) 
-                    1
-                    (+ (fib (- n 1)) (fib (- n 2)))))
-
-            (define (obviously-not-function-that-works)
-                (if (list 100 20 30 40 50 60)
-                    (random-call-not-const)
-                    (other-random-call-not-const)))
-
-            (fib 100)
-            (obviously-not-function-that-works)
-
-        "#;
-
-        // let mut analysis = Analysis::default();
-        let mut exprs = Parser::parse(script).unwrap();
-        {
-            let mut analysis = SemanticAnalysis::new(&mut exprs);
-
-            let constants = im_rc::hashmap! {
-                "+".into() => SteelVal::Void,
-                "<=".into() => SteelVal::Void,
-                "-".into() => SteelVal::Void,
-            };
-
-            let result = analysis.run_black_box(constants, true);
-
-            println!("{:#?}", result);
-
-            // Only select expressions which are identified as constant
-
-            analysis
-                .exprs
-                .iter()
-                .filter(|expr| {
-                    if let ExprKind::Define(define) = expr {
-                        if let ExprKind::LambdaFunction(_) = &define.body {
-                            let name = define.name.atom_identifier().unwrap().clone();
-
-                            return result.contains_key(&name);
-
-                            // collector.functions.entry(name).or_default();
-                        }
-                    }
-
-                    false
-                })
-                .collect::<Vec<_>>()
-                .pretty_print();
-
-            // let constant_exprs = analysis.exprs.iter().filter(|x| )
-
-            // analysis.exprs.pretty_print();
-        }
-    }
-
-    #[test]
-    fn check_analysis_pass() {
-        // let mut builder = Builder::new();
-
-        let script = r#"
-
-        (define + (%module-get%))
-        (define list (%module-get%))
-
-        (define alias-list list)
-        (define alias-list2 alias-list)
-        (define alias-list3 alias-list2)
-        (define alias-list4 alias-list3)
-
-        (let ()
-            (let ()
-                (let ()
-                    (let () (+ 1 2 3 4 5)))))
-
-        (+ applesauce 20)
-
-        (define applesauce 100)
-
-        ;(let ((a 10) (b 20))
-        ;    (+ a b c))
-
-        ;(define (foo x y z)
-        ;    (define (inner-func-that-captures a b c)
-        ;        (inner-func-that-captures x y z))
-        ;    (inner-func-that-captures 1 2 3))
-
-        (define (test)
-            (define (foo)
-                    (bar))
-            (define (bar)
-                    (foo))
-            (foo))
-
-        (define (loop value accum)
-            (loop (cons value accum)))
-
-        ;(define (foo x y z)
-        ;    (let ((x x) (y y))
-        ;        (lambda (extra-arg x) 
-        ;            (set! x 100)
-        ;            (set! foo "hello world")
-        ;            (+ z z z))))
-
-        ;(define (test x y z)
-        ;    (let ((foo foo))
-        ;        (foo x y z)
-        ;        (foo 1 2 3)
-        ;        (foo 10 20 30)))
-        
-        ;(foo "applesauce" "bananas" "sauce")
-        "#;
-
-        // let mut analysis = Analysis::default();
-        let mut exprs = Parser::parse(script).unwrap();
-        {
-            let mut analysis = SemanticAnalysis::new(&mut exprs);
-            analysis.replace_pure_empty_lets_with_body();
-
-            // Log the free identifiers
-            let free_vars = analysis.find_free_identifiers();
-
-            for var in free_vars {
-                crate::rerrs::report_info(
-                    ErrorKind::FreeIdentifier.to_error_code(),
-                    "input.rkt",
-                    script,
-                    "Free identifier".to_string(),
-                    var.span,
-                );
-            }
-
-            let _unused_args = analysis.find_unused_arguments();
-
-            // println!("Unused args: {unused_args:?}");
-
-            // for var in analysis.unused_variables() {
-            //     crate::rerrs::report_warning(
-            //         ErrorKind::FreeIdentifier.to_error_code(),
-            //         "input.rkt",
-            //         script,
-            //         "Unused variable".to_string(),
-            //         var.span,
-            //     );
-            // }
-
-            // for var in analysis.global_defs() {
-            //     crate::rerrs::report_info(
-            //         ErrorKind::FreeIdentifier.to_error_code(),
-            //         "input.rkt",
-            //         script,
-            //         "global var".to_string(),
-            //         var.span,
-            //     );
-            // }
-
-            // for var in analysis.last_usages() {
-            //     crate::rerrs::report_info(
-            //         ErrorKind::FreeIdentifier.to_error_code(),
-            //         "input.rkt",
-            //         script,
-            //         "last usage of variable".to_string(),
-            //         var.span,
-            //     );
-            // }
-
-            analysis.lift_pure_local_functions();
-            // analysis.lift_local_functions();
-
-            for expr in analysis.exprs.iter() {
-                println!("{expr}");
-            }
-
-            let list_id = analysis
-                .query_top_level_define("list")
-                .unwrap()
-                .name
-                .atom_syntax_object()
-                .unwrap()
-                .syntax_object_id;
-
-            let alias_list_4_id = analysis
-                .query_top_level_define("alias-list4")
-                .unwrap()
-                .name
-                .atom_syntax_object()
-                .unwrap()
-                .syntax_object_id;
-
-            let found = analysis.resolve_alias(alias_list_4_id);
-
-            println!(
-                "List id: {list_id}, list 4 id: {alias_list_4_id}, resolved alias id: {found:?}"
-            );
-        }
-    }
-}
diff --git a/crates/steel-core/src/compiler/passes/begin.rs b/crates/steel-core/src/compiler/passes/begin.rs
deleted file mode 100644
index f021edbaa..000000000
--- a/crates/steel-core/src/compiler/passes/begin.rs
+++ /dev/null
@@ -1,656 +0,0 @@
-use log::{debug, log_enabled};
-use steel_parser::tokens::MaybeBigInt;
-
-use crate::parser::{
-    ast::{Atom, Begin, ExprKind, LambdaFunction, List, Set},
-    parser::SyntaxObject,
-};
-use crate::parser::{interner::InternedString, tokens::TokenType};
-use std::{collections::HashSet, time::Instant};
-
-use super::{Folder, VisitorMutUnit};
-
-pub(crate) struct FlattenBegin {}
-impl FlattenBegin {
-    pub(crate) fn flatten(expr: ExprKind) -> ExprKind {
-        FlattenBegin {}.visit(expr)
-    }
-}
-
-impl Folder for FlattenBegin {
-    #[inline]
-    fn visit_begin(&mut self, begin: Begin) -> ExprKind {
-        let span = begin.location;
-
-        if begin.exprs.len() == 1 {
-            return self.visit(begin.exprs.into_iter().next().unwrap());
-        }
-
-        // Flatten begins
-        let flattened_exprs = begin
-            .exprs
-            .into_iter()
-            .flat_map(|x| {
-                if let ExprKind::Begin(b) = x {
-                    b.exprs
-                        .into_iter()
-                        .map(|x| self.visit(x))
-                        .collect::<Vec<_>>()
-                } else {
-                    vec![self.visit(x)]
-                }
-            })
-            .collect::<Vec<_>>();
-
-        if flattened_exprs.len() == 1 {
-            flattened_exprs.into_iter().next().unwrap()
-        } else {
-            ExprKind::Begin(Begin::new(flattened_exprs, span))
-        }
-    }
-}
-
-pub fn flatten_begins_and_expand_defines(exprs: Vec<ExprKind>) -> Vec<ExprKind> {
-    let flatten_begins_and_expand_defines_time = Instant::now();
-
-    let res = exprs
-        .into_iter()
-        .map(FlattenBegin::flatten)
-        .map(ConvertDefinesToLets::convert_defines)
-        .collect();
-
-    if log_enabled!(log::Level::Debug) {
-        debug!(
-            target: "pipeline_time",
-            "Flatten begins and expand defines time: {:?}",
-            flatten_begins_and_expand_defines_time.elapsed()
-        );
-    }
-
-    res
-}
-
-struct DefinedVars {
-    defined_identifiers: HashSet<InternedString>,
-    output: bool,
-}
-
-impl DefinedVars {
-    fn new() -> Self {
-        DefinedVars {
-            defined_identifiers: HashSet::new(),
-            output: false,
-        }
-    }
-
-    fn insert(&mut self, name: InternedString) {
-        self.defined_identifiers.insert(name);
-    }
-
-    fn check_output(&mut self) -> bool {
-        let output = self.output;
-        self.output = false;
-        output
-    }
-}
-
-impl VisitorMutUnit for DefinedVars {
-    fn visit_atom(&mut self, a: &Atom) {
-        if let TokenType::Identifier(ident) = &a.syn.ty {
-            self.output = self.defined_identifiers.contains(ident) || self.output;
-        }
-    }
-}
-
-struct ConvertDefinesToLets {
-    depth: usize,
-}
-
-impl ConvertDefinesToLets {
-    fn new() -> Self {
-        Self { depth: 0 }
-    }
-
-    fn convert_defines(expr: ExprKind) -> ExprKind {
-        ConvertDefinesToLets::new().visit(expr)
-    }
-}
-
-impl Folder for ConvertDefinesToLets {
-    #[inline]
-    fn visit_lambda_function(&mut self, mut lambda_function: Box<LambdaFunction>) -> ExprKind {
-        self.depth += 1;
-        lambda_function.body = self.visit(lambda_function.body);
-        self.depth -= 1;
-        ExprKind::LambdaFunction(lambda_function)
-    }
-
-    // TODO
-    #[inline]
-    fn visit_begin(&mut self, mut begin: Begin) -> ExprKind {
-        if self.depth > 0 {
-            match convert_exprs_to_let(begin) {
-                ExprKind::Begin(mut b) => {
-                    b.exprs = b.exprs.into_iter().map(|e| self.visit(e)).collect();
-                    ExprKind::Begin(b)
-                }
-                ExprKind::List(mut l) => {
-                    l.args = l.args.into_iter().map(|x| self.visit(x)).collect();
-                    ExprKind::List(l)
-                }
-                ExprKind::Let(mut l) => {
-                    let mut visited_bindings = Vec::new();
-
-                    for (binding, expr) in l.bindings {
-                        visited_bindings.push((self.visit(binding), self.visit(expr)));
-                    }
-
-                    l.bindings = visited_bindings;
-                    l.body_expr = self.visit(l.body_expr);
-
-                    ExprKind::Let(l)
-                }
-                other => panic!("Something went wrong in define conversion, found: {other:?}"),
-            }
-        } else {
-            // println!("Ignoring begin");
-            begin.exprs = begin.exprs.into_iter().map(|e| self.visit(e)).collect();
-            ExprKind::Begin(begin)
-        }
-    }
-}
-
-#[derive(PartialEq, Debug)]
-enum ExpressionType {
-    DefineConst(InternedString),
-    DefineFlat(InternedString),
-    DefineFlatStar(InternedString),
-    DefineFunction(InternedString),
-    Expression,
-}
-
-impl ExpressionType {
-    fn is_expression(&self) -> bool {
-        matches!(self, ExpressionType::Expression)
-    }
-
-    fn eval_atom(t: &SyntaxObject) -> bool {
-        matches!(
-            t.ty,
-            TokenType::BooleanLiteral(_)
-                | TokenType::NumberLiteral(_)
-                | TokenType::StringLiteral(_)
-                | TokenType::CharacterLiteral(_)
-                | TokenType::IntegerLiteral(_)
-        )
-    }
-
-    fn is_constant(expr: &ExprKind) -> bool {
-        match expr {
-            ExprKind::Atom(Atom { syn, .. }) => Self::eval_atom(syn),
-            _ => false,
-        }
-    }
-
-    fn generate_expression_types(exprs: &[ExprKind]) -> Vec<ExpressionType> {
-        let mut expression_types = Vec::with_capacity(exprs.len());
-        let mut defined_idents = DefinedVars::new();
-
-        for expr in exprs {
-            match expr {
-                ExprKind::Define(d) => {
-                    let name = d
-                        .name
-                        .atom_identifier_or_else(|| {})
-                        .expect("Define without a legal name");
-
-                    defined_idents.insert(*name);
-
-                    match &d.body {
-                        ExprKind::LambdaFunction(_) => {
-                            expression_types.push(ExpressionType::DefineFunction(*name));
-                        }
-                        _ => {
-                            defined_idents.visit(&d.body);
-                            if defined_idents.check_output() {
-                                expression_types.push(ExpressionType::DefineFlatStar(*name));
-                            } else if Self::is_constant(&d.body) {
-                                expression_types.push(ExpressionType::DefineConst(*name));
-                            } else {
-                                expression_types.push(ExpressionType::DefineFlat(*name));
-                            }
-                        }
-                    }
-                }
-                _ => expression_types.push(ExpressionType::Expression),
-            }
-        }
-
-        // println!("Expression types: {:?}", expression_types);
-
-        expression_types
-    }
-}
-
-fn atom(name: String) -> ExprKind {
-    ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-        name.into(),
-    ))))
-}
-
-fn set(var: ExprKind, expr: ExprKind) -> ExprKind {
-    ExprKind::Set(Box::new(Set::new(
-        var,
-        expr,
-        SyntaxObject::default(TokenType::Set),
-    )))
-}
-
-fn apply_ident(func: ExprKind) -> ExprKind {
-    ExprKind::List(List::new(vec![func]))
-}
-
-fn convert_exprs_to_let(begin: Begin) -> ExprKind {
-    // let defines = collect_defines_from_current_scope(&exprs);
-
-    let expression_types = ExpressionType::generate_expression_types(&begin.exprs);
-
-    // Go ahead and quit if there are only expressions here
-    if expression_types.iter().all(|x| x.is_expression()) {
-        return ExprKind::Begin(begin);
-    }
-
-    if !expression_types
-        .iter()
-        .any(|x| matches!(x, ExpressionType::DefineFunction(_)))
-    {
-        // let starting_iter = ExprKind::atom("void".to_string())
-
-        // TODO: last expression needs to be something, otherwise this doesn't work
-        // if let Some(last) = expression_types.last() {
-        //     if !last.is_expression() {}
-        // }
-
-        // println!("IN HERE");
-        // println!("Expression_types")
-
-        return begin
-            .exprs
-            .into_iter()
-            .rev()
-            .reduce(|accum, expr| {
-                // println!("Accum: {:?}, Expr: {:?}", accum, expr);
-
-                match expr {
-                    ExprKind::Define(d) => {
-                        // let constructed_function =
-
-                        let constructed_function = ExprKind::LambdaFunction(
-                            LambdaFunction::new(
-                                vec![d.name],
-                                accum,
-                                SyntaxObject::default(TokenType::Lambda),
-                            )
-                            .into(),
-                        );
-
-                        ExprKind::List(List::new(vec![constructed_function, d.body]))
-                    }
-                    other => ExprKind::Begin(Begin::new(
-                        vec![other, accum],
-                        SyntaxObject::default(TokenType::Begin),
-                    )),
-                }
-            })
-            .expect("Empty expression");
-
-        // return todo!();
-    }
-
-    let mut exprs = begin.exprs.clone();
-
-    // let mut last_expression = expression_types.len();
-
-    let idx = expression_types
-        .iter()
-        .rev()
-        .position(|x| !x.is_expression())
-        .expect("Convert exprs to let in define conversion found no trailing expressions in begin");
-
-    // println!("Last expression index: {:?}", idx);
-
-    let idx = expression_types.len() - 1 - idx;
-
-    let mut body = exprs.split_off(idx + 1);
-
-    // These are going to be the
-    let args = exprs
-        .iter()
-        .map(|x| {
-            if let ExprKind::Define(d) = x {
-                d.body.clone()
-            } else {
-                x.clone()
-            }
-        })
-        .collect::<Vec<_>>();
-
-    // This corresponds to the (let ((apple ..) (banana ..) (cucumber ..)))
-    //                               ^^^^^^     ^^^^^^^      ^^^^^^^^
-    let mut top_level_arguments: Vec<ExprKind> = Vec::new();
-
-    // This corresponds to the set expressions
-    // (set! apple #####apple0)
-    // (set! banana #####banana1)
-    // (set! cucumber #####cucumber1)
-    let mut set_expressions: Vec<ExprKind> = Vec::new();
-
-    // corresponds to #####apple0, #####banana1, #####cucumber1, etc
-    let mut bound_names: Vec<ExprKind> = Vec::new();
-
-    // TODO - check that the last expression does not contain any usages of the constant?
-    // if expression_types[0..idx + 1]
-    //     .iter()
-    //     .all(|x| matches!(x, ExpressionType::DefineConst(_)))
-    // {
-    //     return ExprKind::Begin(Begin::new(body, begin.location));
-    // }
-
-    // Top level application with dummy arguments that will immediately get overwritten
-    let mut top_level_dummy_args = vec![
-        // ExprKind::Atom(Atom::new(SyntaxObject::default(
-        //     TokenType::IntegerLiteral(123)
-        // )));
-        // top_level_arguments.len()
-    ];
-
-    let mut new_args = Vec::new();
-
-    // println!("{:#?}", expression_types);
-
-    // TODO:
-    // If there are functions at all, go through this weird path
-    // Otherwise, we should do the following transformation:
-    //
-    // If there are no functions at all, just do a series of lets, similar to let*
-
-    // TODO: Move this up so we don't have to use raw_exprs anymore
-
-    for ((i, expression), arg) in expression_types[0..idx + 1].iter().enumerate().zip(args) {
-        match expression {
-            ExpressionType::DefineFunction(name) => {
-                if let ExprKind::Define(d) = &exprs[i] {
-                    top_level_arguments.push(d.name.clone());
-                    top_level_dummy_args.push(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                        TokenType::IntegerLiteral(MaybeBigInt::Small(123)),
-                    ))));
-                    let name_prime =
-                        atom("_____".to_string() + name.resolve() + i.to_string().as_str());
-                    let set_expr = set(d.name.clone(), name_prime.clone());
-                    bound_names.push(name_prime);
-                    set_expressions.push(set_expr);
-                    new_args.push(arg);
-                } else {
-                    panic!("expected define, found: {}", &exprs[i]);
-                };
-
-                // let name = Atom::new(SyntaxObject::new)
-            }
-            ExpressionType::DefineFlat(name) => {
-                if let ExprKind::Define(d) = &exprs[i] {
-                    top_level_arguments.push(d.name.clone());
-                    top_level_dummy_args.push(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                        TokenType::IntegerLiteral(MaybeBigInt::Small(123)),
-                    ))));
-                    let name_prime =
-                        atom("_____".to_string() + name.resolve() + i.to_string().as_str());
-                    let set_expr = set(d.name.clone(), name_prime.clone());
-                    bound_names.push(name_prime);
-                    set_expressions.push(set_expr);
-                    new_args.push(arg);
-                } else {
-                    panic!("expected define, found: {}", &exprs[i]);
-                };
-            }
-            ExpressionType::DefineConst(_name) => {
-                if let ExprKind::Define(d) = &exprs[i] {
-                    top_level_dummy_args.push(arg);
-                    top_level_arguments.push(d.name.clone());
-                    // top_level_arguments.push(d.name.clone());
-                    // let name_prime = atom("#####".to_string() + name + i.to_string().as_str());
-                    // let set_expr = set(d.name.clone(), name_prime.clone());
-                    // bound_names.push(name_prime);
-                    // set_expressions.push(set_expr);
-                } else {
-                    panic!("expected define, found: {}", &exprs[i]);
-                };
-            }
-            ExpressionType::DefineFlatStar(name) => {
-                if let ExprKind::Define(d) = &exprs[i] {
-                    top_level_arguments.push(d.name.clone());
-                    top_level_dummy_args.push(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                        TokenType::IntegerLiteral(MaybeBigInt::Small(123)),
-                    ))));
-                    let name_prime =
-                        atom("_____".to_string() + name.resolve() + i.to_string().as_str());
-
-                    // Make this a (set! x (x'))
-                    // Applying the function
-                    let set_expr = set(d.name.clone(), apply_ident(name_prime.clone()));
-
-                    // Set this to be an empty function (lambda () <expr>)
-                    new_args.push(
-                        LambdaFunction::new(
-                            Vec::new(),
-                            arg.clone(),
-                            SyntaxObject::default(TokenType::Lambda),
-                        )
-                        .into(),
-                    );
-
-                    bound_names.push(name_prime);
-                    set_expressions.push(set_expr);
-                } else {
-                    panic!("expected define, found: {}", &exprs[i]);
-                };
-            }
-            // TODO: Move this down, don't put it with the lets, put it down in order with the set expressions
-            // That way we're not at risk of accidentally goofing up the ordering of the expressions.
-            // If will _only_ go in the right order of assignment
-            ExpressionType::Expression => {
-                // TODO: This is definitly not right
-                // let expr = atom("#####define-conversion".to_string() + i.to_string().as_str());
-                // top_level_dummy_args.push(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                //     TokenType::IntegerLiteral(123),
-                // ))));
-
-                // // This also gets bound in the inner function for now
-                // bound_names.push(expr.clone());
-
-                // top_level_arguments.push(expr);
-                // new_args.push(arg);
-
-                set_expressions.push(arg)
-            }
-        }
-    }
-
-    // // Append the body instructions to the set!
-    set_expressions.append(&mut body);
-
-    let inner_lambda = LambdaFunction::new(
-        bound_names,
-        ExprKind::Begin(Begin::new(
-            set_expressions,
-            SyntaxObject::default(TokenType::Begin),
-        )),
-        SyntaxObject::default(TokenType::Lambda),
-    );
-
-    new_args.insert(0, ExprKind::LambdaFunction(Box::new(inner_lambda)));
-
-    let inner_application = ExprKind::List(List::new(new_args));
-
-    let outer_lambda = LambdaFunction::new(
-        top_level_arguments,
-        inner_application,
-        SyntaxObject::default(TokenType::Lambda),
-    );
-
-    top_level_dummy_args.insert(0, ExprKind::LambdaFunction(Box::new(outer_lambda)));
-
-    ExprKind::List(List::new(top_level_dummy_args))
-
-    // TODO: This is the real transformation that needs to take place once lets are fixed
-    // follow-up - let rec is going to be completely broken
-
-    // let pairs = bound_names
-    //     .into_iter()
-    //     .zip(new_args.into_iter())
-    //     .collect::<Vec<_>>();
-
-    // let inner_let = Let::new(
-    //     pairs,
-    //     ExprKind::Begin(Begin::new(
-    //         set_expressions,
-    //         SyntaxObject::default(TokenType::Begin),
-    //     )),
-    //     SyntaxObject::default(TokenType::Let),
-    // );
-
-    // let outer_pairs = top_level_arguments
-    //     .into_iter()
-    //     .zip(top_level_dummy_args.into_iter())
-    //     .collect::<Vec<_>>();
-
-    // let outer_let = Let::new(
-    //     outer_pairs,
-    //     ExprKind::Let(Box::new(inner_let)),
-    //     SyntaxObject::default(TokenType::Let),
-    // );
-
-    // let output = ExprKind::Let(Box::new(outer_let));
-
-    // println!("-----------------");
-    // println!("{}", output.to_pretty(60));
-
-    // output
-}
-
-#[cfg(test)]
-mod flatten_begin_test {
-
-    use super::*;
-    use crate::parser::ast::ExprKind;
-    use crate::parser::ast::{Atom, Begin, List};
-
-    use crate::parser::parser::SyntaxObject;
-    use crate::parser::tokens::TokenType;
-    use crate::parser::tokens::TokenType::*;
-
-    // #[test]
-    // fn defines_translates_to_simple_let() {
-    //     let expr = r#"
-    //     (lambda ()
-    //         (begin
-    //             (define x 10)
-    //             (define y 20)
-    //             (define z 30)
-    //             (+ x y z)))"#;
-
-    //     let expected = r#"
-    //     (lambda () ((lambda (x y z) ((lambda () (begin (+ x y z))))) 10 20 30))
-    //     "#;
-
-    //     let parsed = Parser::parse(expr).unwrap();
-    //     let expected_parsed = Parser::parse(expected).unwrap();
-
-    //     let result = flatten_begins_and_expand_defines(parsed);
-
-    //     assert_eq!(result, expected_parsed);
-    // }
-
-    fn atom(ident: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(Identifier(ident.into()))))
-    }
-
-    fn int(num: isize) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(IntegerLiteral(
-            MaybeBigInt::Small(num),
-        ))))
-    }
-
-    #[test]
-    fn basic_flatten_one_level() {
-        let expr = ExprKind::Begin(Begin::new(
-            vec![
-                ExprKind::Begin(Begin::new(
-                    vec![ExprKind::List(List::new(vec![
-                        atom("+"),
-                        atom("x"),
-                        int(10),
-                    ]))],
-                    SyntaxObject::default(TokenType::Begin),
-                )),
-                ExprKind::List(List::new(vec![atom("+"), atom("y"), int(20)])),
-                ExprKind::List(List::new(vec![atom("+"), atom("z"), int(30)])),
-            ],
-            SyntaxObject::default(TokenType::Begin),
-        ));
-
-        let expected = ExprKind::Begin(Begin::new(
-            vec![
-                ExprKind::List(List::new(vec![atom("+"), atom("x"), int(10)])),
-                ExprKind::List(List::new(vec![atom("+"), atom("y"), int(20)])),
-                ExprKind::List(List::new(vec![atom("+"), atom("z"), int(30)])),
-            ],
-            SyntaxObject::default(TokenType::Begin),
-        ));
-
-        assert_eq!(FlattenBegin::flatten(expr), expected);
-    }
-
-    #[test]
-    fn basic_flatten_multiple_levels() {
-        let expr = ExprKind::Begin(Begin::new(
-            vec![
-                ExprKind::Begin(Begin::new(
-                    vec![ExprKind::List(List::new(vec![
-                        atom("+"),
-                        atom("x"),
-                        int(10),
-                    ]))],
-                    SyntaxObject::default(TokenType::Begin),
-                )),
-                ExprKind::Begin(Begin::new(
-                    vec![ExprKind::List(List::new(vec![
-                        atom("+"),
-                        atom("y"),
-                        int(20),
-                    ]))],
-                    SyntaxObject::default(TokenType::Begin),
-                )),
-                ExprKind::Begin(Begin::new(
-                    vec![ExprKind::List(List::new(vec![
-                        atom("+"),
-                        atom("z"),
-                        int(30),
-                    ]))],
-                    SyntaxObject::default(TokenType::Begin),
-                )),
-            ],
-            SyntaxObject::default(TokenType::Begin),
-        ));
-
-        let expected = ExprKind::Begin(Begin::new(
-            vec![
-                ExprKind::List(List::new(vec![atom("+"), atom("x"), int(10)])),
-                ExprKind::List(List::new(vec![atom("+"), atom("y"), int(20)])),
-                ExprKind::List(List::new(vec![atom("+"), atom("z"), int(30)])),
-            ],
-            SyntaxObject::default(TokenType::Begin),
-        ));
-
-        assert_eq!(FlattenBegin::flatten(expr), expected);
-    }
-}
diff --git a/crates/steel-core/src/compiler/passes/manager.rs b/crates/steel-core/src/compiler/passes/manager.rs
deleted file mode 100644
index af55b7a1e..000000000
--- a/crates/steel-core/src/compiler/passes/manager.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use crate::parser::ast::ExprKind;
-
-use super::Folder;
-
-type PassFn = fn() -> Box<dyn Folder>;
-
-pub struct PassManager {
-    passes: Vec<PassFn>,
-}
-
-impl Default for PassManager {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl PassManager {
-    pub fn new() -> Self {
-        PassManager { passes: Vec::new() }
-    }
-
-    pub fn register_pass(&mut self, pass: PassFn) -> &mut Self {
-        self.passes.push(pass);
-        self
-    }
-
-    pub fn run(&self, mut ast: Vec<ExprKind>) -> Vec<ExprKind> {
-        let mut changed = false;
-        while changed {
-            for thunk in &self.passes {
-                let mut pass = thunk();
-                ast = pass.fold(ast);
-                changed = pass.modified();
-            }
-        }
-        ast
-    }
-}
diff --git a/crates/steel-core/src/compiler/passes/mangle.rs b/crates/steel-core/src/compiler/passes/mangle.rs
deleted file mode 100644
index 59a18dd74..000000000
--- a/crates/steel-core/src/compiler/passes/mangle.rs
+++ /dev/null
@@ -1,265 +0,0 @@
-use steel_parser::ast::DEFINE;
-
-use crate::{
-    compiler::program::BEGIN,
-    parser::{
-        ast::{Atom, ExprKind, Quote},
-        interner::InternedString,
-        tokens::TokenType,
-    },
-};
-
-use super::VisitorMutRefUnit;
-use std::collections::HashSet;
-
-/*
-Steps for doing having scoped macros
-
-- A requires a macro (or macros) from B
-    - Expand A with macros from A
-    - Then expand A with macros from B / C / D
-        - A must be done first, but then the rest can be done in phases
-    - Copy the code for B, mangle it and then include it in A directly
-*/
-
-pub fn collect_globals(exprs: &[ExprKind]) -> HashSet<InternedString> {
-    let mut global_defs = HashSet::new();
-
-    for expr in exprs {
-        match expr {
-            ExprKind::Define(d) => {
-                if let Some(name) = d.name.atom_identifier() {
-                    if name.resolve().starts_with("mangler") {
-                        continue;
-                    }
-                    global_defs.insert(*name);
-                }
-            }
-            ExprKind::List(l)
-                if l.first_ident() == Some(&*DEFINE)
-                    || l.first()
-                        .and_then(|x| x.atom_syntax_object())
-                        .map(|x| x.ty == TokenType::Define)
-                        .unwrap_or_default() =>
-            {
-                match l.get(1) {
-                    Some(ExprKind::Atom(_)) => {
-                        if let Some(name) = l.second_ident() {
-                            if name.resolve().starts_with("mangler") {
-                                continue;
-                            }
-                            // println!("Inserting: {}", name);
-                            global_defs.insert(*name);
-                        }
-                    }
-
-                    Some(ExprKind::List(l)) => {
-                        if let Some(name) = l.first_ident() {
-                            if name.resolve().starts_with("mangler") {
-                                continue;
-                            }
-                            // println!("Inserting: {}", name);
-                            global_defs.insert(*name);
-                        }
-                    }
-
-                    _ => {}
-                }
-            }
-            ExprKind::List(l)
-                if l.first_ident() == Some(&*BEGIN)
-                    || l.first()
-                        .and_then(|x| x.atom_syntax_object())
-                        .map(|x| x.ty == TokenType::Begin)
-                        .unwrap_or_default() =>
-            {
-                if l.len() > 1 {
-                    let collected_defs = collect_globals(&l[1..]);
-                    global_defs.extend(collected_defs);
-                }
-
-                // let collected_defs =collect_globals(&l[])
-            }
-            ExprKind::Begin(b) => {
-                let collected_defs = collect_globals(&b.exprs);
-                global_defs.extend(collected_defs);
-            }
-            _ => {}
-        }
-    }
-
-    global_defs
-}
-
-pub struct NameUnMangler<'a> {
-    prefix: &'a str,
-}
-
-impl<'a> NameUnMangler<'a> {
-    pub fn new(prefix: &'a str) -> Self {
-        Self { prefix }
-    }
-
-    pub fn unmangle_vars(&mut self, exprs: &mut [ExprKind]) {
-        for expr in exprs {
-            self.visit(expr);
-        }
-    }
-
-    pub fn unmangle_expr(&mut self, expr: &mut ExprKind) {
-        self.visit(expr);
-    }
-}
-
-impl<'a> VisitorMutRefUnit for NameUnMangler<'a> {
-    #[inline]
-    fn visit_quote(&mut self, q: &mut Quote) {
-        if let Some(expression) = q.expr.atom_identifier_mut() {
-            // TODO: Should roll up this into one thing, since strip prefix checks if
-            // it starts with the right value
-            if expression.resolve().starts_with(self.prefix) {
-                *expression = expression
-                    .resolve()
-                    .strip_prefix(self.prefix)
-                    .unwrap()
-                    .into();
-            }
-        }
-    }
-}
-
-pub struct NameMangler {
-    pub(crate) globals: HashSet<InternedString>,
-    prefix: String,
-}
-
-impl NameMangler {
-    pub fn new(globals: HashSet<InternedString>, prefix: String) -> Self {
-        Self { globals, prefix }
-    }
-
-    pub fn mangle_vars(&mut self, exprs: &mut [ExprKind]) {
-        for expr in exprs {
-            self.visit(expr);
-        }
-    }
-}
-
-pub fn mangle_vars_with_prefix(prefix: String, exprs: &mut [ExprKind]) {
-    let globals = collect_globals(exprs);
-
-    let mut name_mangler = NameMangler { globals, prefix };
-
-    for expr in exprs {
-        name_mangler.visit(expr);
-    }
-}
-
-impl VisitorMutRefUnit for NameMangler {
-    #[inline]
-    fn visit_atom(&mut self, a: &mut Atom) {
-        if let TokenType::Identifier(i) = &mut a.syn.ty {
-            if self.globals.contains(i) {
-                let new_str = i.resolve();
-
-                *i = (self.prefix.clone() + new_str).into();
-
-                // i.insert_str(0, &self.prefix);
-            }
-        }
-    }
-
-    /// We don't want quoted values to be mangled since those should match
-    /// the real name given
-    #[inline]
-    fn visit_quote(&mut self, _q: &mut Quote) {}
-}
-
-#[cfg(test)]
-mod name_mangling_tests {
-    use super::*;
-
-    use crate::parser::parser::Parser;
-
-    #[test]
-    fn basic_mangling() {
-        let expr = r#"
-           (define (foo x y z) (let ((a 10) (b 20)) (bar (+ x y z a b))))
-           (define (bar applesauce) (+ applesauce 10))
-        "#;
-
-        let mut parsed = Parser::parse(expr).unwrap();
-
-        mangle_vars_with_prefix("--test--".to_string(), &mut parsed);
-
-        let expected = Parser::parse(
-            r#"
-            (define (--test--foo x y z) (let ((a 10) (b 20)) (--test--bar (+ x y z a b))))
-            (define (--test--bar applesauce) (+ applesauce 10))
-        "#,
-        )
-        .unwrap();
-
-        assert_eq!(parsed, expected);
-    }
-
-    #[test]
-    fn shadowed_global_still_mangled() {
-        let expr = r#"
-        (define (foo x y z) (let ((foo 10) (b 20)) (foo (+ bar y z a b))))
-        (define (bar applesauce) (+ applesauce 10))
-     "#;
-
-        let mut parsed = Parser::parse(expr).unwrap();
-
-        mangle_vars_with_prefix("--test--".to_string(), &mut parsed);
-
-        let expected = Parser::parse(
-            r#"
-            (define (--test--foo x y z) (let ((--test--foo 10) (b 20)) (--test--foo (+ --test--bar y z a b))))
-            (define (--test--bar applesauce) (+ applesauce 10))
-     "#,
-        )
-        .unwrap();
-
-        assert_eq!(parsed, expected);
-    }
-
-    #[test]
-    fn still_collect_defines_in_begins() {
-        let expr = r#"
-        (begin 
-            (begin 
-                (begin 
-                    (begin 
-                        (define x 10)
-                    ) 
-                    (define y 20)
-                )
-            )
-        )
-        "#;
-
-        let mut parsed = Parser::parse(expr).unwrap();
-
-        mangle_vars_with_prefix("--test--".to_string(), &mut parsed);
-
-        let expected = Parser::parse(
-            r#"
-        (begin 
-            (begin 
-                (begin 
-                    (begin 
-                        (define --test--x 10)
-                    ) 
-                    (define --test--y 20)
-                )
-            )
-        )
-        "#,
-        )
-        .unwrap();
-
-        assert_eq!(parsed, expected);
-    }
-}
diff --git a/crates/steel-core/src/compiler/passes/mod.rs b/crates/steel-core/src/compiler/passes/mod.rs
deleted file mode 100644
index fedff42c6..000000000
--- a/crates/steel-core/src/compiler/passes/mod.rs
+++ /dev/null
@@ -1,510 +0,0 @@
-pub mod analysis;
-pub mod begin;
-pub mod manager;
-pub mod mangle;
-pub mod reader;
-pub mod shadow;
-
-use std::ops::ControlFlow;
-
-use crate::parser::ast::ExprKind;
-// use crate::parser::ast::*;
-
-use crate::parser::ast::{
-    Atom, Begin, Define, If, LambdaFunction, Let, List, Macro, Quote, Require, Return, Set,
-    SyntaxRules,
-};
-
-pub trait Folder {
-    fn fold(&mut self, ast: Vec<ExprKind>) -> Vec<ExprKind> {
-        ast.into_iter().map(|x| self.visit(x)).collect()
-    }
-
-    // Whether or not the pass modified the input AST
-    fn modified(&self) -> bool {
-        false
-    }
-
-    fn visit(&mut self, expr: ExprKind) -> ExprKind {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-
-    #[inline]
-    fn visit_if(&mut self, mut f: Box<If>) -> ExprKind {
-        f.test_expr = self.visit(f.test_expr);
-        f.then_expr = self.visit(f.then_expr);
-        f.else_expr = self.visit(f.else_expr);
-        ExprKind::If(f)
-    }
-
-    #[inline]
-    fn visit_let(&mut self, mut l: Box<Let>) -> ExprKind {
-        let mut visited_bindings = Vec::new();
-
-        for (binding, expr) in l.bindings {
-            visited_bindings.push((self.visit(binding), self.visit(expr)));
-        }
-
-        l.bindings = visited_bindings;
-        l.body_expr = self.visit(l.body_expr);
-
-        ExprKind::Let(l)
-    }
-
-    #[inline]
-    fn visit_define(&mut self, mut define: Box<Define>) -> ExprKind {
-        define.body = self.visit(define.body);
-        ExprKind::Define(define)
-    }
-
-    #[inline]
-    fn visit_lambda_function(&mut self, mut lambda_function: Box<LambdaFunction>) -> ExprKind {
-        lambda_function.body = self.visit(lambda_function.body);
-        ExprKind::LambdaFunction(lambda_function)
-    }
-
-    #[inline]
-    fn visit_begin(&mut self, mut begin: Begin) -> ExprKind {
-        begin.exprs = begin.exprs.into_iter().map(|e| self.visit(e)).collect();
-        ExprKind::Begin(begin)
-    }
-
-    #[inline]
-    fn visit_return(&mut self, mut r: Box<Return>) -> ExprKind {
-        r.expr = self.visit(r.expr);
-        ExprKind::Return(r)
-    }
-
-    #[inline]
-    fn visit_quote(&mut self, quote: Box<Quote>) -> ExprKind {
-        // quote.expr = self.visit(quote.expr);
-        ExprKind::Quote(quote)
-    }
-
-    #[inline]
-    fn visit_macro(&mut self, m: Box<Macro>) -> ExprKind {
-        ExprKind::Macro(m)
-    }
-
-    #[inline]
-    fn visit_atom(&mut self, a: Atom) -> ExprKind {
-        ExprKind::Atom(a)
-    }
-
-    #[inline]
-    fn visit_list(&mut self, mut l: List) -> ExprKind {
-        l.args = l.args.into_iter().map(|e| self.visit(e)).collect();
-        ExprKind::List(l)
-    }
-
-    #[inline]
-    fn visit_syntax_rules(&mut self, l: Box<SyntaxRules>) -> ExprKind {
-        ExprKind::SyntaxRules(l)
-    }
-
-    #[inline]
-    fn visit_set(&mut self, mut s: Box<Set>) -> ExprKind {
-        s.variable = self.visit(s.variable);
-        s.expr = self.visit(s.expr);
-        ExprKind::Set(s)
-    }
-
-    #[inline]
-    fn visit_require(&mut self, s: Require) -> ExprKind {
-        ExprKind::Require(s)
-    }
-}
-
-pub trait VisitorMutUnit {
-    fn visit(&mut self, expr: &ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-
-    #[inline]
-    fn visit_if(&mut self, f: &If) {
-        self.visit(&f.test_expr);
-        self.visit(&f.then_expr);
-        self.visit(&f.else_expr);
-    }
-
-    #[inline]
-    fn visit_let(&mut self, l: &Let) {
-        l.bindings.iter().for_each(|x| self.visit(&x.1));
-        self.visit(&l.body_expr);
-    }
-
-    #[inline]
-    fn visit_define(&mut self, define: &Define) {
-        self.visit(&define.body);
-    }
-
-    #[inline]
-    fn visit_lambda_function(&mut self, lambda_function: &LambdaFunction) {
-        self.visit(&lambda_function.body);
-    }
-
-    #[inline]
-    fn visit_begin(&mut self, begin: &Begin) {
-        for expr in &begin.exprs {
-            self.visit(expr);
-        }
-    }
-
-    #[inline]
-    fn visit_return(&mut self, r: &Return) {
-        self.visit(&r.expr);
-    }
-
-    #[inline]
-    fn visit_quote(&mut self, quote: &Quote) {
-        self.visit(&quote.expr);
-    }
-
-    #[inline]
-    fn visit_macro(&mut self, _m: &Macro) {}
-
-    #[inline]
-    fn visit_atom(&mut self, _a: &Atom) {}
-
-    #[inline]
-    fn visit_list(&mut self, l: &List) {
-        for expr in &l.args {
-            self.visit(expr);
-        }
-    }
-
-    #[inline]
-    fn visit_syntax_rules(&mut self, _l: &SyntaxRules) {}
-
-    #[inline]
-    fn visit_set(&mut self, s: &Set) {
-        self.visit(&s.variable);
-        self.visit(&s.expr);
-    }
-
-    #[inline]
-    fn visit_require(&mut self, _s: &Require) {}
-}
-
-pub trait VisitorMutControlFlow {
-    fn visit(&mut self, expr: &ExprKind) -> ControlFlow<()> {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-
-    #[inline]
-    fn visit_if(&mut self, f: &If) -> ControlFlow<()> {
-        self.visit(&f.test_expr)?;
-        self.visit(&f.then_expr)?;
-        self.visit(&f.else_expr)?;
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_let(&mut self, l: &Let) -> ControlFlow<()> {
-        for binding in &l.bindings {
-            self.visit(&binding.1)?;
-        }
-
-        self.visit(&l.body_expr)?;
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_define(&mut self, define: &Define) -> ControlFlow<()> {
-        self.visit(&define.body)?;
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_lambda_function(&mut self, lambda_function: &LambdaFunction) -> ControlFlow<()> {
-        self.visit(&lambda_function.body)?;
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_begin(&mut self, begin: &Begin) -> ControlFlow<()> {
-        for expr in &begin.exprs {
-            self.visit(expr)?;
-        }
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_return(&mut self, r: &Return) -> ControlFlow<()> {
-        self.visit(&r.expr)?;
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_quote(&mut self, quote: &Quote) -> ControlFlow<()> {
-        self.visit(&quote.expr)?;
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_macro(&mut self, _m: &Macro) -> ControlFlow<()> {
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_atom(&mut self, _a: &Atom) -> ControlFlow<()> {
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_list(&mut self, l: &List) -> ControlFlow<()> {
-        for expr in &l.args {
-            self.visit(expr)?;
-        }
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_syntax_rules(&mut self, _l: &SyntaxRules) -> ControlFlow<()> {
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_set(&mut self, s: &Set) -> ControlFlow<()> {
-        self.visit(&s.variable)?;
-        self.visit(&s.expr)?;
-
-        ControlFlow::Continue(())
-    }
-
-    #[inline]
-    fn visit_require(&mut self, _s: &Require) -> ControlFlow<()> {
-        ControlFlow::Continue(())
-    }
-}
-
-pub trait VisitorMutUnitRef<'a> {
-    fn visit(&mut self, expr: &'a ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-
-    #[inline]
-    fn visit_if(&mut self, f: &'a If) {
-        self.visit(&f.test_expr);
-        self.visit(&f.then_expr);
-        self.visit(&f.else_expr);
-    }
-
-    #[inline]
-    fn visit_let(&mut self, l: &'a Let) {
-        l.bindings.iter().for_each(|x| self.visit(&x.1));
-        self.visit(&l.body_expr);
-    }
-
-    #[inline]
-    fn visit_define(&mut self, define: &'a Define) {
-        self.visit(&define.name);
-        self.visit(&define.body);
-    }
-
-    #[inline]
-    fn visit_lambda_function(&mut self, lambda_function: &'a LambdaFunction) {
-        self.visit(&lambda_function.body);
-    }
-
-    #[inline]
-    fn visit_begin(&mut self, begin: &'a Begin) {
-        for expr in &begin.exprs {
-            self.visit(expr);
-        }
-    }
-
-    #[inline]
-    fn visit_return(&mut self, r: &'a Return) {
-        self.visit(&r.expr);
-    }
-
-    #[inline]
-    fn visit_quote(&mut self, quote: &'a Quote) {
-        self.visit(&quote.expr);
-    }
-
-    #[inline]
-    fn visit_macro(&mut self, m: &'a Macro) {
-        self.visit_syntax_rules(&m.syntax_rules);
-    }
-
-    #[inline]
-    fn visit_atom(&mut self, _a: &'a Atom) {}
-
-    #[inline]
-    fn visit_list(&mut self, l: &'a List) {
-        for expr in &l.args {
-            self.visit(expr);
-        }
-    }
-
-    #[inline]
-    fn visit_syntax_rules(&mut self, s: &'a SyntaxRules) {
-        for pattern in &s.patterns {
-            self.visit(&pattern.body);
-        }
-    }
-
-    #[inline]
-    fn visit_set(&mut self, s: &'a Set) {
-        self.visit(&s.variable);
-        self.visit(&s.expr);
-    }
-
-    #[inline]
-    fn visit_require(&mut self, _s: &'a Require) {}
-}
-
-pub trait VisitorMutRefUnit {
-    fn visit(&mut self, expr: &mut ExprKind) {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-            ExprKind::Let(l) => self.visit_let(l),
-        }
-    }
-
-    #[inline]
-    fn visit_if(&mut self, f: &mut If) {
-        self.visit(&mut f.test_expr);
-        self.visit(&mut f.then_expr);
-        self.visit(&mut f.else_expr);
-    }
-
-    #[inline]
-    fn visit_let(&mut self, l: &mut Let) {
-        l.bindings.iter_mut().for_each(|x| self.visit(&mut x.1));
-        self.visit(&mut l.body_expr);
-    }
-
-    #[inline]
-    fn visit_define(&mut self, define: &mut Define) {
-        self.visit(&mut define.name);
-        self.visit(&mut define.body);
-    }
-
-    #[inline]
-    fn visit_lambda_function(&mut self, lambda_function: &mut LambdaFunction) {
-        for var in &mut lambda_function.args {
-            self.visit(var);
-        }
-        self.visit(&mut lambda_function.body);
-    }
-
-    #[inline]
-    fn visit_begin(&mut self, begin: &mut Begin) {
-        for expr in &mut begin.exprs {
-            self.visit(expr);
-        }
-    }
-
-    #[inline]
-    fn visit_return(&mut self, r: &mut Return) {
-        self.visit(&mut r.expr);
-    }
-
-    #[inline]
-    fn visit_quote(&mut self, quote: &mut Quote) {
-        self.visit(&mut quote.expr);
-    }
-
-    #[inline]
-    fn visit_macro(&mut self, _m: &mut Macro) {}
-
-    #[inline]
-    fn visit_atom(&mut self, _a: &mut Atom) {}
-
-    #[inline]
-    fn visit_list(&mut self, l: &mut List) {
-        for expr in &mut l.args {
-            self.visit(expr);
-        }
-    }
-
-    #[inline]
-    fn visit_syntax_rules(&mut self, _l: &mut SyntaxRules) {}
-
-    #[inline]
-    fn visit_set(&mut self, s: &mut Set) {
-        self.visit(&mut s.variable);
-        self.visit(&mut s.expr);
-    }
-
-    #[inline]
-    fn visit_require(&mut self, _s: &mut Require) {}
-}
diff --git a/crates/steel-core/src/compiler/passes/reader.rs b/crates/steel-core/src/compiler/passes/reader.rs
deleted file mode 100644
index 55913877c..000000000
--- a/crates/steel-core/src/compiler/passes/reader.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-use crate::parser::{
-    ast::{ExprKind, List},
-    interner::InternedString,
-};
-
-use super::Folder;
-
-pub struct ExpandMethodCalls {}
-
-impl ExpandMethodCalls {
-    pub fn expand_methods(exprs: Vec<ExprKind>) -> Vec<ExprKind> {
-        ExpandMethodCalls {}.fold(exprs)
-    }
-}
-
-impl Folder for ExpandMethodCalls {
-    #[inline]
-    fn visit_list(&mut self, mut l: List) -> ExprKind {
-        if l.args.is_empty() {
-            l.args = l.args.into_iter().map(|e| self.visit(e)).collect();
-            return ExprKind::List(l);
-        }
-
-        // println!("Visiting list: {:?}", l);
-
-        if let Some(func) = l.first_ident().map(|x| x.to_string()) {
-            // println!("Inside this if statement");
-            // println!("Func: {:?}", func);
-
-            if func.contains('.') {
-                let words = func.split('.').collect::<Vec<_>>();
-
-                if words.len() != 2 {
-                    l.args = l.args.into_iter().map(|e| self.visit(e)).collect();
-                    return ExprKind::List(l);
-                } else {
-                    // Here we're going to transform (struct.method ...)
-                    // into (method struct)
-                    let mut first = l.args.remove(0);
-                    let mut second = first.clone();
-
-                    // method
-                    first.update_string_in_atom(words[0].into());
-
-                    // struct
-                    second.update_string_in_atom(words[1].into());
-
-                    // method pushed on first
-                    l.args.insert(0, first);
-
-                    // then the struct
-                    l.args.insert(0, second);
-
-                    l.args = l.args.into_iter().map(|e| self.visit(e)).collect();
-
-                    // println!("Expanded method call: {:?}", l);
-
-                    return ExprKind::List(l);
-                }
-            }
-        }
-
-        l.args = l.args.into_iter().map(|e| self.visit(e)).collect();
-        ExprKind::List(l)
-    }
-}
-
-pub struct MultipleArityFunctions {
-    dot: InternedString,
-}
-
-impl MultipleArityFunctions {
-    pub fn new() -> Self {
-        MultipleArityFunctions { dot: ".".into() }
-    }
-
-    pub fn expand_multiple_arity_functions(exprs: Vec<ExprKind>) -> Vec<ExprKind> {
-        MultipleArityFunctions { dot: ".".into() }.fold(exprs)
-    }
-}
-
-impl Folder for MultipleArityFunctions {
-    #[inline]
-    fn visit_lambda_function(
-        &mut self,
-        mut lambda_function: Box<crate::parser::ast::LambdaFunction>,
-    ) -> ExprKind {
-        // Visit the body
-        lambda_function.body = self.visit(lambda_function.body);
-
-        let mut dot_count = 0;
-
-        lambda_function
-            .args
-            .iter()
-            .filter_map(|x| x.atom_identifier())
-            .for_each(|x| {
-                if *x == self.dot {
-                    dot_count += 1;
-                }
-            });
-
-        // If we found one dot in the correct position
-        // Adjust this lambda function to be a rest function
-        if dot_count == 1 {
-            let dot_index = lambda_function.args.len() - 2;
-
-            if let Some(dot) = lambda_function.args[dot_index].atom_identifier() {
-                if *dot == self.dot {
-                    lambda_function.args.remove(dot_index);
-                    lambda_function.rest = true;
-
-                    log::debug!(target: "reader-macros", "transformed multi-arity function");
-                } else {
-                    return ExprKind::LambdaFunction(lambda_function);
-                }
-            }
-        }
-
-        ExprKind::LambdaFunction(lambda_function)
-    }
-}
diff --git a/crates/steel-core/src/compiler/passes/shadow.rs b/crates/steel-core/src/compiler/passes/shadow.rs
deleted file mode 100644
index da9ab7417..000000000
--- a/crates/steel-core/src/compiler/passes/shadow.rs
+++ /dev/null
@@ -1,199 +0,0 @@
-use std::collections::HashMap;
-
-use quickscope::{ScopeMap, ScopeSet};
-
-use crate::parser::{
-    ast::{Atom, ExprKind},
-    interner::InternedString,
-};
-
-use super::VisitorMutRefUnit;
-
-pub struct RenameShadowedVariables {
-    modified: bool,
-    scope: ScopeSet<InternedString>,
-    // Modify the variable with the depth
-    shadows: ScopeMap<InternedString, usize>,
-    str_modifiers: HashMap<usize, String>,
-}
-
-impl Default for RenameShadowedVariables {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl RenameShadowedVariables {
-    pub fn new() -> Self {
-        Self {
-            scope: ScopeSet::new(),
-            shadows: ScopeMap::new(),
-            modified: false,
-            str_modifiers: HashMap::new(),
-        }
-    }
-
-    pub fn rename_shadowed_vars(exprs: &mut [ExprKind]) {
-        let mut renamer = Self::new();
-
-        for expr in exprs.iter_mut() {
-            renamer.visit(expr);
-        }
-    }
-}
-
-impl VisitorMutRefUnit for RenameShadowedVariables {
-    fn visit_lambda_function(&mut self, lambda_function: &mut crate::parser::ast::LambdaFunction) {
-        self.scope.push_layer();
-        self.shadows.push_layer();
-
-        // TODO: Insert the code here to mark these variables as in scope
-
-        for variable in lambda_function.arguments_mut() {
-            if self.scope.contains(variable) {
-                let modifier = self.scope.depth();
-                self.shadows.define(*variable, modifier);
-
-                // Create a mutable string to mangle
-                let mut mut_var = "##".to_string() + variable.resolve();
-
-                if let Some(char_modifier) = char::from_digit(modifier as u32, 10) {
-                    mut_var.push(char_modifier);
-                } else if let Some(str_modifier) = self.str_modifiers.get(&modifier) {
-                    mut_var.push_str(str_modifier);
-                } else {
-                    self.str_modifiers.insert(modifier, modifier.to_string());
-                    mut_var.push_str(self.str_modifiers.get(&modifier).unwrap());
-                }
-
-                // println!("Mangling variable: {}", mut_var);
-
-                *variable = mut_var.into();
-
-                self.scope.define(*variable);
-
-                continue;
-            }
-
-            self.scope.define(*variable);
-        }
-
-        self.visit(&mut lambda_function.body);
-
-        self.scope.pop_layer();
-        self.shadows.pop_layer();
-    }
-
-    fn visit_quote(&mut self, _quote: &mut steel_parser::ast::Quote) {}
-
-    fn visit_atom(&mut self, a: &mut Atom) {
-        if let Some(ident) = a.ident_mut() {
-            if let Some(modifier) = self.shadows.get(ident) {
-                // Append the variable with the depth it occurs at.
-                // Now, shadowing shouldn't actually _be_ a problem
-                // ident.push(char::from_digit(*modifier as u32, 10).unwrap());
-
-                let mut mut_ident = "##".to_string() + ident.resolve();
-
-                if let Some(char_modifier) = char::from_digit(*modifier as u32, 10) {
-                    mut_ident.push(char_modifier)
-                } else if let Some(str_modifier) = self.str_modifiers.get(modifier) {
-                    mut_ident.push_str(str_modifier)
-                } else {
-                    panic!("The modifier should be defined by now")
-                }
-
-                *ident = mut_ident.into();
-
-                self.modified = true;
-            }
-        }
-    }
-
-    fn visit_let(&mut self, l: &mut crate::parser::ast::Let) {
-        self.scope.push_layer();
-        self.shadows.push_layer();
-
-        for variable in l
-            .bindings
-            .iter_mut()
-            .filter_map(|x| x.0.atom_identifier_mut())
-        {
-            if self.scope.contains(variable) {
-                let modifier = self.scope.depth();
-                self.shadows.define(*variable, modifier);
-
-                let mut mut_var = "##".to_string() + variable.resolve();
-
-                if let Some(char_modifier) = char::from_digit(modifier as u32, 10) {
-                    mut_var.push(char_modifier);
-                } else if let Some(str_modifier) = self.str_modifiers.get(&modifier) {
-                    mut_var.push_str(str_modifier);
-                } else {
-                    self.str_modifiers.insert(modifier, modifier.to_string());
-                    mut_var.push_str(self.str_modifiers.get(&modifier).unwrap());
-                }
-
-                *variable = mut_var.into();
-
-                self.scope.define(*variable);
-                continue;
-            }
-
-            self.scope.define(*variable);
-        }
-
-        //
-        l.bindings.iter_mut().for_each(|x| self.visit(&mut x.1));
-        self.visit(&mut l.body_expr);
-
-        // TODO: Insert the code here to mark these variables as in scope
-
-        self.scope.pop_layer();
-        self.shadows.pop_layer();
-    }
-}
-
-#[cfg(test)]
-mod shadow_mangling_tests {
-    use crate::parser::{ast::AstTools, parser::Parser};
-
-    use super::*;
-
-    #[test]
-    fn check_basic_shadowing() {
-        let script = r#"
-            (define (foo x)
-                (let ((x x))
-                    (+ x 10)))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut renamer = RenameShadowedVariables::new();
-
-        for expr in exprs.iter_mut() {
-            renamer.visit(expr);
-        }
-
-        exprs.pretty_print();
-    }
-
-    #[test]
-    fn check_basic_shadowing_multiple_levels() {
-        let script = r#"
-            (define (foo x)
-                (let ((x x))
-                    (let ((x x))
-                        (+ x 10))))
-        "#;
-
-        let mut exprs = Parser::parse(script).unwrap();
-        let mut renamer = RenameShadowedVariables::new();
-
-        for expr in exprs.iter_mut() {
-            renamer.visit(expr);
-        }
-
-        exprs.pretty_print();
-    }
-}
diff --git a/crates/steel-core/src/compiler/program.rs b/crates/steel-core/src/compiler/program.rs
deleted file mode 100644
index 6cce79221..000000000
--- a/crates/steel-core/src/compiler/program.rs
+++ /dev/null
@@ -1,1108 +0,0 @@
-use crate::core::labels::Expr;
-use crate::parser::span_visitor::get_span;
-use crate::rvals::Result;
-use crate::{
-    compiler::constants::ConstantMap,
-    core::{instructions::Instruction, opcode::OpCode},
-    stop, SteelVal,
-};
-use crate::{core::instructions::DenseInstruction, parser::span::Span};
-use crate::{
-    parser::{
-        ast::ExprKind,
-        interner::InternedString,
-        parser::{RawSyntaxObject, SyntaxObject},
-        tokens::TokenType,
-    },
-    rvals::IntoSteelVal,
-};
-
-use serde::{Deserialize, Serialize};
-use std::{collections::HashMap, convert::TryInto, rc::Rc, time::SystemTime};
-use steel_parser::tokens::MaybeBigInt;
-
-#[cfg(feature = "profiling")]
-use std::time::Instant;
-
-#[cfg(feature = "profiling")]
-use log::{debug, log_enabled};
-
-use super::{compiler::DebruijnIndicesInterner, map::SymbolMap};
-
-const _TILE_SUPER_INSTRUCTIONS: bool = false;
-
-/// evaluates an atom expression in given environment
-fn eval_atom(t: &SyntaxObject) -> Result<SteelVal> {
-    match &t.ty {
-        TokenType::BooleanLiteral(b) => Ok((*b).into()),
-        // TokenType::Identifier(s) => env.borrow().lookup(&s),
-        TokenType::NumberLiteral(n) => Ok(SteelVal::NumV(*n)),
-        TokenType::StringLiteral(s) => Ok(SteelVal::StringV(s.into())),
-        TokenType::CharacterLiteral(c) => Ok(SteelVal::CharV(*c)),
-        TokenType::IntegerLiteral(MaybeBigInt::Small(n)) => Ok(SteelVal::IntV(*n)),
-        // TODO: @Matt - This doesn't need to happen at all. It will just lead to unnecessary cloning.
-        TokenType::IntegerLiteral(MaybeBigInt::Big(b)) => b.clone().into_steelval(),
-        // TODO: Keywords shouldn't be misused as an expression - only in function calls are keywords allowed
-        TokenType::Keyword(k) => Ok(SteelVal::SymbolV(k.clone().into())),
-        what => {
-            println!("getting here in the eval_atom - code_generator");
-            stop!(UnexpectedToken => what; t.span)
-        }
-    }
-}
-
-pub fn specialize_read_local(instructions: &mut [Instruction]) {
-    for i in 0..instructions.len() {
-        let read_local = instructions.get(i);
-
-        match read_local {
-            Some(Instruction {
-                op_code: OpCode::MOVEREADLOCAL,
-                payload_size,
-                ..
-            }) => {
-                let op_code = match payload_size {
-                    0 => OpCode::MOVEREADLOCAL0,
-                    1 => OpCode::MOVEREADLOCAL1,
-                    2 => OpCode::MOVEREADLOCAL2,
-                    3 => OpCode::MOVEREADLOCAL3,
-                    _ => continue,
-                };
-
-                if let Some(x) = instructions.get_mut(i) {
-                    x.op_code = op_code;
-                }
-            }
-
-            Some(Instruction {
-                op_code: OpCode::READLOCAL,
-                payload_size,
-                ..
-            }) => {
-                let op_code = match payload_size {
-                    0 => OpCode::READLOCAL0,
-                    1 => OpCode::READLOCAL1,
-                    2 => OpCode::READLOCAL2,
-                    3 => OpCode::READLOCAL3,
-                    _ => continue,
-                };
-
-                if let Some(x) = instructions.get_mut(i) {
-                    x.op_code = op_code;
-                }
-            } // instructions[i + 1].op_code = OpCode::PASS;
-            // instructions[i + 2].op_code = OpCode::PASS;
-            // instructions[i + 4].op_code = OpCode::PASS;
-            _ => continue,
-        }
-    }
-}
-
-pub fn specialize_constants(instructions: &mut [Instruction]) -> Result<()> {
-    if instructions.is_empty() {
-        return Ok(());
-    }
-
-    for i in 0..instructions.len() {
-        match instructions.get(i) {
-            Some(Instruction {
-                op_code: OpCode::PUSHCONST,
-                contents:
-                    Some(Expr::Atom(SyntaxObject {
-                        ty: TokenType::Identifier(_),
-                        ..
-                    })),
-                ..
-            }) => continue,
-            Some(Instruction {
-                op_code: OpCode::PUSHCONST,
-                contents: Some(Expr::Atom(syn)),
-                ..
-            }) => {
-                let value = eval_atom(syn)?;
-
-                let opcode = match &value {
-                    SteelVal::IntV(0) => OpCode::LOADINT0,
-                    SteelVal::IntV(1) => OpCode::LOADINT1,
-                    SteelVal::IntV(2) => OpCode::LOADINT2,
-                    _ => continue,
-                };
-
-                instructions.get_mut(i).unwrap().op_code = opcode;
-            }
-            _ => continue,
-        }
-    }
-
-    Ok(())
-}
-
-pub fn convert_call_globals(instructions: &mut [Instruction]) {
-    if instructions.is_empty() {
-        return;
-    }
-
-    for i in 0..instructions.len() - 1 {
-        let push = instructions.get(i);
-        let func = instructions.get(i + 1);
-
-        match (push, func) {
-            (
-                Some(Instruction {
-                    op_code: OpCode::PUSH,
-                    payload_size: index,
-                    contents: Some(Expr::Atom(ident)),
-                    ..
-                }),
-                Some(Instruction {
-                    op_code: OpCode::FUNC,
-                    payload_size: arity,
-                    ..
-                }),
-            ) => {
-                let arity = *arity;
-                let index = *index;
-
-                if let TokenType::Identifier(ident) = ident.ty {
-                    match ident {
-                        _ if ident == *PRIM_CONS_SYMBOL => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::CONS;
-                                x.payload_size = 2;
-                                continue;
-                            }
-                        }
-
-                        // Specialize lists, cons, hashmap, etc. - anything that we expect to be used often in
-                        // real code.
-                        // _ if ident == *PRIM_LIST_SYMBOL => {
-                        //     if let Some(x) = instructions.get_mut(i) {
-                        //         x.op_code = OpCode::LIST;
-                        //         x.payload_size = arity;
-                        //         continue;
-                        //     }
-                        // }
-                        _ if ident == *BOX || ident == *PRIM_BOX => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::NEWBOX;
-                                continue;
-                            }
-                        }
-
-                        _ if ident == *UNBOX || ident == *PRIM_UNBOX => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::UNBOX;
-                                continue;
-                            }
-                        }
-
-                        _ if ident == *SETBOX || ident == *PRIM_SETBOX => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::SETBOX;
-                                continue;
-                            }
-                        }
-
-                        _ if ident == *PRIM_CAR => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::CAR;
-                                continue;
-                            }
-                        }
-
-                        // _ if ident == *CDR_SYMBOL || ident == *PRIM_CAR => {
-                        //     if let Some(x) = instructions.get_mut(i) {
-                        //         x.op_code = OpCode::CAR;
-                        //         continue;
-                        //     }
-                        // }
-                        _ => {
-                            // println!("Converting call global: {}", ident);
-                        }
-                    }
-                }
-
-                // TODO:
-                if let Some(x) = instructions.get_mut(i) {
-                    x.op_code = OpCode::CALLGLOBAL;
-                    x.payload_size = index;
-                }
-
-                if let Some(x) = instructions.get_mut(i + 1) {
-                    // Leave this as the OpCode::FUNC;
-                    // x.op_code = OpCode::Arity;
-                    x.payload_size = arity;
-                }
-            }
-            (
-                Some(Instruction {
-                    op_code: OpCode::PUSH,
-                    payload_size: index,
-                    contents: Some(Expr::Atom(ident)),
-                    ..
-                }),
-                Some(Instruction {
-                    op_code: OpCode::TAILCALL,
-                    // payload_size: arity,
-                    ..
-                }),
-            ) => {
-                // let arity = *arity;
-                let index = *index;
-
-                if let TokenType::Identifier(ident) = ident.ty {
-                    match ident {
-                        _ if ident == *PRIM_CONS_SYMBOL => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::CONS;
-                                x.payload_size = 2;
-                                continue;
-                            }
-                        }
-
-                        _ if ident == *BOX || ident == *PRIM_BOX => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::NEWBOX;
-                                continue;
-                            }
-                        }
-
-                        _ if ident == *UNBOX || ident == *PRIM_UNBOX => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::UNBOX;
-                                continue;
-                            }
-                        }
-
-                        _ if ident == *SETBOX || ident == *PRIM_SETBOX => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::SETBOX;
-                                continue;
-                            }
-                        }
-
-                        _ if ident == *PRIM_CAR => {
-                            if let Some(x) = instructions.get_mut(i) {
-                                x.op_code = OpCode::CAR;
-                                continue;
-                            }
-                        }
-
-                        // Specialize lists, cons, hashmap, etc. - anything that we expect to be used often in
-                        // real code.
-                        _ if ident == *LIST_SYMBOL || ident == *PRIM_LIST_SYMBOL => {}
-
-                        _ => {}
-                    }
-                }
-
-                if let Some(x) = instructions.get_mut(i) {
-                    x.op_code = OpCode::CALLGLOBALTAIL;
-                    x.payload_size = index;
-                }
-
-                // if let Some(x) = instructions.get_mut(i + 1) {
-                // x.op_code = OpCode::Arity;
-                // x.payload_size = arity;
-                // }
-            }
-            _ => {}
-        }
-    }
-}
-
-#[macro_export]
-macro_rules! define_primitive_symbols {
-    ($(($prim_name:tt, $name:tt) => $str:expr,) * ) => {
-        $(
-            pub static $name: once_cell::sync::Lazy<InternedString> = once_cell::sync::Lazy::new(|| InternedString::from_static($str));
-
-            pub static $prim_name: once_cell::sync::Lazy<InternedString> = once_cell::sync::Lazy::new(|| InternedString::from_static(concat!("#%prim.", $str)));
-        )*
-    };
-}
-
-#[macro_export]
-macro_rules! define_symbols {
-    ($($name:tt => $str:expr,) * ) => {
-        $(
-            pub static $name: once_cell::sync::Lazy<InternedString> = once_cell::sync::Lazy::new(|| InternedString::from_static($str));
-        )*
-    };
-}
-
-define_primitive_symbols! {
-    (PRIM_PLUS, PLUS) => "+",
-    (PRIM_MINUS, MINUS) => "-",
-    (PRIM_DIV, DIV) => "/",
-    (PRIM_STAR, STAR) => "*",
-    (PRIM_EQUAL, EQUAL) => "equal?",
-    (PRIM_LTE, LTE) => "<=",
-    (PRIM_CAR, CAR_SYMBOL) => "car",
-    (PRIM_CDR, CDR_SYMBOL) => "cdr",
-}
-
-define_symbols! {
-    UNREADABLE_MODULE_GET => "##__module-get",
-    STANDARD_MODULE_GET => "%module-get%",
-    CONTRACT_OUT => "contract/out",
-    REQUIRE_IDENT_SPEC => "%require-ident-spec",
-    PROVIDE => "provide",
-    FOR_SYNTAX => "for-syntax",
-    PREFIX_IN => "prefix-in",
-    ONLY_IN => "only-in",
-    DATUM_SYNTAX => "datum->syntax",
-    SYNTAX_SPAN => "#%syntax-span",
-    IF => "if",
-    DEFINE => "define",
-    LET => "let",
-    QUOTE =>"quote",
-    RETURN => "return!",
-    REQUIRE => "require",
-    SET => "set!",
-    PLAIN_LET => "%plain-let",
-    LAMBDA => "lambda",
-    LAMBDA_SYMBOL => "λ",
-    LAMBDA_FN => "fn",
-    BEGIN => "begin",
-    DOC_MACRO => "@doc",
-    REQUIRE_BUILTIN => "require-builtin",
-    REQUIRE_DYLIB => "#%require-dylib",
-    STRUCT_KEYWORD => "struct",
-    BETTER_LAMBDA => "#%better-lambda",
-    DEFINE_VALUES => "define-values",
-    AS_KEYWORD => "as",
-    SYNTAX_CONST_IF => "syntax-const-if",
-    UNQUOTE => "unquote",
-    UNQUOTE_COMMA => "#%unquote-comma",
-    RAW_UNQUOTE => "#%unquote",
-    UNQUOTE_SPLICING => "unquote-splicing",
-    RAW_UNQUOTE_SPLICING => "#%unquote-splicing",
-    QUASIQUOTE => "quasiquote",
-    RAW_QUOTE => "#%quote",
-    QUASISYNTAX => "quasisyntax",
-    UNSYNTAX => "unsyntax",
-    RAW_UNSYNTAX => "#%unsyntax",
-    UNSYNTAX_SPLICING => "unsyntax-splicing",
-    RAW_UNSYNTAX_SPLICING => "#%unsyntax-splicing",
-    SYNTAX_QUOTE => "syntax",
-    CONS_SYMBOL => "cons",
-    PRIM_CONS_SYMBOL => "#%prim.cons",
-    LIST_SYMBOL => "list",
-    PRIM_LIST_SYMBOL => "#%prim.list",
-    BOX => "#%box",
-    PRIM_BOX => "#%prim.box",
-    UNBOX => "#%unbox",
-    PRIM_UNBOX => "#%prim.unbox",
-    SETBOX => "#%set-box!",
-    PRIM_SETBOX => "#%prim.set-box!",
-    DEFMACRO => "defmacro",
-    BEGIN_FOR_SYNTAX => "begin-for-syntax",
-}
-
-pub fn inline_num_operations(instructions: &mut [Instruction]) {
-    for i in 0..instructions.len() - 1 {
-        let push = instructions.get(i);
-        let func = instructions.get(i + 1);
-
-        if let (
-            Some(Instruction {
-                op_code: OpCode::PUSH,
-                ..
-            }),
-            Some(Instruction {
-                op_code: OpCode::FUNC | OpCode::TAILCALL,
-                contents:
-                    Some(Expr::Atom(RawSyntaxObject {
-                        ty: TokenType::Identifier(ident),
-                        ..
-                    })),
-                payload_size,
-                ..
-            }),
-        ) = (push, func)
-        {
-            let replaced = match *ident {
-                x if x == *PRIM_PLUS && *payload_size == 2 => Some(OpCode::BINOPADD),
-                x if x == *PRIM_PLUS => Some(OpCode::ADD),
-                x if x == *PRIM_MINUS => Some(OpCode::SUB),
-                x if x == *PRIM_DIV => Some(OpCode::DIV),
-                x if x == *PRIM_STAR => Some(OpCode::MUL),
-                x if x == *PRIM_EQUAL => Some(OpCode::EQUAL),
-                x if x == *PRIM_LTE => Some(OpCode::LTE),
-                _ => None,
-            };
-
-            if let Some(new_op_code) = replaced {
-                let payload_size = *payload_size;
-                if let Some(x) = instructions.get_mut(i) {
-                    x.op_code = new_op_code;
-                    x.payload_size = payload_size;
-                }
-
-                if let Some(x) = instructions.get_mut(i + 1) {
-                    x.op_code = OpCode::PASS;
-                }
-            }
-        }
-    }
-}
-
-pub const fn sequence_to_opcode(pattern: &[(OpCode, usize)]) -> &'static [steel_gen::Pattern] {
-    match pattern {
-        &[(OpCode::MOVEREADLOCAL, _)] => &[steel_gen::Pattern::Single(OpCode::MOVEREADLOCAL)],
-        _ => todo!(),
-    }
-}
-
-pub fn tile_super_instructions(_instructions: &mut [Instruction]) {
-    #[cfg(feature = "dynamic")]
-    {
-        pub fn tile<const N: usize>(instructions: &mut [Instruction]) {
-            // let mut list: List<(usize, OpCode)> = List::new();
-
-            let mut buffer = [(OpCode::VOID, 0); N];
-
-            let mut pattern_buffer = Vec::with_capacity(N);
-
-            // Cell::from_mut()
-
-            if N > instructions.len() {
-                return;
-            }
-
-            for i in 0..instructions.len() - N {
-                for j in 0..N {
-                    buffer[j] = (
-                        instructions[i + j].op_code,
-                        instructions[i + j].payload_size,
-                    );
-                }
-
-                // If this is a candidate to match the pattern, let's try to apply it!
-                if let Some(op_code) = steel_gen::opcode::sequence_to_opcode(&buffer) {
-                    // Check if this pattern genuinely matches one of the code gen'd ones
-                    steel_gen::Pattern::from_opcodes_with_buffer(&buffer, &mut pattern_buffer);
-
-                    if crate::steel_vm::vm::pattern_exists(&pattern_buffer) {
-                        log::debug!(target: "super-instructions", "Applying tiling for: {:?}", op_code);
-
-                        instructions[i].op_code = op_code;
-
-                        continue;
-                    }
-                }
-            }
-
-            // for (index, op) in list {
-            //     instructions[index].op_code = op;
-            // }
-        }
-
-        // Super instruction tiling here!
-
-        if _TILE_SUPER_INSTRUCTIONS {
-            tile::<9>(instructions);
-            tile::<8>(instructions);
-            tile::<7>(instructions);
-            tile::<6>(instructions);
-            tile::<5>(instructions);
-            tile::<4>(instructions);
-            tile::<3>(instructions);
-            tile::<2>(instructions);
-        }
-    }
-}
-
-pub fn merge_conditions_with_if(instructions: &mut [Instruction]) {
-    for i in 0..instructions.len() - 1 {
-        let condition = instructions.get(i);
-        let guard = instructions.get(i + 2);
-
-        if let (
-            Some(Instruction {
-                op_code: OpCode::LTEIMMEDIATE,
-                ..
-            }),
-            Some(Instruction {
-                op_code: OpCode::IF,
-                ..
-            }),
-        ) = (condition, guard)
-        {
-            if let Some(x) = instructions.get_mut(i) {
-                x.op_code = OpCode::LTEIMMEDIATEIF;
-            }
-
-            // let replaced = match *ident {
-            //     x if x == *PLUS && *payload_size == 2 => Some(OpCode::BINOPADD),
-            //     x if x == *PLUS => Some(OpCode::ADD),
-            //     x if x == *MINUS => Some(OpCode::SUB),
-            //     x if x == *DIV => Some(OpCode::DIV),
-            //     x if x == *STAR => Some(OpCode::MUL),
-            //     x if x == *EQUAL => Some(OpCode::EQUAL),
-            //     x if x == *LTE => Some(OpCode::LTE),
-            //     _ => None,
-            // };
-
-            // if let Some(new_op_code) = replaced {
-            //     let payload_size = *payload_size;
-            //     if let Some(x) = instructions.get_mut(i) {
-            //         x.op_code = new_op_code;
-            //         x.payload_size = payload_size;
-            //     }
-
-            //     if let Some(x) = instructions.get_mut(i + 1) {
-            //         x.op_code = OpCode::PASS;
-            //     }
-            // }
-        }
-    }
-}
-
-pub struct ProgramBuilder(Vec<Vec<DenseInstruction>>);
-impl Default for ProgramBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl ProgramBuilder {
-    pub fn new() -> Self {
-        ProgramBuilder(Vec::new())
-    }
-
-    pub fn push(&mut self, val: Vec<DenseInstruction>) {
-        self.0.push(val);
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SerializableProgram {
-    pub instructions: Vec<Vec<DenseInstruction>>,
-    pub constant_map: Vec<u8>,
-}
-
-impl SerializableProgram {
-    pub fn write_to_file(&self, filename: &str) -> Result<()> {
-        use std::io::prelude::*;
-
-        let mut file = File::create(format!("{filename}.txt")).unwrap();
-
-        let buffer = bincode::serialize(self).unwrap();
-
-        file.write_all(&buffer)?;
-        Ok(())
-    }
-
-    pub fn read_from_file(filename: &str) -> Result<Self> {
-        use std::io::prelude::*;
-
-        let mut file = File::open(format!("{filename}.txt")).unwrap();
-
-        let mut buffer = Vec::new();
-
-        let _ = file.read_to_end(&mut buffer).unwrap();
-
-        let program: SerializableProgram = bincode::deserialize(&buffer).unwrap();
-
-        Ok(program)
-    }
-
-    pub fn into_program(self) -> Program {
-        let constant_map = ConstantMap::from_bytes(&self.constant_map).unwrap();
-        Program {
-            constant_map,
-            instructions: self.instructions,
-            ast: HashMap::new(),
-        }
-    }
-}
-
-/// Represents a Steel program
-/// The program holds the instructions and the constant map, serialized to bytes
-pub struct Program {
-    pub instructions: Vec<Vec<DenseInstruction>>,
-    pub constant_map: ConstantMap,
-    pub ast: HashMap<usize, ExprKind>,
-}
-
-impl Program {
-    pub fn new(
-        instructions: Vec<Vec<DenseInstruction>>,
-        constant_map: ConstantMap,
-        ast: HashMap<usize, ExprKind>,
-    ) -> Self {
-        Program {
-            instructions,
-            constant_map,
-            ast,
-        }
-    }
-
-    pub fn into_serializable_program(self) -> Result<SerializableProgram> {
-        Ok(SerializableProgram {
-            instructions: self.instructions,
-            constant_map: self.constant_map.to_bytes()?,
-        })
-    }
-}
-
-// An inspectable program with debug symbols still included on the instructions
-// ConstantMap needs to get passed in to the run time to execute the program
-// This way, the VM knows where to look up values
-#[derive(Clone)]
-pub struct RawProgramWithSymbols {
-    pub(crate) instructions: Vec<Vec<Instruction>>,
-    pub(crate) constant_map: ConstantMap,
-    version: String, // TODO -> this should be semver
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct SerializableRawProgramWithSymbols {
-    instructions: Vec<Vec<Instruction>>,
-    constant_map: Vec<u8>,
-    version: String,
-}
-
-impl SerializableRawProgramWithSymbols {
-    pub fn write_to_file(&self, filename: &str) -> Result<()> {
-        use std::io::prelude::*;
-
-        let mut file = File::create(format!("{filename}.txt")).unwrap();
-
-        let buffer = bincode::serialize(self).unwrap();
-
-        file.write_all(&buffer)?;
-        Ok(())
-    }
-
-    pub fn read_from_file(filename: &str) -> Result<Self> {
-        use std::io::prelude::*;
-
-        let mut file = File::open(format!("{filename}.txt")).unwrap();
-        let mut buffer = Vec::new();
-        let _ = file.read_to_end(&mut buffer).unwrap();
-        let program: Self = bincode::deserialize(&buffer).unwrap();
-
-        Ok(program)
-    }
-
-    pub fn into_raw_program(self) -> RawProgramWithSymbols {
-        let constant_map = ConstantMap::from_bytes(&self.constant_map).unwrap();
-        RawProgramWithSymbols {
-            // struct_functions: self.struct_functions,
-            instructions: self.instructions,
-            constant_map,
-            version: self.version,
-        }
-    }
-}
-
-use std::fs::File;
-use std::io::{self, BufRead};
-use std::path::Path;
-
-// The output is wrapped in a Result to allow matching on errors
-// Returns an Iterator to the Reader of the lines of the file.
-fn _read_lines<P>(filename: P) -> io::Result<io::Lines<io::BufReader<File>>>
-where
-    P: AsRef<Path>,
-{
-    let file = File::open(filename)?;
-    Ok(io::BufReader::new(file).lines())
-}
-
-// trait Profiler {
-//     #[inline(always)]
-//     fn process() -> bool;
-
-//     fn report(&self);
-// }
-
-impl RawProgramWithSymbols {
-    pub fn new(
-        // struct_functions: Vec<StructFuncBuilderConcrete>,
-        instructions: Vec<Vec<Instruction>>,
-        constant_map: ConstantMap,
-        version: String,
-    ) -> Self {
-        Self {
-            // struct_functions,
-            instructions,
-            constant_map,
-            version,
-        }
-    }
-
-    pub fn profile_instructions(&self) {
-        let iter = self
-            .instructions
-            .iter()
-            .flat_map(|x| x.iter())
-            .filter(|x| !matches!(x.op_code, OpCode::PASS));
-
-        let mut occurrences = HashMap::new();
-        for instr in iter {
-            *occurrences.entry(instr.op_code).or_default() += 1;
-        }
-
-        let total: usize = occurrences.values().sum();
-
-        let mut counts = occurrences
-            .into_iter()
-            .map(|x| (x.0, (x.1 as f64 / total as f64) * 100.0))
-            .collect::<Vec<(OpCode, f64)>>();
-
-        counts.sort_by(|x, y| y.1.partial_cmp(&x.1).unwrap());
-
-        println!("{counts:#?}");
-    }
-
-    // Definitely can be improved
-    // pub fn parse_from_self_hosted_file<P>(file: P) -> Result<Self>
-    // where
-    //     P: AsRef<Path>,
-    // {
-    //     let mut lines = read_lines(file)?;
-
-    //     // First line should be the constant map label
-    //     // let constant_map =
-
-    //     if let Some(constant_map_label) = lines.next() {
-    //         if constant_map_label? != "'ConstantMap" {
-    //             stop!(Generic => "Compiled file expected constant map label")
-    //         }
-    //     } else {
-    //         stop!(Generic => "Missing constant map label")
-    //     }
-
-    //     // Temportary interner
-    //     let mut intern = HashMap::new();
-
-    //     let constant_map = if let Some(constant_map) = lines.next() {
-    //         let constant_map = constant_map?;
-
-    //         let constant_map = constant_map
-    //             .trim_start_matches('[')
-    //             .trim_end_matches(']')
-    //             .split(',')
-    //             .map(|x| {
-    //                 // Parse the input
-    //                 let parsed: std::result::Result<Vec<ExprKind>, ParseError> =
-    //                     Parser::new(&x, &mut intern).collect();
-    //                 let parsed = parsed?;
-
-    //                 Ok(SteelVal::try_from(parsed[0].clone()).unwrap())
-    //             })
-    //             .collect::<Result<Vec<_>>>()
-    //             .map(ConstantMap::from_vec)?;
-
-    //         constant_map
-    //     } else {
-    //         stop!(Generic => "Missing constant map")
-    //     };
-
-    //     if let Some(instructions_label) = lines.next() {
-    //         if instructions_label? != "'Instructions" {
-    //             stop!(Generic => "Compiled file expected instructions label")
-    //         }
-    //     } else {
-    //         stop!(Generic => "Missing instructions label")
-    //     }
-
-    //     let mut instruction_set = Vec::new();
-
-    //     let mut instructions = Vec::new();
-
-    //     // Skip past the first 'Expression
-    //     lines.next();
-
-    //     for instruction_string in lines {
-    //         let instruction_string = instruction_string?;
-
-    //         if instruction_string == "'Expression" {
-    //             // instructions = Vec::new();
-    //             // if instruction_set.is_empty() {
-    //             instruction_set.push(instructions);
-    //             instructions = Vec::new();
-    //             // }
-
-    //             continue;
-    //         }
-
-    //         let parsed: std::result::Result<Vec<ExprKind>, ParseError> =
-    //             Parser::new(&instruction_string, &mut intern).collect();
-    //         let parsed = parsed?;
-
-    //         let value = SteelVal::try_from(parsed[0].clone()).unwrap();
-
-    //         if let SteelVal::ListV(v) = value {
-    //             // Get the op code here
-    //             let op_code =
-    //                 OpCode::from_str(v.get(1).unwrap().symbol_or_else(|| unreachable!()).unwrap());
-
-    //             // Get the payload
-    //             let payload = v.get(2).unwrap().int_or_else(|| unreachable!()).unwrap() as usize;
-
-    //             // Get the contents
-    //             // If I can't parse the object, just move on
-    //             let contents = ExprKind::try_from(v.get(3).unwrap())
-    //                 .ok()
-    //                 .and_then(|x| x.atom_syntax_object().cloned());
-
-    //             let instruction = Instruction::new_from_parts(op_code, payload, contents);
-
-    //             instructions.push(instruction)
-    //         } else {
-    //             stop!(Generic => "Instruction serialized incorrectly")
-    //         }
-    //     }
-
-    //     instruction_set.push(instructions);
-
-    //     Ok(Self::new(
-    //         instruction_set,
-    //         constant_map,
-    //         "0.0.1".to_string(),
-    //     ))
-    // }
-
-    pub fn into_serializable_program(self) -> Result<SerializableRawProgramWithSymbols> {
-        Ok(SerializableRawProgramWithSymbols {
-            instructions: self.instructions,
-            constant_map: self.constant_map.to_bytes()?,
-            version: self.version,
-        })
-    }
-
-    pub fn debug_print(&self) {
-        self.instructions
-            .iter()
-            .for_each(|i| println!("{}\n\n", crate::core::instructions::disassemble(i)))
-    }
-
-    /// Applies a peephole style optimization to the underlying instruction set
-    pub fn with_optimization<F: Fn(&mut [Instruction])>(&mut self, f: F) {
-        for instructions in &mut self.instructions {
-            f(instructions)
-        }
-    }
-
-    // Apply the optimizations to raw bytecode
-    pub(crate) fn apply_optimizations(&mut self) -> &mut Self {
-        // if std::env::var("CODE_GEN_V2").is_err() {
-        // Run down the optimizations here
-        for instructions in &mut self.instructions {
-            inline_num_operations(instructions);
-            convert_call_globals(instructions);
-
-            // gimmick_super_instruction(instructions);
-            // move_read_local_call_global(instructions);
-            specialize_read_local(instructions);
-
-            merge_conditions_with_if(instructions);
-
-            specialize_constants(instructions).unwrap();
-
-            // Apply the super instruction tiling!
-            tile_super_instructions(instructions);
-
-            // specialize_exit_jmp(instructions);
-
-            // loop_condition_local_const_arity_two(instructions);
-        }
-
-        self
-    }
-
-    pub fn debug_build(mut self, _name: String, symbol_map: &mut SymbolMap) -> Result<()> {
-        #[cfg(feature = "profiling")]
-        let now = Instant::now();
-
-        // let mut struct_instructions = Vec::new();
-
-        // for builder in &self.struct_functions {
-        //     // Add the eventual function names to the symbol map
-        //     let indices = symbol_map.insert_struct_function_names_from_concrete(builder);
-
-        //     // Get the value we're going to add to the constant map for eventual use
-        //     // Throw the bindings in as well
-        //     let constant_values = builder.to_constant_val(indices);
-        //     let idx = self.constant_map.add_or_get(constant_values);
-
-        //     struct_instructions.push(vec![Instruction::new_struct(idx), Instruction::new_pop()]);
-        // }
-
-        let mut interner = DebruijnIndicesInterner::default();
-
-        for expression in &mut self.instructions {
-            interner.collect_first_pass_defines(expression, symbol_map)?
-        }
-
-        for expression in &mut self.instructions {
-            interner.collect_second_pass_defines(expression, symbol_map)?
-        }
-
-        // TODO try here - the loop condition local const arity two seems to rely on the
-        // existence of having been already adjusted by the interner
-        for instructions in &mut self.instructions {
-            // loop_condition_local_const_arity_two(instructions);
-            specialize_constants(instructions)?;
-        }
-
-        // Put the new struct functions at the front
-        // struct_instructions.append(&mut self.instructions);
-        // self.instructions = struct_instructions;
-
-        self.instructions
-            .iter()
-            .for_each(|i| println!("{}\n\n", crate::core::instructions::disassemble(i)));
-
-        #[cfg(feature = "profiling")]
-        if log_enabled!(target: "pipeline_time", log::Level::Debug) {
-            debug!(target: "pipeline_time", "Executable Build Time: {:?}", now.elapsed());
-        }
-
-        // let mut sorted_symbol_map = symbol_map.map.iter().collect::<Vec<_>>();
-        // sorted_symbol_map.sort_by_key(|x| x.1);
-
-        // println!("Symbol Map: {:#?}", sorted_symbol_map);
-
-        Ok(())
-    }
-
-    // TODO -> check out the spans part of this
-    // also look into having the constant map be correct mapping
-    // I think the run time will have to swap the constant map in and out
-    pub fn build(mut self, name: String, symbol_map: &mut SymbolMap) -> Result<Executable> {
-        #[cfg(feature = "profiling")]
-        let now = Instant::now();
-
-        let mut interner = DebruijnIndicesInterner::default();
-
-        for expression in &mut self.instructions {
-            interner.collect_first_pass_defines(expression, symbol_map)?
-        }
-
-        for expression in &mut self.instructions {
-            interner.collect_second_pass_defines(expression, symbol_map)?
-        }
-
-        // if std::env::var("CODE_GEN_V2").is_err() {
-        // TODO try here - the loop condition local const arity two seems to rely on the
-        // existence of having been already adjusted by the interner
-        for instructions in &mut self.instructions {
-            // TODO: Re-enable optimizations
-            // loop_condition_local_const_arity_two(instructions);
-            specialize_constants(instructions)?;
-            // gimmick_super_instruction(instructions);
-            // move_read_local_call_global(instructions);
-            specialize_read_local(instructions);
-        }
-        // }
-
-        let (spans, instructions) = extract_spans(self.instructions);
-
-        // let mut sorted_symbol_map = symbol_map.map.iter().collect::<Vec<_>>();
-        // sorted_symbol_map.sort_by_key(|x| x.1);
-
-        // println!("Symbol Map: {:#?}", sorted_symbol_map);
-
-        #[cfg(feature = "profiling")]
-        if log_enabled!(target: "pipeline_time", log::Level::Debug) {
-            debug!(target: "pipeline_time", "Executable Build Time: {:?}", now.elapsed());
-        }
-
-        Ok(Executable {
-            name: Rc::new(name),
-            version: Rc::new(self.version),
-            time_stamp: SystemTime::now(),
-            instructions: instructions
-                .into_iter()
-                .map(|x| Rc::from(x.into_boxed_slice()))
-                .collect(),
-            constant_map: self.constant_map,
-            spans,
-        })
-    }
-}
-
-// TODO -> replace spans on instructions with index into span vector
-// this is kinda nasty but it _should_ work
-fn extract_spans(
-    instructions: Vec<Vec<Instruction>>,
-) -> (Vec<Rc<[Span]>>, Vec<Vec<DenseInstruction>>) {
-    // let mut span_vec = Vec::with_capacity(instructions.iter().map(|x| x.len()).sum());
-
-    // for instruction_set in &instructions {
-    //     for instruction in instruction_set {
-    //         if let Some(syn) = &instruction.contents {
-    //             span_vec.push(syn.span)
-    //         } else {
-    //             span_vec.push(Span::default())
-    //         }
-    //     }
-    // }
-
-    let span_vec = instructions
-        .iter()
-        .map(|x| {
-            x.iter()
-                .map(|x| {
-                    x.contents
-                        .as_ref()
-                        .map(|x| match x {
-                            Expr::Atom(a) => a.span,
-                            Expr::List(l) => get_span(l),
-                        })
-                        .unwrap_or_default()
-                })
-                .collect()
-        })
-        .collect();
-
-    let instructions: Vec<_> = instructions
-        .into_iter()
-        .map(|x| {
-            // let len = x.len();
-            x.into_iter()
-                .map(|i| {
-                    DenseInstruction::new(
-                        i.op_code,
-                        i.payload_size.try_into().unwrap_or_else(|_| {
-                            // println!("{:?}", len);
-                            println!("{:?}", i);
-                            panic!("Uh oh ")
-                        }),
-                    )
-                })
-                .collect()
-        })
-        .collect();
-
-    (span_vec, instructions)
-}
-
-// A program stripped of its debug symbols, but only constructable by running a pass
-// over it with the symbol map to intern all of the symbols in the order they occurred
-#[allow(unused)]
-#[derive(Clone)]
-pub struct Executable {
-    pub(crate) name: Rc<String>,
-    pub(crate) version: Rc<String>,
-    pub(crate) time_stamp: SystemTime, // TODO -> don't use system time, probably not as portable, prefer date time
-    pub(crate) instructions: Vec<Rc<[DenseInstruction]>>,
-    pub(crate) constant_map: ConstantMap,
-    pub(crate) spans: Vec<Rc<[Span]>>,
-}
-
-impl Executable {
-    pub fn name(&self) -> &str {
-        &self.name
-    }
-
-    pub fn time_stamp(&self) -> &SystemTime {
-        &self.time_stamp
-    }
-}
diff --git a/crates/steel-core/src/containers.rs b/crates/steel-core/src/containers.rs
deleted file mode 100644
index 980032de9..000000000
--- a/crates/steel-core/src/containers.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-use crate::SteelVal;
-
-mod private {
-    use crate::steel_vm::{builtin::BuiltInModule, engine::Engine};
-
-    pub trait Sealed {}
-
-    // Implement for those same types, but no others.
-    impl Sealed for BuiltInModule {}
-    impl Sealed for Engine {}
-}
-
-/// Blanket implementation for things that can register values into the container,
-/// used for RegisterFn
-pub(crate) trait RegisterValue: private::Sealed {
-    fn register_value_inner(&mut self, name: &str, value: SteelVal) -> &mut Self;
-}
diff --git a/crates/steel-core/src/conversions.rs b/crates/steel-core/src/conversions.rs
deleted file mode 100644
index 06cb7b5e3..000000000
--- a/crates/steel-core/src/conversions.rs
+++ /dev/null
@@ -1,470 +0,0 @@
-use crate::values::lists::List;
-
-use crate::{
-    gc::Gc,
-    rerrs::ErrorKind,
-    rvals::{AsRefSteelValFromUnsized, FromSteelVal, IntoSteelVal, Result},
-    SteelErr, SteelVal,
-};
-use std::{
-    borrow::Cow,
-    collections::{HashMap, HashSet},
-};
-
-#[cfg(feature = "anyhow")]
-mod anyhow_conversion {
-    use crate::{rvals::IntoSteelVal, SteelVal};
-
-    impl IntoSteelVal for anyhow::Error {
-        fn into_steelval(self) -> crate::rvals::Result<crate::SteelVal> {
-            Ok(SteelVal::StringV(format!("{:#?}", self).into()))
-        }
-    }
-}
-
-impl IntoSteelVal for SteelVal {
-    fn into_steelval(self) -> Result<SteelVal> {
-        Ok(self)
-    }
-}
-
-// impl IntoSteelVal for Result<SteelVal> {
-//     fn into_steelval(self) -> Result<SteelVal> {
-//         self
-//     }
-// }
-
-impl<T: FromSteelVal + Clone, D: im_lists::handler::DropHandler<Self>> FromSteelVal
-    for im_lists::list::GenericList<T, im_lists::shared::RcPointer, 256, 1, D>
-{
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        if let SteelVal::ListV(l) = val {
-            l.iter().map(T::from_steelval).collect()
-        } else {
-            stop!(TypeMismatch => "Unable to convert SteelVal to List, found: {}", val);
-        }
-    }
-}
-
-impl<T: IntoSteelVal + Clone, D: im_lists::handler::DropHandler<Self>> IntoSteelVal
-    for im_lists::list::GenericList<T, im_lists::shared::RcPointer, 256, 1, D>
-{
-    fn into_steelval(self) -> Result<SteelVal> {
-        self.into_iter()
-            .map(|x| x.into_steelval())
-            .collect::<Result<List<_>>>()
-            .map(SteelVal::ListV)
-    }
-}
-
-impl FromSteelVal for Gc<im_rc::HashMap<SteelVal, SteelVal>> {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        if let SteelVal::HashMapV(hm) = val {
-            Ok(hm.0.clone())
-        } else {
-            stop!(TypeMismatch => "Unable to convert Steelval to HashMap, found: {}", val);
-        }
-    }
-}
-
-// impl IntoSteelVal for str {
-//     fn into_steelval(self) -> Result<SteelVal> {
-//         Ok(SteelVal::StringV(self.to_string().into()))
-//     }
-// }
-
-// impl<T: IntoSteelVal + Clone> IntoSteelVal for Cow<'_, T> {
-//     fn into_steelval(self) -> Result<SteelVal> {
-//         match self {
-//             Cow::Borrowed(b) => b.clone().into_steelval(),
-//             Cow::Owned(o) => o.into_steelval(),
-//         }
-//     }
-// }
-
-impl IntoSteelVal for Cow<'_, str> {
-    fn into_steelval(self) -> Result<SteelVal> {
-        match self {
-            Cow::Borrowed(b) => b.into_steelval(),
-            Cow::Owned(o) => o.into_steelval(),
-        }
-    }
-}
-
-impl FromSteelVal for Cow<'_, str> {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        if let SteelVal::StringV(s) = val {
-            Ok(Cow::Owned(s.to_string()))
-        } else {
-            stop!(TypeMismatch => "expected string, found {:?}", val)
-        }
-    }
-}
-
-impl<T: IntoSteelVal + Clone> IntoSteelVal for &[T] {
-    fn into_steelval(self) -> Result<SteelVal> {
-        self.iter()
-            .map(|x| x.clone().into_steelval())
-            .collect::<Result<List<_>>>()
-            .map(SteelVal::ListV)
-    }
-}
-
-// TODO: @Matt - figure out how to get this to actually return the right value. At the moment,
-// it seems I can't get this to return the correct value
-impl<T: FromSteelVal + Clone> AsRefSteelValFromUnsized<T> for T {
-    type Output = Vec<T>;
-
-    fn as_ref_from_unsized(val: &SteelVal) -> Result<Self::Output> {
-        if let SteelVal::ListV(v) = val {
-            v.iter()
-                .map(|x| T::from_steelval(x))
-                .collect::<Result<Vec<_>>>()
-        } else {
-            stop!(TypeMismatch => "expected list, found: {:?}", val);
-        }
-    }
-}
-
-impl<A: IntoSteelVal, B: IntoSteelVal> IntoSteelVal for (A, B) {
-    fn into_steelval(self) -> Result<SteelVal> {
-        Ok(SteelVal::ListV(
-            vec![self.0.into_steelval()?, self.1.into_steelval()?].into(),
-        ))
-    }
-}
-
-// Vectors should translate into vectors in rust
-impl<T: IntoSteelVal> IntoSteelVal for Vec<T> {
-    fn into_steelval(self) -> Result<SteelVal> {
-        let vec_vals: Result<Vec<SteelVal>> = self.into_iter().map(|x| x.into_steelval()).collect();
-
-        match vec_vals {
-            Ok(l) => Ok(SteelVal::ListV(l.into())),
-            _ => Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                "Could not convert vector of values to SteelVal list".to_string(),
-            )),
-        }
-    }
-}
-
-impl<T: FromSteelVal> FromSteelVal for Vec<T> {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        match val {
-            SteelVal::ListV(l) => {
-                let result_vec_vals: Result<Self> = l
-                    .into_iter()
-                    .map(|x| FromSteelVal::from_steelval(x))
-                    .collect();
-
-                match result_vec_vals {
-                    Ok(x) => Ok(x),
-                    _ => Err(SteelErr::new(
-                        ErrorKind::ConversionError,
-                        "Could not convert SteelVal list to Vector of values".to_string(),
-                    )),
-                }
-            }
-            // SteelVal::Pair(_) => {
-            //     let result_vec_vals: Result<Self> = SteelVal::iter(val.clone())
-            //         .into_iter()
-            //         .map(FromSteelVal::from_steelval)
-            //         .collect();
-
-            //     match result_vec_vals {
-            //         Ok(x) => Ok(x),
-            //         _ => Err(SteelErr::new(
-            //             ErrorKind::ConversionError,
-            //             "Could not convert SteelVal list to Vector of values".to_string(),
-            //         )),
-            //     }
-            // }
-            SteelVal::VectorV(v) => {
-                let result_vec_vals: Result<Self> =
-                    v.iter().map(FromSteelVal::from_steelval).collect();
-                match result_vec_vals {
-                    Ok(x) => Ok(x),
-                    _ => Err(SteelErr::new(
-                        ErrorKind::ConversionError,
-                        "Could not convert SteelVal list to Vector of values".to_string(),
-                    )),
-                }
-            } // TODO
-            _ => Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                "Could not convert SteelVal list to Vector of values".to_string(),
-            )),
-        }
-    }
-}
-
-impl<T: FromSteelVal> FromSteelVal for Box<[T]> {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        match val {
-            SteelVal::ListV(l) => {
-                let result_vec_vals: Result<Self> = l
-                    .into_iter()
-                    .map(|x| FromSteelVal::from_steelval(x))
-                    .collect();
-
-                match result_vec_vals {
-                    Ok(x) => Ok(x),
-                    _ => Err(SteelErr::new(
-                        ErrorKind::ConversionError,
-                        "Could not convert SteelVal list to Vector of values".to_string(),
-                    )),
-                }
-            }
-            SteelVal::VectorV(v) => {
-                let result_vec_vals: Result<Self> =
-                    v.iter().map(FromSteelVal::from_steelval).collect();
-                match result_vec_vals {
-                    Ok(x) => Ok(x),
-                    _ => Err(SteelErr::new(
-                        ErrorKind::ConversionError,
-                        "Could not convert SteelVal list to Vector of values".to_string(),
-                    )),
-                }
-            } // TODO
-            _ => Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                "Could not convert SteelVal list to Vector of values".to_string(),
-            )),
-        }
-    }
-}
-
-impl FromSteelVal for Box<str> {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        if let SteelVal::StringV(s) = val {
-            Ok(s.as_str().into())
-        } else {
-            stop!(TypeMismatch => "Unable to convert {} into Box<str>", val);
-        }
-    }
-}
-
-// HashMap
-impl<K: IntoSteelVal, V: IntoSteelVal> IntoSteelVal for HashMap<K, V> {
-    fn into_steelval(mut self) -> Result<SteelVal> {
-        let mut hm = im_rc::HashMap::new();
-        for (key, val) in self.drain() {
-            hm.insert(key.into_steelval()?, val.into_steelval()?);
-        }
-        Ok(SteelVal::HashMapV(Gc::new(hm).into()))
-    }
-}
-
-impl<K: FromSteelVal + Eq + std::hash::Hash, V: FromSteelVal> FromSteelVal for HashMap<K, V> {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        // todo!()
-        if let SteelVal::HashMapV(hm) = val {
-            let mut h = HashMap::new();
-            for (key, value) in hm.0.unwrap().into_iter() {
-                h.insert(K::from_steelval(&key)?, V::from_steelval(&value)?);
-            }
-            Ok(h)
-        } else {
-            Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                "Could not convert SteelVal to HashMap".to_string(),
-            ))
-        }
-    }
-}
-
-// BTreeMap
-// impl<K: IntoSteelVal, V: IntoSteelVal> IntoSteelVal for BTreeMap<K, V> {
-//     fn into_steelval(self) -> Result<SteelVal> {
-//         let mut hm = im_rc::HashMap::new();
-//         for (key, val) in self.drain() {
-//             hm.insert(key.into_steelval()?, val.into_steelval()?);
-//         }
-//         Ok(SteelVal::HashMapV(Gc::new(hm)))
-//     }
-// }
-
-// impl<K: FromSteelVal, V: FromSteelVal> FromSteelVal for BTreeMap<K, V> {
-//     fn from_steelval(val: SteelVal) -> Result<Self> {
-//         todo!()
-//     }
-// }
-
-impl<A: FromSteelVal, B: FromSteelVal> FromSteelVal for (A, B) {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        if let SteelVal::ListV(l) = val {
-            if l.len() != 2 {
-                return Err(SteelErr::new(ErrorKind::ConversionError, format!("Could not convert steelval to (A, B): {:?} - list was not length of 2, found length: {}", val, l.len())));
-            }
-
-            Ok((
-                A::from_steelval(l.get(0).unwrap())?,
-                B::from_steelval(l.get(1).unwrap())?,
-            ))
-        } else {
-            Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                format!("Could not convert SteelVal to (A, B): {:?}", val),
-            ))
-        }
-    }
-}
-
-// HashSet
-impl<K: IntoSteelVal> IntoSteelVal for HashSet<K> {
-    fn into_steelval(mut self) -> Result<SteelVal> {
-        let mut hs = im_rc::HashSet::new();
-        for value in self.drain() {
-            hs.insert(value.into_steelval()?);
-        }
-        Ok(SteelVal::HashSetV(Gc::new(hs).into()))
-    }
-}
-
-impl<K: FromSteelVal + Eq + std::hash::Hash> FromSteelVal for HashSet<K> {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        if let SteelVal::HashSetV(hs) = val {
-            let mut h = HashSet::new();
-            for k in hs.0.unwrap().into_iter() {
-                h.insert(K::from_steelval(&k)?);
-            }
-            Ok(h)
-        } else {
-            Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                "Could not convert SteelVal to HashSet".to_string(),
-            ))
-        }
-    }
-}
-
-// BTreeSet
-// impl<K: IntoSteelVal> IntoSteelVal for BTreeSet<K> {
-//     fn into_steelval(self) -> Result<SteelVal> {
-//         todo!()
-//     }
-// }
-
-// impl<K: FromSteelVal> FromSteelVal for BTreeSet<K> {
-//     fn from_steelval(val: SteelVal) -> Result<Self> {
-//         todo!()
-//     }
-// }
-
-#[cfg(test)]
-mod conversion_tests {
-
-    use super::*;
-
-    use im_rc::vector;
-
-    #[test]
-    fn vec_into_list() {
-        let input_vec = vec![1, 2];
-        // let expected = SteelVal::Pair(Gc::new(ConsCell::new(
-        //     SteelVal::IntV(1),
-        //     Some(Gc::new(ConsCell::new(SteelVal::IntV(2), None))),
-        // )));
-
-        let expected = SteelVal::ListV(vec![SteelVal::IntV(1), SteelVal::IntV(2)].into());
-
-        assert_eq!(input_vec.into_steelval().unwrap(), expected)
-    }
-
-    #[test]
-    fn vec_from_list() {
-        let input_list = SteelVal::ListV(vec![SteelVal::IntV(1), SteelVal::IntV(2)].into());
-
-        let expected = vec![1, 2];
-        let result = <Vec<i32>>::from_steelval(&input_list).unwrap();
-
-        assert_eq!(result, expected)
-    }
-
-    #[test]
-    fn vec_from_vector() {
-        let input_vector = vector![SteelVal::IntV(1), SteelVal::IntV(2)].into();
-
-        let expected = vec![1, 2];
-        let result = <Vec<i32>>::from_steelval(&input_vector).unwrap();
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn vec_from_steelval_error() {
-        let input = SteelVal::IntV(2);
-        assert!(<Vec<i32>>::from_steelval(&input).is_err());
-    }
-
-    #[test]
-    fn hashmap_into_steelval() {
-        let mut input = HashMap::new();
-        input.insert("foo".to_string(), "bar".to_string());
-        input.insert("foo2".to_string(), "bar2".to_string());
-
-        let expected = SteelVal::HashMapV(
-            Gc::new(im_rc::hashmap! {
-                SteelVal::StringV("foo".into()) => SteelVal::StringV("bar".into()),
-                SteelVal::StringV("foo2".into()) => SteelVal::StringV("bar2".into())
-            })
-            .into(),
-        );
-
-        assert_eq!(input.into_steelval().unwrap(), expected);
-    }
-
-    #[test]
-    fn hashmap_from_steelval_hashmap() {
-        let input = SteelVal::HashMapV(
-            Gc::new(im_rc::hashmap! {
-                SteelVal::StringV("foo".into()) => SteelVal::StringV("bar".into()),
-                SteelVal::StringV("foo2".into()) => SteelVal::StringV("bar2".into())
-            })
-            .into(),
-        );
-
-        let mut expected = HashMap::new();
-        expected.insert("foo".to_string(), "bar".to_string());
-        expected.insert("foo2".to_string(), "bar2".to_string());
-
-        assert_eq!(
-            <HashMap<String, String>>::from_steelval(&input).unwrap(),
-            expected
-        );
-    }
-
-    #[test]
-    fn hashset_into_steelval() {
-        let mut input = HashSet::new();
-        input.insert("foo".to_string());
-        input.insert("bar".to_string());
-
-        let expected = SteelVal::HashSetV(
-            Gc::new(im_rc::hashset! {
-                SteelVal::StringV("foo".into()),
-                SteelVal::StringV("bar".into())
-            })
-            .into(),
-        );
-
-        assert_eq!(input.into_steelval().unwrap(), expected);
-    }
-
-    #[test]
-    fn hashset_from_steelval_hashset() {
-        let input = SteelVal::HashSetV(
-            Gc::new(im_rc::hashset! {
-                SteelVal::StringV("foo".into()),
-                SteelVal::StringV("bar".into())
-            })
-            .into(),
-        );
-
-        let mut expected = HashSet::new();
-        expected.insert("foo".to_string());
-        expected.insert("bar".to_string());
-
-        assert_eq!(<HashSet<String>>::from_steelval(&input).unwrap(), expected);
-    }
-}
diff --git a/crates/steel-core/src/core/instructions.rs b/crates/steel-core/src/core/instructions.rs
deleted file mode 100644
index 159e39f14..000000000
--- a/crates/steel-core/src/core/instructions.rs
+++ /dev/null
@@ -1,139 +0,0 @@
-use crate::core::opcode::OpCode;
-use serde::{Deserialize, Serialize};
-use std::convert::TryInto;
-
-use super::labels::Expr;
-
-/// Instruction loaded with lots of information prior to being condensed
-/// Includes the opcode and the payload size, plus some information
-/// used for locating spans and pretty error messages
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Instruction {
-    pub op_code: OpCode,
-    pub payload_size: usize,
-    pub contents: Option<Expr>,
-}
-
-impl Instruction {
-    pub fn new_from_parts(
-        op_code: OpCode,
-        payload_size: usize,
-        contents: Option<Expr>,
-    ) -> Instruction {
-        Instruction {
-            op_code,
-            payload_size,
-            contents,
-        }
-    }
-}
-
-// Want to turn a steel struct directly into this struct
-// If we values themselves can be mapped
-// impl TryFrom<SteelStruct> for Instruction {
-//     type Error = crate::SteelErr;
-
-//     fn try_from(value: SteelStruct) -> Result<Self, Self::Error> {
-//         if value.name == "Instruction" {
-
-//         }
-//     }
-// }
-
-pub fn densify(instructions: Vec<Instruction>) -> Vec<DenseInstruction> {
-    instructions.into_iter().map(|x| x.into()).collect()
-}
-
-pub fn pretty_print_dense_instructions(instrs: &[DenseInstruction]) {
-    for (i, instruction) in instrs.iter().enumerate() {
-        println!(
-            "{}    {:?} : {}",
-            i, instruction.op_code, instruction.payload_size
-        );
-    }
-}
-
-pub fn disassemble(instructions: &[Instruction]) -> String {
-    let first_column_width = instructions.len().to_string().len();
-    let second_column_width = instructions
-        .iter()
-        .map(|x| format!("{:?}", x.op_code).len())
-        .max()
-        .unwrap();
-    let third_column_width = instructions
-        .iter()
-        .map(|x| x.payload_size.to_string().len())
-        .max()
-        .unwrap();
-
-    let mut buffer = String::new();
-
-    for (i, instruction) in instructions.iter().enumerate() {
-        let index = i.to_string();
-
-        buffer.push_str(index.as_str());
-        for _ in 0..(first_column_width - index.len()) {
-            buffer.push(' ');
-        }
-
-        buffer.push_str("    ");
-
-        let op_code = format!("{:?}", instruction.op_code);
-        buffer.push_str(op_code.as_str());
-        for _ in 0..(second_column_width - op_code.len()) {
-            buffer.push(' ');
-        }
-
-        buffer.push_str(" : ");
-
-        let payload_size = instruction.payload_size.to_string();
-        buffer.push_str(payload_size.as_str());
-        for _ in 0..(third_column_width - payload_size.len()) {
-            buffer.push(' ');
-        }
-
-        buffer.push_str("    ");
-
-        if let Some(syn) = instruction.contents.as_ref() {
-            match syn {
-                Expr::Atom(syn) => {
-                    let contents = syn.ty.to_string();
-                    buffer.push_str(contents.as_str());
-                }
-                Expr::List(l) => {
-                    let contents = l.to_string();
-                    buffer.push_str(contents.as_str());
-                }
-            }
-        }
-
-        buffer.push('\n');
-    }
-
-    buffer
-}
-
-#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
-pub struct DenseInstruction {
-    pub op_code: OpCode,
-    // Function IDs need to be interned _again_ before patched into the code?
-    pub payload_size: u32,
-}
-
-impl DenseInstruction {
-    pub fn new(op_code: OpCode, payload_size: u32) -> DenseInstruction {
-        DenseInstruction {
-            op_code,
-            payload_size,
-        }
-    }
-}
-
-// TODO don't actually pass around the span w/ the instruction
-// pass around an index into the span to reduce the size of the instructions
-// generate an equivalent
-impl From<Instruction> for DenseInstruction {
-    fn from(val: Instruction) -> DenseInstruction {
-        DenseInstruction::new(val.op_code, val.payload_size.try_into().unwrap())
-    }
-}
diff --git a/crates/steel-core/src/core/labels.rs b/crates/steel-core/src/core/labels.rs
deleted file mode 100644
index ff2b97da2..000000000
--- a/crates/steel-core/src/core/labels.rs
+++ /dev/null
@@ -1,114 +0,0 @@
-use serde::{Deserialize, Serialize};
-use steel_parser::ast::ExprKind;
-
-use super::instructions::Instruction;
-use super::opcode::OpCode;
-use crate::parser::parser::SyntaxObject;
-
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-pub(crate) static LABEL_ID: AtomicUsize = AtomicUsize::new(0);
-
-#[derive(Clone, Copy, Debug, PartialEq, Hash, Eq)]
-pub struct Label(usize);
-
-pub fn fresh() -> Label {
-    Label(LABEL_ID.fetch_add(1, Ordering::Relaxed))
-}
-
-#[derive(Clone, Serialize, Deserialize, Debug, PartialEq)]
-pub enum Expr {
-    Atom(SyntaxObject),
-    List(ExprKind),
-}
-
-#[derive(Clone, Debug)]
-pub struct LabeledInstruction {
-    pub op_code: OpCode,
-    pub payload_size: usize,
-    pub contents: Option<Expr>,
-    pub tag: Option<Label>,
-    pub goto: Option<Label>,
-    pub constant: bool,
-}
-
-impl LabeledInstruction {
-    pub fn builder(op_code: OpCode) -> Self {
-        Self {
-            op_code,
-            payload_size: 0,
-            contents: None,
-            tag: None,
-            goto: None,
-            constant: false,
-        }
-    }
-
-    pub fn payload(mut self, payload_size: usize) -> Self {
-        self.payload_size = payload_size;
-        self
-    }
-
-    pub fn contents(mut self, contents: SyntaxObject) -> Self {
-        self.contents = Some(Expr::Atom(contents));
-        self
-    }
-
-    pub fn list_contents(mut self, contents: ExprKind) -> Self {
-        self.contents = Some(Expr::List(contents));
-        self
-    }
-
-    pub fn tag(mut self, tag: Label) -> Self {
-        self.tag = Some(tag);
-        self
-    }
-
-    pub fn goto(mut self, goto: Label) -> Self {
-        self.goto = Some(goto);
-        self
-    }
-
-    pub fn constant(mut self, constant: bool) -> Self {
-        self.constant = constant;
-        self
-    }
-
-    pub fn set_goto(&mut self, goto: Label) {
-        self.goto = Some(goto);
-    }
-
-    pub fn set_tag(&mut self, tag: Label) {
-        self.tag = Some(tag);
-    }
-}
-
-pub fn resolve_labels(instructions: Vec<LabeledInstruction>) -> Vec<Instruction> {
-    // TODO: Come back to this
-    // let label_map = instructions
-    //     .iter()
-    //     .enumerate()
-    //     // We want a map of label -> index, flip the incoming
-    //     .filter_map(|x| x.1.tag.map(|t| (t, x.0)))
-    //     .collect::<HashMap<Label, usize>>();
-
-    // dbg!(&label_map);
-
-    instructions
-        .into_iter()
-        .map(|x| {
-            // If this is an instruction with a jump of some kind to a label
-            // Resolve that here
-            // if let Some(label_goto) = x.goto {
-            //     // println!("Instruction: {x:#?}");
-            //     x.payload_size = label_map[&label_goto]
-            // }
-
-            Instruction {
-                op_code: x.op_code,
-                payload_size: x.payload_size,
-                contents: x.contents,
-            }
-        })
-        .collect()
-}
diff --git a/crates/steel-core/src/core/mod.rs b/crates/steel-core/src/core/mod.rs
deleted file mode 100644
index 840ae60f7..000000000
--- a/crates/steel-core/src/core/mod.rs
+++ /dev/null
@@ -1,4 +0,0 @@
-pub mod instructions;
-pub mod labels;
-pub mod opcode;
-pub(crate) mod utils;
diff --git a/crates/steel-core/src/core/opcode.rs b/crates/steel-core/src/core/opcode.rs
deleted file mode 100644
index d433112d4..000000000
--- a/crates/steel-core/src/core/opcode.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub use steel_gen::OpCode;
diff --git a/crates/steel-core/src/core/utils.rs b/crates/steel-core/src/core/utils.rs
deleted file mode 100644
index 1ac1413bf..000000000
--- a/crates/steel-core/src/core/utils.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-// Generates a macro that expands to code snippet to do arity checks
-// example usage:
-// arity_check!(length, args, 1);
-// Expands to:
-// if args.len() != 1 {
-//     stop!(ArityMismatch => format!("length expected only one argument, found {}", args.len()))
-// }
-// assert!(args.len() == 1);
-
-macro_rules! arity_check_generator {
-    ($($arity:tt),*) => {
-        macro_rules! arity_check {
-            ($name:tt, $args:expr, 1) => {
-                if $args.len() != 1 {
-                    stop!(ArityMismatch => format!(stringify!($name expected only one argument, found {}), $args.len()))
-                }
-                assert!($args.len() == 1);
-            };
-
-            $ (
-                ($name:tt, $args:expr, $arity) => {
-                    if $args.len() != $arity {
-                        stop!(ArityMismatch => format!(stringify!($name expected two arguments, found {}), $args.len()))
-                    }
-                    assert!($args.len() == $arity);
-                };
-            ) *
-        }
-    }
-}
-
-arity_check_generator!(0, 1, 2, 3, 4, 5, 6, 7, 8);
-
-use std::{cell::RefCell, rc::Rc};
-
-pub(crate) use arity_check;
-
-// Declares a const for a function that takes an immutable slice to the arguments
-// e.g.
-//      declare_const_ref_functions! { LENGTH => length }
-// expands into
-//      const LENGTH: SteelVal = SteelVal::FuncV(length)
-macro_rules! declare_const_ref_functions {
-    ($($name:tt => $func_name:tt),* $(,)? ) => {
-        $ (
-            pub(crate) const $name: SteelVal = SteelVal::FuncV($func_name);
-        ) *
-    }
-}
-
-pub(crate) use declare_const_ref_functions;
-
-// Declares a const for a function that takes an immutable slice to the arguments
-// e.g.
-//      declare_const_mut_ref_functions! { CONS => cons }
-// expands into
-//      const LENGTH: SteelVal = SteelVal::MutFunc(length)
-macro_rules! declare_const_mut_ref_functions {
-    ($($name:tt => $func_name:tt),* $(,)? ) => {
-        $ (
-            pub(crate) const $name: SteelVal = SteelVal::MutFunc($func_name);
-        ) *
-    }
-}
-
-pub(crate) use declare_const_mut_ref_functions;
-
-pub(crate) trait Boxed {
-    fn boxed(self) -> Box<Self>;
-    fn refcounted(self) -> Rc<Self>;
-    fn rc_refcell(self) -> Rc<RefCell<Self>>;
-}
-
-impl<T> Boxed for T {
-    #[inline(always)]
-    fn boxed(self) -> Box<T> {
-        Box::new(self)
-    }
-
-    #[inline(always)]
-    fn refcounted(self) -> Rc<T> {
-        Rc::new(self)
-    }
-
-    #[inline(always)]
-    fn rc_refcell(self) -> Rc<RefCell<T>> {
-        Rc::new(RefCell::new(self))
-    }
-}
diff --git a/crates/steel-core/src/env.rs b/crates/steel-core/src/env.rs
deleted file mode 100644
index 01a528446..000000000
--- a/crates/steel-core/src/env.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use crate::rvals::{Result, SteelVal};
-
-#[allow(unused)]
-#[derive(Debug, Clone)]
-pub struct Env {
-    pub(crate) bindings_vec: Vec<SteelVal>,
-}
-
-impl Env {
-    pub fn extract(&self, idx: usize) -> Option<SteelVal> {
-        self.bindings_vec.get(idx).cloned()
-    }
-
-    /// top level global env has no parent
-    pub fn root() -> Self {
-        Env {
-            bindings_vec: Vec::new(),
-        }
-    }
-
-    // pub fn len(&self) -> usize {
-    //     self.bindings_vec.len()
-    // }
-
-    #[cfg(feature = "dynamic")]
-    pub(crate) fn _print_diagnostics(&self) {
-        for (idx, value) in self.bindings_vec.iter().enumerate() {
-            if let SteelVal::Closure(b) = value {
-                let count = b.call_count();
-                if count > 0 {
-                    println!("Function: {} - Count: {}", idx, b.call_count());
-                }
-            }
-        }
-    }
-
-    /// Search starting from the current environment
-    /// for `idx`, looking through the parent chain in order.
-    ///
-    /// if found, return that value
-    ///
-    /// Otherwise, error with `FreeIdentifier`
-    #[inline(always)]
-    pub fn repl_lookup_idx(&self, idx: usize) -> SteelVal {
-        self.bindings_vec[idx].clone()
-    }
-
-    /// Get the value located at that index
-    pub fn _repl_get_idx(&self, idx: usize) -> &SteelVal {
-        &self.bindings_vec[idx]
-    }
-
-    #[inline]
-    pub fn repl_define_idx(&mut self, idx: usize, val: SteelVal) {
-        if idx < self.bindings_vec.len() {
-            self.bindings_vec[idx] = val;
-        } else {
-            if idx > self.bindings_vec.len() {
-                for _ in 0..(idx - self.bindings_vec.len()) {
-                    self.bindings_vec.push(SteelVal::Void);
-                }
-            }
-
-            self.bindings_vec.push(val);
-            assert_eq!(self.bindings_vec.len() - 1, idx);
-        }
-    }
-
-    pub fn repl_set_idx(&mut self, idx: usize, val: SteelVal) -> Result<SteelVal> {
-        let output = self.bindings_vec[idx].clone();
-        self.bindings_vec[idx] = val;
-        Ok(output)
-    }
-
-    #[inline]
-    pub fn add_root_value(&mut self, idx: usize, val: SteelVal) {
-        // self.bindings_map.insert(idx, val);
-        self.repl_define_idx(idx, val);
-    }
-
-    pub fn roots(&self) -> impl Iterator<Item = &SteelVal> {
-        self.bindings_vec.iter()
-    }
-}
diff --git a/crates/steel-core/src/gc.rs b/crates/steel-core/src/gc.rs
deleted file mode 100644
index abb05f73c..000000000
--- a/crates/steel-core/src/gc.rs
+++ /dev/null
@@ -1,1001 +0,0 @@
-use crate::rerrs::SteelErr;
-use crate::rvals::SteelVal;
-use crate::stop;
-use std::fmt::Pointer;
-use std::rc::Rc;
-use std::sync::atomic::{AtomicUsize, Ordering};
-use std::{ffi::OsStr, fmt};
-use std::{ops::Deref, rc::Weak};
-
-pub static OBJECT_COUNT: AtomicUsize = AtomicUsize::new(0);
-pub(crate) static MAXIMUM_OBJECTS: usize = 50000;
-
-// TODO: Make these available to be
-// type Shared<T> = std::rc::Rc<T>;
-// type SharedMut<T> = std::rc::Rc<std::cell::RefCell<T>>;
-
-// TODO: Consider triomphe for a drop in replacement of Arc
-
-/// Used for automatic detection of ref cycle
-pub enum MaybeWeak<T: Clone> {
-    StrongRef(Gc<T>),
-    WeakRef(Gc<T>),
-}
-
-/// This is simply a newtype around the `Rc` type
-/// When enabled, this allows for complete sandboxing of data types
-/// It does not expose the full functionality of the `Rc` type
-/// but it does allow for some
-#[derive(PartialEq, Eq, Hash, PartialOrd, Ord, Debug)]
-pub struct Gc<T: ?Sized>(pub(crate) Rc<T>);
-
-impl<T: ?Sized> Pointer for Gc<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:p}", self.0)
-    }
-}
-
-/// Newtype around the `Weak` type.
-/// Enables the detection of reference cycles in mutable memory locations
-pub struct WeakGc<T>(Weak<T>);
-
-impl fmt::Display for Gc<SteelVal> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl fmt::Display for Gc<String> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-pub fn get_object_count() -> usize {
-    OBJECT_COUNT.fetch_add(0, Ordering::SeqCst)
-}
-
-impl<T: Clone> Gc<T> {
-    /// Deep clone the object to remove it from the GC
-    pub fn unwrap(&self) -> T {
-        (*self.0).clone()
-    }
-
-    pub fn make_mut(&mut self) -> &mut T {
-        Rc::make_mut(&mut self.0)
-    }
-}
-
-impl<T> Gc<T> {
-    // in order to fully sandbox, I have to check the memory limit
-    pub fn new(val: T) -> Gc<T> {
-        // OBJECT_COUNT.fetch_add(1, Ordering::SeqCst);
-        Gc(Rc::new(val))
-    }
-
-    pub fn try_new(val: T) -> Result<Gc<T>, SteelErr> {
-        let mem: usize = OBJECT_COUNT.fetch_add(1, Ordering::SeqCst);
-        if mem > MAXIMUM_OBJECTS {
-            stop!(Generic => "ran out of memory!")
-        }
-        Ok(Gc(Rc::new(val)))
-    }
-
-    pub fn checked_allocate(allocations: usize) -> Result<(), SteelErr> {
-        let mem: usize = OBJECT_COUNT.fetch_add(0, Ordering::SeqCst);
-        if mem + allocations > MAXIMUM_OBJECTS {
-            stop!(Generic => "allocation would exceed maximum allowed memory")
-        }
-        Ok(())
-    }
-
-    pub fn downgrade(this: &Self) -> Weak<T> {
-        Rc::downgrade(&this.0)
-    }
-
-    pub fn get_mut(&mut self) -> Option<&mut T> {
-        Rc::get_mut(&mut self.0)
-    }
-
-    pub fn ptr_eq(this: &Self, other: &Self) -> bool {
-        Rc::ptr_eq(&this.0, &other.0)
-    }
-
-    pub fn as_ptr(&self) -> *const T {
-        Rc::as_ptr(&self.0)
-    }
-
-    pub fn try_unwrap(self) -> Result<T, Gc<T>> {
-        Rc::try_unwrap(self.0).map_err(|x| Gc(x))
-    }
-
-    pub fn strong_count(this: &Self) -> usize {
-        Rc::strong_count(&this.0)
-    }
-
-    // this does not match the original semantics of Rc::try_unwrap
-    // in order to match this, we would need some unsafe rust
-    // instead, I take a _slight_ performance hit in order to
-    // match the original functionality, and the specific use case
-    // for me, which is unwinding lists in the drop for SteelVal
-    // pub fn try_unwrap(this: Self) -> Result<T, SteelErr> {
-    //     let inner = Rc::clone(&this.0);
-    //     drop(this);
-    //     Rc::try_unwrap(inner)
-    //         .map_err(|_| SteelErr::new(ErrorKind::Generic, "value still has reference".to_string()))
-    //     // .map(|x| {
-    //     //     OBJECT_COUNT.fetch_sub(1, Ordering::SeqCst);
-    //     //     x
-    //     // })
-    // }
-
-    pub fn check_memory() -> Result<usize, SteelErr> {
-        let mem: usize = OBJECT_COUNT.fetch_add(0, Ordering::SeqCst);
-        if mem > MAXIMUM_OBJECTS {
-            stop!(Generic => "ran out of memory!")
-        }
-        Ok(mem)
-    }
-}
-
-impl<T> AsRef<T> for Gc<T> {
-    fn as_ref(&self) -> &T {
-        self.0.as_ref()
-    }
-}
-
-impl<T> Deref for Gc<T> {
-    type Target = T;
-    fn deref(&self) -> &T {
-        self.0.deref()
-    }
-}
-
-// impl<T> Drop for Gc<T> {
-//     fn drop(&mut self) {
-//         // println!("Strong count: {}", Rc::strong_count(&self.0));
-
-//         // if Rc::strong_count(&self.0) == 1 {
-//         //     OBJECT_COUNT.fetch_sub(1, Ordering::SeqCst);
-//         // }
-//     }
-// }
-
-impl<T> Clone for Gc<T> {
-    #[inline(always)]
-    fn clone(&self) -> Self {
-        Gc(Rc::clone(&self.0))
-    }
-}
-
-impl AsRef<OsStr> for Gc<String> {
-    fn as_ref(&self) -> &OsStr {
-        self.0.as_ref().as_ref()
-    }
-}
-
-impl From<&str> for Gc<String> {
-    fn from(val: &str) -> Self {
-        Gc::new(val.to_string())
-    }
-}
-
-impl From<String> for Gc<String> {
-    fn from(val: String) -> Self {
-        Gc::new(val)
-    }
-}
-
-impl From<&String> for Gc<String> {
-    fn from(val: &String) -> Self {
-        Gc::new(val.clone())
-    }
-}
-
-impl AsRef<str> for Gc<String> {
-    fn as_ref(&self) -> &str {
-        self.0.as_ref()
-    }
-}
-
-#[cfg(feature = "unsafe-internals")]
-pub mod unsafe_roots {
-
-    use super::Gc;
-    use std::ptr::NonNull;
-
-    #[derive(Clone)]
-    pub enum MaybeRooted<T> {
-        Rooted(Rooted<T>),
-        Reference(Gc<T>),
-    }
-
-    impl<T: std::fmt::Debug> std::fmt::Debug for MaybeRooted<T> {
-        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-            match self {
-                Self::Rooted(v) => write!(f, "{:?}", unsafe { v.value.as_ref() }),
-                Self::Reference(v) => write!(f, "{:?}", v),
-            }
-        }
-    }
-
-    impl<T> MaybeRooted<T> {
-        pub fn from_root(value: &Gc<T>) -> Self {
-            Self::Rooted(Rooted::from_ref(value))
-        }
-    }
-
-    impl<T> AsRef<T> for MaybeRooted<T> {
-        fn as_ref(&self) -> &T {
-            match self {
-                Self::Rooted(v) => unsafe { v.value.as_ref() },
-                Self::Reference(v) => &v,
-            }
-        }
-    }
-
-    impl<T> std::ops::Deref for MaybeRooted<T> {
-        type Target = T;
-
-        fn deref(&self) -> &Self::Target {
-            match self {
-                Self::Rooted(v) => unsafe { v.value.as_ref() },
-                Self::Reference(v) => &v,
-            }
-        }
-    }
-
-    #[derive(Clone)]
-    pub struct Rooted<T> {
-        value: NonNull<T>,
-    }
-
-    impl<T> Rooted<T> {
-        pub fn from_ref(value: &Gc<T>) -> Self {
-            Rooted {
-                value: NonNull::new(Gc::as_ptr(value) as _).expect("Given pointer was null!"),
-            }
-        }
-    }
-
-    #[test]
-    fn test_rooting() {
-        use crate::SteelVal;
-
-        let root = Gc::new(SteelVal::ListV(im_lists::list![]));
-
-        let rooted_reference = Rooted::from_ref(&root);
-
-        println!("{:?}", unsafe { rooted_reference.value.as_ref() });
-    }
-
-    #[test]
-    fn recover_original_gc() {
-        use crate::SteelVal;
-
-        let root = Gc::new(SteelVal::ListV(im_lists::list![]));
-
-        let rooted_reference = Rooted::from_ref(&root);
-
-        let recovered = unsafe { rooted_reference.value.as_ref() };
-
-        println!("{:?}", recovered);
-    }
-}
-
-// #[cfg(feature = "unsafe-internals")]
-#[allow(unused)]
-pub mod unsafe_erased_pointers {
-    /*
-    Warning - here be dragons. Definitely a lot of unsafe things here, and when used incorrectly
-    can lead to undefined behavior.
-    */
-
-    use std::cell::Cell;
-    use std::rc::{Rc, Weak};
-    use std::{any::Any, cell::RefCell, marker::PhantomData};
-
-    use crate::rvals::cycles::IterativeDropHandler;
-    use crate::rvals::AsRefSteelValFromRef;
-    use crate::{rerrs::ErrorKind, rvals::AsRefMutSteelValFromRef, SteelErr, SteelVal};
-
-    // TODO: This needs to be exanded to n args, probably like 8 with a macro
-    pub struct MutableReferenceArena<A, B> {
-        _phantom1: PhantomData<A>,
-        _phantom2: PhantomData<B>,
-    }
-
-    impl<A, B> MutableReferenceArena<A, B> {
-        pub fn new() -> Self {
-            Self {
-                _phantom1: PhantomData,
-                _phantom2: PhantomData,
-            }
-        }
-
-        pub fn retain_reference(
-            &mut self,
-            original_a: &mut A,
-            original_b: &mut B,
-            mut thunk: impl FnMut(
-                BorrowedObject<A>,
-                BorrowedObject<B>,
-            ) -> crate::rvals::Result<SteelVal>,
-        ) -> crate::rvals::Result<SteelVal> {
-            let erased = original_a as *mut _;
-
-            // Wrap the original mutable pointer in an object that respects borrowing
-            // rules for runtime borrow checking
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let borrowed = BorrowedObject::new(weak_ptr);
-
-            let erased2 = original_b as *mut _;
-            let wrapped2 = Rc::new(RefCell::new(erased2));
-            let weak_ptr2 = Rc::downgrade(&wrapped2);
-
-            let borrowed2 = BorrowedObject::new(weak_ptr2);
-
-            thunk(borrowed, borrowed2)
-        }
-    }
-
-    pub struct MutableReferenceNursery<T> {
-        _phantom: PhantomData<T>, // pointers: Vec<Rc<RefCell<*mut T>>>,
-    }
-
-    impl<T> MutableReferenceNursery<T> {
-        pub fn new() -> Self {
-            Self {
-                _phantom: PhantomData, // pointers: Vec::new(),
-            }
-        }
-
-        pub fn retain_readonly_reference(
-            &mut self,
-            original: &T,
-            mut thunk: impl FnMut(ReadOnlyBorrowedObject<T>) -> crate::rvals::Result<SteelVal>,
-        ) -> crate::rvals::Result<SteelVal> {
-            let erased = original as *const _;
-
-            // Wrap the original mutable pointer in an object that respects borrowing
-            // rules for runtime borrow checking
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let borrowed = ReadOnlyBorrowedObject::new(weak_ptr, Rc::new(Cell::new(0)));
-
-            thunk(borrowed)
-        }
-
-        pub fn retain_reference(
-            &mut self,
-            original: &mut T,
-            mut thunk: impl FnMut(BorrowedObject<T>) -> crate::rvals::Result<SteelVal>,
-        ) -> crate::rvals::Result<SteelVal> {
-            let erased = original as *mut _;
-
-            // Wrap the original mutable pointer in an object that respects borrowing
-            // rules for runtime borrow checking
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let borrowed = BorrowedObject::new(weak_ptr);
-
-            thunk(borrowed)
-        }
-
-        // pub(crate) fn wrap_mut_borrow_object(original: &mut T) -> BorrowedObject<T> {
-        //     let erased = original as *mut _;
-
-        //     // Wrap the original mutable pointer in an object that respects borrowing
-        //     // rules for runtime borrow checking
-        //     let wrapped = Rc::new(RefCell::new(erased));
-        //     let weak_ptr = Rc::downgrade(&wrapped);
-
-        //     let borrowed = BorrowedObject { ptr: weak_ptr };
-
-        //     borrowed
-        // }
-    }
-
-    // TODO: Re-evaluate the necessity of this trait. Is it possible to overload it all into one? That could
-    // help disambiguate the function call sites.
-    pub trait CustomReference {
-        fn walk(&self) {}
-    }
-
-    /// Warning - you should not implement this trait yourself. Use the `custom_reference` macro instead.
-    /// Implementing this incorrectly could lead to undefined behavior.
-    pub unsafe trait ReferenceMarker<'a> {
-        type Static: ?Sized + 'static;
-    }
-
-    pub fn type_id<'a, T>() -> std::any::TypeId
-    where
-        T: ReferenceMarker<'a>,
-        T::Static: Any,
-    {
-        std::any::TypeId::of::<T::Static>()
-    }
-
-    #[macro_export]
-    macro_rules! custom_reference {
-        ($t: ident) => {
-            unsafe impl<'a> $crate::gc::unsafe_erased_pointers::ReferenceMarker<'a> for $t {
-                type Static = $t;
-            }
-        };
-
-        ($t: ident<'a>) => {
-            unsafe impl<'a> $crate::gc::unsafe_erased_pointers::ReferenceMarker<'a> for $t<'a> {
-                type Static = $t<'static>;
-            }
-        };
-    }
-
-    // Only works if this is explicitly, a reference type?
-    impl CustomReference for &str {}
-
-    pub trait ReferenceCustomType {
-        fn as_any_ref(&self) -> &dyn Any;
-        fn as_any_ref_mut(&mut self) -> &mut dyn Any;
-        fn name(&self) -> &str {
-            std::any::type_name::<Self>()
-        }
-        fn display(&self) -> std::result::Result<String, std::fmt::Error> {
-            Ok(format!("#<{}>", self.name().to_string()))
-        }
-        fn visit(&self) {}
-        fn drop_mut(&mut self, drop_handler: &mut IterativeDropHandler) {}
-    }
-
-    impl<'a, T: CustomReference + 'static> ReferenceCustomType for T {
-        fn as_any_ref(&self) -> &dyn Any {
-            self as &dyn Any
-        }
-        fn as_any_ref_mut(&mut self) -> &mut dyn Any {
-            self as &mut dyn Any
-        }
-        fn display(&self) -> std::result::Result<String, std::fmt::Error> {
-            // if let Some(formatted) = self.fmt() {
-            //     formatted
-            // } else {
-            Ok(format!("#<{}>", self.name().to_string()))
-            // }
-        }
-        fn visit(&self) {
-            self.walk()
-        }
-    }
-
-    // impl<T: ReferenceCustomType + 'static> IntoSteelVal for T {
-    //     fn into_steelval(self) -> crate::rvals::Result<SteelVal> {
-    //         // Ok(self.new_steel_val())
-    //         Ok(SteelVal::Custom(Rc::new(RefCell::new(Box::new(self)))))
-    //     }
-    // }
-
-    /// This is for objects that are references FROM an already borrowed object.
-    /// In order to make this safe - we create a scoped nursery which ties the lifetime
-    /// of the object to the parent object, and all of those get dropped when the parent lifetime
-    /// ends. This will also mean that allocating references repeatedly will continuously
-    /// fill space in the nursery (at the moment). Once the original reference is done being borrowed,
-    /// we purge the entire nursery. This could cause issues - however for now as a proof
-    /// of concept, we will just treat the nursery as an allocation pool. Gc cycles should be able
-    /// to be run over this pool - just check the amount of weak pointer allocations to each allocation
-    /// and drop those from the vec.
-    pub(crate) struct TemporaryObject<T> {
-        pub(crate) ptr: Rc<RefCell<*mut T>>,
-    }
-
-    // TODO: Probably combine this and the above
-    pub(crate) struct ReadOnlyTemporaryObject<T> {
-        pub(crate) ptr: Rc<RefCell<*const T>>,
-    }
-
-    // Not a reference explicitly. This might contain a reference, but on its own it is a
-    // value type. This should probably only deal with immutable references for now.
-    pub(crate) struct Temporary<T> {
-        pub(crate) ptr: Rc<T>,
-    }
-
-    impl<T> CustomReference for Temporary<T> {}
-    impl<T> CustomReference for TemporaryObject<T> {}
-    impl<T> CustomReference for ReadOnlyTemporaryObject<T> {}
-
-    impl<T: 'static> TemporaryObject<T> {
-        pub fn into_opaque_reference<'a>(self) -> OpaqueReference<'a> {
-            OpaqueReference {
-                inner: Rc::new(self),
-            }
-        }
-    }
-
-    impl<T: 'static> ReadOnlyTemporaryObject<T> {
-        pub fn into_opaque_reference<'a>(self) -> OpaqueReference<'a> {
-            OpaqueReference {
-                inner: Rc::new(self),
-            }
-        }
-    }
-
-    impl<T: 'static> Temporary<T> {
-        pub fn into_opaque_reference<'a>(self) -> OpaqueReference<'a> {
-            OpaqueReference {
-                inner: Rc::new(self),
-            }
-        }
-    }
-
-    pub struct ReadOnlyTemporary<T> {
-        pub(crate) ptr: Weak<T>,
-    }
-
-    impl<T> CustomReference for ReadOnlyTemporary<T> {}
-
-    impl<T> Clone for ReadOnlyTemporary<T> {
-        fn clone(&self) -> Self {
-            Self {
-                ptr: Weak::clone(&self.ptr),
-            }
-        }
-    }
-
-    impl<T: 'static> ReadOnlyTemporary<T> {
-        pub fn into_opaque_reference<'a>(self) -> OpaqueReference<'a> {
-            OpaqueReference {
-                inner: Rc::new(self),
-            }
-        }
-    }
-
-    pub struct ReadOnlyBorrowedObject<T> {
-        pub(crate) ptr: Weak<RefCell<*const T>>,
-        pub(crate) parent_borrow_count: Rc<Cell<BorrowFlag>>,
-    }
-
-    impl<T> CustomReference for ReadOnlyBorrowedObject<T> {}
-
-    impl<T> ReadOnlyBorrowedObject<T> {
-        pub fn new(
-            ptr: Weak<RefCell<*const T>>,
-            parent_borrow_count: Rc<Cell<BorrowFlag>>,
-        ) -> Self {
-            Self {
-                ptr,
-                parent_borrow_count,
-            }
-        }
-    }
-
-    impl<T> Drop for ReadOnlyBorrowedObject<T> {
-        fn drop(&mut self) {
-            self.parent_borrow_count
-                .set(self.parent_borrow_count.get() - 1);
-        }
-    }
-
-    impl<T> Clone for ReadOnlyBorrowedObject<T> {
-        fn clone(&self) -> Self {
-            Self {
-                ptr: Weak::clone(&self.ptr),
-                parent_borrow_count: Rc::clone(&self.parent_borrow_count),
-            }
-        }
-    }
-
-    impl<T: 'static> ReadOnlyBorrowedObject<T> {
-        pub fn into_opaque_reference<'a>(self) -> OpaqueReference<'a> {
-            OpaqueReference {
-                inner: Rc::new(self),
-            }
-        }
-    }
-
-    type BorrowFlag = isize;
-    const UNUSED: BorrowFlag = 0;
-
-    #[inline(always)]
-    fn is_writing(x: BorrowFlag) -> bool {
-        x < UNUSED
-    }
-
-    #[inline(always)]
-    fn is_reading(x: BorrowFlag) -> bool {
-        x > UNUSED
-    }
-
-    pub struct BorrowedObject<T> {
-        pub(crate) ptr: Weak<RefCell<*mut T>>,
-        // TODO: This might need to just be a direct reference to the parent?
-        pub(crate) parent_borrow_flag: Rc<Cell<bool>>,
-        pub(crate) child_borrow_flag: Rc<Cell<bool>>,
-        // TODO:
-        // This really should be the way to do things...
-        pub(crate) borrow_count: Rc<Cell<BorrowFlag>>,
-    }
-
-    impl<T> Drop for BorrowedObject<T> {
-        fn drop(&mut self) {
-            // We're not borrowing anymore, so we can do this
-            self.parent_borrow_flag.set(false);
-        }
-    }
-
-    impl<T> BorrowedObject<T> {
-        pub fn new(ptr: Weak<RefCell<*mut T>>) -> Self {
-            Self {
-                ptr,
-                parent_borrow_flag: Rc::new(Cell::new(false)),
-                child_borrow_flag: Rc::new(Cell::new(false)),
-                borrow_count: Rc::new(Cell::new(0)),
-            }
-        }
-
-        pub fn with_parent_flag(mut self, parent_borrow_flag: Rc<Cell<bool>>) -> Self {
-            self.parent_borrow_flag = parent_borrow_flag;
-
-            self
-        }
-    }
-
-    impl SteelVal {
-        pub(crate) fn get_borrow_flag_if_borrowed_object<T: AsRefMutSteelValFromRef + 'static>(
-            &self,
-        ) -> crate::rvals::Result<Rc<Cell<bool>>> {
-            if let SteelVal::Reference(v) = self {
-                let res = v.inner.as_any_ref();
-
-                if res.is::<BorrowedObject<T>>() {
-                    let borrowed_object = res.downcast_ref::<BorrowedObject<T>>().unwrap();
-
-                    Ok(Rc::clone(&borrowed_object.child_borrow_flag))
-                } else {
-                    let error_message = format!(
-                        "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                        self,
-                        std::any::type_name::<Self>()
-                    );
-                    Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-                }
-            } else {
-                let error_message = format!(
-                    "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                    self,
-                    std::any::type_name::<Self>()
-                );
-
-                Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-            }
-        }
-
-        pub(crate) fn get_borrow_count_if_borrowed_object<T: AsRefMutSteelValFromRef + 'static>(
-            &self,
-        ) -> crate::rvals::Result<Rc<Cell<BorrowFlag>>> {
-            if let SteelVal::Reference(v) = self {
-                let res = v.inner.as_any_ref();
-
-                if res.is::<BorrowedObject<T>>() {
-                    let borrowed_object = res.downcast_ref::<BorrowedObject<T>>().unwrap();
-
-                    Ok(Rc::clone(&borrowed_object.borrow_count))
-                } else {
-                    let error_message = format!(
-                        "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                        self,
-                        std::any::type_name::<Self>()
-                    );
-                    Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-                }
-            } else {
-                let error_message = format!(
-                    "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                    self,
-                    std::any::type_name::<Self>()
-                );
-
-                Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-            }
-        }
-    }
-
-    impl<T> CustomReference for BorrowedObject<T> {}
-
-    impl<'a, T> Clone for BorrowedObject<T> {
-        fn clone(&self) -> Self {
-            Self {
-                ptr: Weak::clone(&self.ptr),
-                parent_borrow_flag: Rc::clone(&self.parent_borrow_flag),
-                child_borrow_flag: Rc::clone(&self.child_borrow_flag),
-                borrow_count: Rc::clone(&self.borrow_count),
-            }
-        }
-    }
-
-    impl<T: 'static> BorrowedObject<T> {
-        pub fn into_opaque_reference<'a>(self) -> OpaqueReference<'a> {
-            OpaqueReference {
-                inner: Rc::new(self),
-            }
-        }
-    }
-
-    pub(crate) trait Opaque {}
-
-    impl<T> Opaque for Rc<RefCell<T>> {}
-
-    // TODO: Use this to chain multiple references together. The engine should be able to accept something
-    // `with_reference` and then have the value be scoped to that lifetime.
-    #[derive(Clone, Default)]
-    pub(crate) struct OpaqueReferenceNursery {
-        // memory: Rc<RefCell<Vec<OpaqueReference<'static>>>>,
-        memory: Rc<RefCell<Vec<Box<dyn Opaque>>>>,
-        weak_values: Rc<RefCell<Vec<OpaqueReference<'static>>>>,
-    }
-
-    thread_local! {
-        static NURSERY: OpaqueReferenceNursery = OpaqueReferenceNursery::new();
-    }
-
-    impl OpaqueReferenceNursery {
-        const DEFAULT_CAPACITY: usize = 8;
-
-        fn new() -> Self {
-            Self {
-                memory: Rc::new(RefCell::new(Vec::with_capacity(Self::DEFAULT_CAPACITY))),
-                weak_values: Rc::new(RefCell::new(Vec::with_capacity(Self::DEFAULT_CAPACITY))),
-            }
-        }
-
-        pub fn tie_lifetime<'a, T>(_: &'a mut T) -> NurseryAccessToken<'a> {
-            NurseryAccessToken {
-                phantom: PhantomData,
-            }
-        }
-
-        // pub(crate) fn allocate_ro_object<T: 'static>
-
-        // Safety - these absolutely need to be the same type.
-        pub(crate) fn allocate_rw_object<'a, T: 'a, EXT: 'static>(obj: &mut T) {
-            let erased = obj as *mut _;
-
-            let erased = unsafe { std::mem::transmute::<*mut T, *mut EXT>(erased) };
-
-            // Wrap the original mutable pointer in an object that respects borrowing
-            // rules for runtime borrow checking
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let borrowed = BorrowedObject::new(weak_ptr);
-
-            NURSERY.with(|x| x.memory.borrow_mut().push(Box::new(wrapped)));
-            NURSERY.with(|x| {
-                x.weak_values
-                    .borrow_mut()
-                    .push(borrowed.into_opaque_reference())
-            });
-        }
-
-        pub(crate) fn allocate_ro_object<'a, T: 'a, EXT: 'static>(obj: &T) {
-            let erased = obj as *const _;
-
-            let erased = unsafe { std::mem::transmute::<*const T, *const EXT>(erased) };
-
-            // Wrap the original mutable pointer in an object that respects borrowing
-            // rules for runtime borrow checking
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let borrowed = ReadOnlyBorrowedObject::new(weak_ptr, Rc::new(Cell::new(0)));
-
-            NURSERY.with(|x| x.memory.borrow_mut().push(Box::new(wrapped)));
-
-            // TODO: Consider doing the transmute in the into_opaque_reference function,
-            // to extend the lifetime, but nowhere else. Could save passing in the double types.
-            NURSERY.with(|x| {
-                x.weak_values
-                    .borrow_mut()
-                    .push(borrowed.into_opaque_reference())
-            });
-        }
-
-        pub(crate) fn allocate(obj: OpaqueReference<'static>) {
-            NURSERY.with(|x| x.weak_values.borrow_mut().push(obj));
-        }
-
-        pub(crate) fn free_all() {
-            NURSERY.with(|x| x.memory.borrow_mut().clear());
-            NURSERY.with(|x| x.weak_values.borrow_mut().clear());
-        }
-
-        pub(crate) fn drain_weak_references_to_steelvals() -> Vec<SteelVal> {
-            let res = NURSERY.with(|x| {
-                x.weak_values
-                    .borrow_mut()
-                    .drain(..)
-                    .map(Rc::new)
-                    .map(SteelVal::Reference)
-                    .collect()
-            });
-
-            // NURSERY.with(|x| x.memory.borrow_mut().clear());
-
-            res
-        }
-    }
-
-    pub struct NurseryAccessToken<'a> {
-        phantom: PhantomData<&'a ()>,
-    }
-
-    impl<'a> NurseryAccessToken<'a> {
-        pub fn allocate(obj: OpaqueReference<'static>) {
-            OpaqueReferenceNursery::allocate(obj)
-        }
-    }
-
-    impl<'a> Drop for NurseryAccessToken<'a> {
-        fn drop(&mut self) {
-            OpaqueReferenceNursery::free_all()
-        }
-    }
-
-    // impl<T> BorrowedObject {
-    //     pub fn borrow_mut()
-    // }
-
-    #[derive(Clone)]
-    pub struct OpaqueReference<'a> {
-        inner: Rc<dyn ReferenceCustomType + 'a>,
-    }
-
-    impl OpaqueReference<'static> {
-        pub fn format(&self) -> std::result::Result<String, std::fmt::Error> {
-            self.display()
-        }
-
-        pub fn drop_mut(&mut self, drop_handler: &mut IterativeDropHandler) {
-            if let Some(inner) = Rc::get_mut(&mut self.inner) {
-                inner.drop_mut(drop_handler);
-            }
-        }
-    }
-
-    impl CustomReference for OpaqueReference<'static> {}
-
-    // TODO: Combine this and the next into 1 trait
-    impl<T: ReferenceCustomType + 'static> AsRefMutSteelValFromRef for T {
-        fn as_mut_ref_from_ref<'a>(val: &'a SteelVal) -> crate::rvals::Result<&'a mut T> {
-            if let SteelVal::Reference(v) = val {
-                let res = v.inner.as_any_ref();
-
-                if res.is::<BorrowedObject<T>>() {
-                    let borrowed_object = res.downcast_ref::<BorrowedObject<T>>().unwrap();
-
-                    if borrowed_object.borrow_count.get() > 0
-                        || borrowed_object.child_borrow_flag.get()
-                    {
-                        stop!(Generic => "Value is already borrowed!")
-                    }
-
-                    let guard = borrowed_object.ptr.upgrade().ok_or_else(
-                        throw!(Generic => "opaque reference pointer dropped before use!"),
-                    );
-
-                    return guard.map(|x| unsafe { &mut *(*x.borrow_mut()) });
-                } else {
-                    let error_message = format!(
-                        "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                        val,
-                        std::any::type_name::<Self>()
-                    );
-                    Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-                }
-            } else {
-                let error_message = format!(
-                    "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                    val,
-                    std::any::type_name::<Self>()
-                );
-
-                Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-            }
-        }
-    }
-
-    impl<T: ReferenceCustomType + 'static> AsRefSteelValFromRef for T {
-        fn as_ref_from_ref<'a>(val: &'a SteelVal) -> crate::rvals::Result<&'a T> {
-            if let SteelVal::Reference(v) = val {
-                let res = v.inner.as_any_ref();
-
-                // TODO: Flatten these conversions - we're doing 2 checks when we only need to do one.
-                if res.is::<ReadOnlyBorrowedObject<T>>() {
-                    let borrowed_object = res.downcast_ref::<ReadOnlyBorrowedObject<T>>().unwrap();
-
-                    // return Ok(borrowed_object.clone());
-
-                    let guard = borrowed_object.ptr.upgrade().ok_or_else(
-                        throw!(Generic => "opaque reference pointer dropped before use!"),
-                    );
-
-                    return guard.map(|x| unsafe { &*(*x.borrow()) });
-                } else if res.is::<ReadOnlyTemporary<T>>() {
-                    let borrowed_object = res.downcast_ref::<ReadOnlyTemporary<T>>().unwrap();
-
-                    // return Ok(borrowed_object.clone());
-
-                    let guard = borrowed_object.ptr.upgrade().ok_or_else(
-                        throw!(Generic => "opaque reference pointer dropped before use!"),
-                    );
-
-                    // TODO: @Matt -> We really do not want to have this here
-                    // The way to fix it is to have a separate trait, with a return type
-                    // more akin to a an owned borrow of some kind (like Ref from borrow() on refcell)
-                    // This is super suspect but we'll move on for now
-                    return guard.map(|x| unsafe { &*(Rc::as_ptr(&x)) });
-                } else {
-                    let error_message = format!(
-                        "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                        val,
-                        std::any::type_name::<Self>()
-                    );
-                    Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-                }
-            } else {
-                let error_message = format!(
-                    "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                    val,
-                    std::any::type_name::<Self>()
-                );
-
-                Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-            }
-        }
-    }
-
-    #[test]
-    fn test() {
-        #[derive(Debug)]
-        struct FooBar {
-            baz: String,
-        }
-
-        struct Baz<'a> {
-            foo_bar: &'a mut FooBar,
-        }
-
-        impl FooBar {
-            fn append_str(&mut self, suffix: &str) {
-                self.baz.push_str(suffix);
-            }
-        }
-        let mut nursery = MutableReferenceNursery::new();
-
-        let mut object = FooBar {
-            baz: "hello world!".to_string(),
-        };
-
-        let mut baz = Baz {
-            foo_bar: &mut object,
-        };
-
-        // HAS to be around the whole time
-        nursery
-            .retain_reference(&mut baz, |erased| unsafe {
-                let guard = erased.ptr.upgrade().unwrap();
-
-                let ref_mut: &mut Baz = &mut *(*guard.borrow_mut());
-
-                ref_mut.foo_bar.append_str("bananas");
-
-                Ok(SteelVal::Void)
-            })
-            .unwrap();
-
-        object.append_str("foobar");
-
-        dbg!(object);
-    }
-}
diff --git a/crates/steel-core/src/jit/code_gen.rs b/crates/steel-core/src/jit/code_gen.rs
deleted file mode 100644
index 83aaa6c98..000000000
--- a/crates/steel-core/src/jit/code_gen.rs
+++ /dev/null
@@ -1,890 +0,0 @@
-#![allow(unused)]
-
-use crate::gc::Gc;
-use crate::jit::ir::*;
-use crate::jit::value::{
-    decode, to_encoded_double, to_encoded_double_from_const_ptr, to_encoded_double_raw,
-};
-use crate::parser::ast::ExprKind;
-// use crate::rvals::ConsCell;
-use crate::SteelVal;
-use cranelift::prelude::types::{F64, I64};
-use cranelift::prelude::*;
-use cranelift_jit::{JITBuilder, JITModule};
-use cranelift_module::{DataContext, Linkage, Module};
-use im_rc::Vector;
-use std::collections::{HashMap, HashSet};
-use std::slice;
-
-// use lazy_static::lazy_static;
-use std::cell::RefCell;
-// use typed_arena::Arena;
-
-use super::lower::lower_function;
-use super::sig::{JitFunctionPointer, Sig};
-use super::value::{encode_bool, from_i32, get_ref_from_double, FALSE_VALUE};
-
-thread_local! {
-    pub static MEMORY: RefCell<Vec<Gc<SteelVal>>> = RefCell::new(Vec::new());
-}
-
-/// The basic JIT class.
-pub struct JIT {
-    /// The function builder context, which is reused across multiple
-    /// FunctionBuilder instances.
-    builder_context: FunctionBuilderContext,
-
-    /// The main Cranelift context, which holds the state for codegen. Cranelift
-    /// separates this from `Module` to allow for parallel compilation, with a
-    /// context per thread, though this isn't in the simple demo here.
-    ctx: codegen::Context,
-
-    /// The data context, which is to data objects what `ctx` is to functions.
-    data_ctx: DataContext,
-
-    /// The module, with the jit backend, which manages the JIT'd
-    /// functions.
-    module: JITModule,
-
-    /// Legal vars - functions that are currently deemed legal to reference
-    legal_vars: HashSet<String>,
-}
-
-unsafe extern "C" fn length(value: f64) -> f64 {
-    let lst = get_ref_from_double(value);
-
-    // todo!()
-
-    // if let SteelVal::Pair(_) = lst {
-    //     let count = SteelVal::iter(lst).count() as isize;
-    // }
-
-    unimplemented!()
-}
-
-unsafe extern "C" fn empty_const() -> f64 {
-    let empty_list = Gc::new(SteelVal::VectorV(Gc::new(Vector::new())));
-    JIT::allocate(&empty_list);
-    to_encoded_double(&empty_list)
-}
-
-// Prints a value used by the compiled code. Our JIT exposes this
-// function to compiled code with the name "print".
-// TODO audit the unsafe
-unsafe extern "C" fn car(value: f64) -> f64 {
-    // let lst: Box<SteelVal> = std::mem::transmute(value);
-
-    todo!()
-
-    // let lst = get_ref_from_double(value);
-
-    // if let SteelVal::Pair(c) = lst {
-    //     let ret_value = &c.car;
-    //     to_encoded_double_raw(ret_value)
-    // } else {
-    //     panic!("car expected a list, found: {:?}", lst);
-    // }
-
-    // unimplemented!()
-}
-
-// TODO implement the cdr and see what happens
-// Safety: The caller must assure that the value being passed in is a reference to
-// a GC value
-unsafe extern "C" fn cdr(value: f64) -> f64 {
-    let lst = get_ref_from_double(value);
-
-    todo!()
-
-    // if let SteelVal::Pair(c) = lst {
-    //     let rest = c.cdr().as_ref().map(Gc::clone);
-
-    //     if let Some(rest) = rest {
-    //         let new_pair = Gc::new(SteelVal::Pair(rest));
-
-    //         // We want to increment the life time of this so that references are valid later
-    //         JIT::allocate(&new_pair);
-
-    //         // println!("cdr output: {:?}", new_pair);
-
-    //         to_encoded_double(&new_pair)
-    //     } else {
-    //         let empty_list = Gc::new(SteelVal::VectorV(Gc::new(Vector::new())));
-    //         JIT::allocate(&empty_list);
-    //         to_encoded_double(&empty_list)
-    //     }
-    // } else {
-    //     panic!("cdr expected a list");
-    // }
-}
-
-// TODO how to do booleans?
-unsafe extern "C" fn empty(l: f64) -> f64 {
-    let lst = decode(l);
-
-    encode_bool(if let SteelVal::VectorV(v) = lst {
-        v.is_empty()
-    } else {
-        false
-    })
-}
-
-// TODO
-// Implement values with a tag to know if they're a primitive or a reference
-// type - would let me not have to register non values in memory
-unsafe extern "C" fn cons(car: f64, cdr: f64) -> f64 {
-    let car = decode(car);
-    let cdr = decode(cdr);
-
-    todo!()
-
-    // match &cdr {
-    //     SteelVal::Pair(cdr) => {
-    //         let new_value = Gc::new(SteelVal::Pair(Gc::new(ConsCell::new(
-    //             car.clone(),
-    //             Some(cdr.clone()),
-    //         ))));
-
-    //         // Register the allocated value so that it lives long enough
-    //         JIT::allocate(&new_value);
-    //         to_encoded_double(&new_value)
-    //     }
-    //     SteelVal::VectorV(l) => {
-    //         let new_value = if l.is_empty() {
-    //             Gc::new(SteelVal::Pair(Gc::new(ConsCell::new(car, None))))
-    //         } else {
-    //             Gc::new(SteelVal::Pair(Gc::new(ConsCell::new(
-    //                 car,
-    //                 Some(Gc::new(ConsCell::new(cdr, None))),
-    //             ))))
-    //         };
-
-    //         JIT::allocate(&new_value);
-    //         to_encoded_double(&new_value)
-    //     }
-    //     _ => panic!(
-    //         "cons requires a list as the second argument, found: {}",
-    //         cdr
-    //     ),
-    // }
-}
-
-unsafe extern "C" fn _equals(left: f64, right: f64) -> f64 {
-    let left = decode(left);
-    let right = decode(right);
-
-    encode_bool(left == right)
-}
-
-unsafe extern "C" fn _less_than_or_equals(left: f64, right: f64) -> f64 {
-    let left = decode(left);
-    let right = decode(right);
-
-    encode_bool(left <= right)
-}
-
-// unsafe extern "C" fn addition(left: f64, right: f64) -> f64 {
-//     let left = decode(left);
-//     let right = decode(right);
-
-//     if let (SteelVal::IntV(l), SteelVal::IntV(r)) = (left, right) {
-//         to_encoded_double(SteelVal::IntV(l + r))
-//     } else {
-//         panic!("Addition expected two numbers")
-//     }
-// }
-
-fn register_primitives(builder: &mut JITBuilder) {
-    let addr: *const u8 = car as *const u8;
-    builder.symbol("car", addr);
-
-    let addr: *const u8 = cdr as *const u8;
-    builder.symbol("cdr", addr);
-
-    let addr: *const u8 = cons as *const u8;
-    builder.symbol("cons", addr);
-
-    let addr: *const u8 = empty as *const u8;
-    builder.symbol("empty?", addr);
-    builder.symbol("null?", addr);
-
-    let addr: *const u8 = empty_const as *const u8;
-    builder.symbol("empty", addr);
-
-    let outer_value = "hello world!";
-
-    // First convert function to this using register function
-    let outer = move |args: &[SteelVal]| -> SteelVal {
-        println!("{}", outer_value);
-        SteelVal::BoolV(false)
-    };
-
-    unsafe extern "C" fn func(x: f64) -> f64 {
-        unimplemented!()
-        // to_encoded_double(decode(x))
-    }
-
-    // How do you take a closure and turn it into something not a closure without macros?
-    // Unique type is unable to be encoded into a JIT callable function
-    let addr: *const u8 = func as *const u8;
-    builder.symbol("external-func", addr);
-}
-
-impl Default for JIT {
-    fn default() -> Self {
-        let mut builder = JITBuilder::new(cranelift_module::default_libcall_names()).unwrap();
-
-        register_primitives(&mut builder);
-
-        let module = JITModule::new(builder);
-
-        let mut output = Self {
-            builder_context: FunctionBuilderContext::new(),
-            ctx: module.make_context(),
-            data_ctx: DataContext::new(),
-            module,
-            legal_vars: HashSet::new(),
-        };
-
-        output.register_primitives();
-        output
-    }
-}
-
-impl JIT {
-    // Wipes out the memory stores in the typed area
-    pub fn new() -> Self {
-        JIT::free();
-        Self::default()
-    }
-
-    // Wipe out the memory
-    pub fn free() {
-        MEMORY.with(|x| {
-            *x.borrow_mut() = Vec::new();
-        });
-    }
-
-    // Keep track of the refs that get heap allocated
-    pub(crate) fn allocate(value: &Gc<SteelVal>) {
-        MEMORY.with(|x| x.borrow_mut().push(Gc::clone(value)))
-    }
-
-    fn register_primitives(&mut self) {
-        self.register_symbol("car");
-        self.register_symbol("cdr");
-        self.register_symbol("cons");
-        self.register_symbol("empty?");
-        self.register_symbol("null?");
-        self.register_symbol("empty");
-    }
-
-    fn register_symbol(&mut self, name: &str) {
-        // println!("Registering function: {}", name);
-
-        self.legal_vars.insert(name.to_string());
-    }
-
-    // pub unsafe fn compile_and_transmute(
-    //     &mut self,
-    //     input: &ExprKind,
-    //     sig: Sig,
-    // ) -> Result, String> {
-    //     let code_ptr = self.compile(input)?;
-    //     let code_fn = std::mem::transmute::<_, T>(code_ptr);
-    //     Ok(code_fn)
-    // }
-
-    /// Compile a string in the toy language into machine code.
-    pub fn compile(&mut self, input: &ExprKind) -> Result<JitFunctionPointer, String> {
-        // TOOD lift this out of this function
-        // let mut legal_vars = HashSet::new();
-
-        // Register the functions that are legal to reference inside the machine code
-        // legal_vars.insert("car".to_string());
-        // legal_vars.insert("cdr".to_string());
-        // legal_vars.insert("cons".to_string());
-        // legal_vars.insert("empty?".to_string());
-        // legal_vars.insert("null?".to_string());
-
-        // First, parse the string, producing AST nodes.
-        let (name, params, the_return, stmts) = lower_function(input, &mut self.legal_vars)
-            .ok_or_else(|| "Unable to lower the input AST".to_string())?;
-        // type_check_please(&input).map_err(|e| e.to_string())?;
-
-        // Get the arity from the number of parameters of the function we're compiling
-        let arity = Sig::from_usize(params.len());
-
-        println!("Function name: {}", name);
-        println!("Params: {:?}", params);
-        // println!("Return value: {}", the_return);
-        // println!("Statements: {:?}", stmts);
-
-        // Then, translate the AST nodes into Cranelift IR.
-        self.translate(params, the_return, stmts)?;
-
-        println!("\n\n{}\n\n", self.ctx.func);
-
-        // Next, declare the function to jit. Functions must be declared
-        // before they can be called, or defined.
-        //
-        // TODO: This may be an area where the API should be streamlined; should
-        // we have a version of `declare_function` that automatically declares
-        // the function?
-        let id = self
-            .module
-            .declare_function(&name, Linkage::Export, &self.ctx.func.signature)
-            .map_err(|e| e.to_string())?;
-
-        // println!("Made it here!");
-
-        // Define the function to jit. This finishes compilation, although
-        // there may be outstanding relocations to perform. Currently, jit
-        // cannot finish relocations until all functions to be called are
-        // defined. For this toy demo for now, we'll just finalize the
-        // function below.
-        self.module
-            .define_function(id, &mut self.ctx)
-            .map_err(|e| {
-                println!("{:?}", e);
-                e.to_string()
-            })?;
-
-        // println!("Defined function!");
-
-        // Now that compilation is finished, we can clear out the context state.
-        self.module.clear_context(&mut self.ctx);
-
-        // Finalize the functions which we just defined, which resolves any
-        // outstanding relocations (patching in addresses, now that they're
-        // available).
-        self.module.finalize_definitions();
-
-        // We can now retrieve a pointer to the machine code.
-        let code = self.module.get_finalized_function(id);
-
-        // This _is_ a legal function now after the function is finalized
-        self.register_symbol(&name);
-
-        Ok(JitFunctionPointer::new(arity, code))
-    }
-
-    /// Create a zero-initialized data section.
-    pub fn create_data(&mut self, name: &str, contents: Vec<u8>) -> Result<&[u8], String> {
-        // The steps here are analogous to `compile`, except that data is much
-        // simpler than functions.
-        self.data_ctx.define(contents.into_boxed_slice());
-        let id = self
-            .module
-            .declare_data(name, Linkage::Export, true, false)
-            .map_err(|e| e.to_string())?;
-
-        self.module
-            .define_data(id, &self.data_ctx)
-            .map_err(|e| e.to_string())?;
-        self.data_ctx.clear();
-        self.module.finalize_definitions();
-        let buffer = self.module.get_finalized_data(id);
-        // TODO: Can we move the unsafe into cranelift?
-        Ok(unsafe { slice::from_raw_parts(buffer.0, buffer.1) })
-    }
-
-    // Translate from toy-language AST nodes into Cranelift IR.
-    fn translate(
-        &mut self,
-        params: Vec<String>,
-        the_return: String,
-        stmts: Vec<Expr>,
-    ) -> Result<(), String> {
-        // Our toy language currently only supports I64 values, though Cranelift
-        // supports other types.
-        // TODO come back to this to figure out the best way to handle different targets
-        // let int = self.module.target_config().pointer_type();
-
-        let int = F64;
-
-        for _p in &params {
-            self.ctx.func.signature.params.push(AbiParam::new(int));
-        }
-
-        // Our toy language currently only supports one return value, though
-        // Cranelift is designed to support more.
-        self.ctx.func.signature.returns.push(AbiParam::new(int));
-
-        println!("Function signature: {:?}", self.ctx.func.signature);
-
-        // Create the builder to build a function.
-        let mut builder = FunctionBuilder::new(&mut self.ctx.func, &mut self.builder_context);
-
-        // Create the entry block, to start emitting code in.
-        let entry_block = builder.create_block();
-
-        // Since this is the entry block, add block parameters corresponding to
-        // the function's parameters.
-        //
-        // TODO: Streamline the API here.
-        builder.append_block_params_for_function_params(entry_block);
-
-        // Tell the builder to emit code in this block.
-        builder.switch_to_block(entry_block);
-
-        // And, tell the builder that this block will have no further
-        // predecessors. Since it's the entry block, it won't have any
-        // predecessors.
-        builder.seal_block(entry_block);
-
-        // The toy language allows variables to be declared implicitly.
-        // Walk the AST and declare all implicitly-declared variables.
-        let variables =
-            declare_variables(int, &mut builder, &params, &the_return, &stmts, entry_block);
-
-        // Now translate the statements of the function body.
-        let mut trans = FunctionTranslator {
-            int,
-            builder,
-            variables,
-            module: &mut self.module,
-        };
-        for expr in stmts {
-            trans.translate_expr(expr);
-        }
-
-        // Set up the return variable of the function. Above, we declared a
-        // variable to hold the return value. Here, we just do a use of that
-        // variable.
-        let return_variable = trans.variables.get(&the_return).unwrap();
-        let return_value = trans.builder.use_var(*return_variable);
-
-        // Emit the return instruction.
-        trans.builder.ins().return_(&[return_value]);
-
-        // Tell the builder we're done with this function.
-        trans.builder.finalize();
-
-        // debug out what we can at this point
-        // println!("\n{}", trans.builder.display(trans.module.isa()));
-
-        Ok(())
-    }
-}
-
-/// A collection of state used for translating from toy-language AST nodes
-/// into Cranelift IR.
-struct FunctionTranslator<'a> {
-    int: types::Type,
-    builder: FunctionBuilder<'a>,
-    variables: HashMap<String, Variable>,
-    module: &'a mut JITModule,
-}
-
-impl<'a> FunctionTranslator<'a> {
-    // Comes in as a float
-    // This unboxes the value first by applying the bitwise and
-    // then casting to an int
-    fn decode_float_to_int(&mut self, value: Value) -> Value {
-        let bitmask: i64 = unsafe { std::mem::transmute(!super::value::INT32_TAG) };
-        let cast = self.builder.ins().bitcast(I64, value);
-        self.builder.ins().band_imm(cast, bitmask)
-    }
-
-    // TODO
-    // currently decode float to int just takes an encoded value and blindly decodes to an integer
-    fn decode_float_or_steelval_to_int(&mut self, value: Value) -> Value {
-        // let bitmask
-        unimplemented!()
-    }
-
-    // fn decode_bool(&mut self, value: Value) -> Value {
-    //     self.builder.ins().isub_imm()
-    // }
-
-    // This takes in an int, then applies the bitwise and
-    // then we cast this to a float when we're done
-    fn encode_int_to_float(&mut self, value: Value) -> Value {
-        let bitmask: i64 = unsafe { std::mem::transmute(super::value::INT32_TAG) };
-        let encoded_int = self.builder.ins().bor_imm(value, bitmask);
-        self.builder.ins().bitcast(F64, encoded_int)
-    }
-
-    /// When you write out instructions in Cranelift, you get back `Value`s. You
-    /// can then use these references in other instructions.
-    fn translate_expr(&mut self, expr: Expr) -> Value {
-        match expr {
-            Expr::Literal(literal) => {
-                let imm: i32 = literal.parse().unwrap();
-                // Literal needs to be encoded as an int first
-                // let value = self.builder.ins().iconst(self.int, i64::from(imm));
-
-                // let value = self.builder.ins().iconst(I64, i64::from(imm));
-
-                // println!("Encoding literal: {}", imm);
-                // self.encode_int_to_float(value)
-
-                let encoded = from_i32(imm);
-                self.builder.ins().f64const(encoded)
-            }
-
-            Expr::Add(lhs, rhs) => {
-                let lhs = self.translate_expr(*lhs);
-                let rhs = self.translate_expr(*rhs);
-
-                println!("About to decode the floats to ints");
-
-                let decoded_lhs = self.decode_float_to_int(lhs);
-                let decoded_rhs = self.decode_float_to_int(rhs);
-
-                println!("Finished decoding ints");
-                // println!("Successfully decoded ")
-
-                // let output = self.builder.ins().iadd(lhs, rhs);
-                let output = self.builder.ins().iadd(decoded_lhs, decoded_rhs);
-
-                println!("Generated add instruction");
-
-                let output = self.encode_int_to_float(output);
-
-                println!("Encoding the result back to a float");
-
-                output
-
-                // self.builder.ins().xo
-            }
-
-            Expr::Sub(lhs, rhs) => {
-                let lhs = self.translate_expr(*lhs);
-                let rhs = self.translate_expr(*rhs);
-
-                let decoded_lhs = self.decode_float_to_int(lhs);
-                let decoded_rhs = self.decode_float_to_int(rhs);
-
-                let output = self.builder.ins().isub(decoded_lhs, decoded_rhs);
-
-                self.encode_int_to_float(output)
-                // let output = self.
-
-                // self.builder.ins().isub(lhs, rhs)
-            }
-
-            Expr::Mul(lhs, rhs) => {
-                let lhs = self.translate_expr(*lhs);
-                let rhs = self.translate_expr(*rhs);
-                self.builder.ins().imul(lhs, rhs)
-            }
-
-            Expr::Div(lhs, rhs) => {
-                let lhs = self.translate_expr(*lhs);
-                let rhs = self.translate_expr(*rhs);
-                self.builder.ins().udiv(lhs, rhs)
-            }
-
-            Expr::Eq(lhs, rhs) => self.translate_icmp(IntCC::Equal, *lhs, *rhs),
-            Expr::Ne(lhs, rhs) => self.translate_icmp(IntCC::NotEqual, *lhs, *rhs),
-            Expr::Lt(lhs, rhs) => self.translate_icmp(IntCC::SignedLessThan, *lhs, *rhs),
-
-            Expr::Le(lhs, rhs) => self.translate_icmp(IntCC::SignedLessThanOrEqual, *lhs, *rhs),
-            // Expr::Le(lhs, rhs) => {
-            //     // self.translate_call("<=".to_string(), vec![*lhs, *rhs])
-            //     self.translate_icmp(IntCC::SignedLessThanOrEqual, *lhs, *rhs)
-            // }
-            Expr::Gt(lhs, rhs) => self.translate_icmp(IntCC::SignedGreaterThan, *lhs, *rhs),
-            Expr::Ge(lhs, rhs) => self.translate_icmp(IntCC::SignedGreaterThanOrEqual, *lhs, *rhs),
-
-            Expr::Call(name, args) => self.translate_call(name, args),
-            Expr::GlobalDataAddr(name) => self.translate_global_data_addr(name),
-            Expr::Identifier(name) => {
-                // `use_var` is used to read the value of a variable.
-                let variable = self.variables.get(&name).expect("variable not defined");
-                self.builder.use_var(*variable)
-            }
-            Expr::Assign(name, expr) => self.translate_assign(name, *expr),
-            Expr::IfElse(condition, then_body, else_body) => {
-                self.translate_if_else(*condition, then_body, else_body)
-            }
-            Expr::WhileLoop(condition, loop_body) => {
-                self.translate_while_loop(*condition, loop_body)
-            }
-            Expr::Block(body) => self.translate_block(body),
-        }
-    }
-
-    fn translate_assign(&mut self, name: String, expr: Expr) -> Value {
-        // `def_var` is used to write the value of a variable. Note that
-        // variables can have multiple definitions. Cranelift will
-        // convert them into SSA form for itself automatically.
-        let new_value = self.translate_expr(expr);
-        let variable = self.variables.get(&name).unwrap();
-        self.builder.def_var(*variable, new_value);
-        new_value
-    }
-
-    // icmp needs to keep track of the value
-    // TODO remove using icmp
-    fn translate_icmp(&mut self, cmp: IntCC, lhs: Expr, rhs: Expr) -> Value {
-        let lhs = self.translate_expr(lhs);
-        let rhs = self.translate_expr(rhs);
-
-        let encoded_lhs = self.decode_float_to_int(lhs);
-        let encoded_rhs = self.decode_float_to_int(rhs);
-
-        let c = self.builder.ins().icmp(cmp, encoded_lhs, encoded_rhs);
-
-        // self.builder.ins().bint(IntTo, x)
-        // let encoded = self.builder.ins.icmp(c)
-
-        let one_or_zero = self.builder.ins().bint(I64, c);
-
-        // Encode the resulting value back to the encoded constant
-        let int_bool = self.builder.ins().iadd_imm(one_or_zero, FALSE_VALUE as i64);
-        self.builder.ins().bitcast(F64, int_bool)
-    }
-
-    // Translate a block of instructions
-    fn translate_block(&mut self, expr_block: Vec<Expr>) -> Value {
-        let block = self.builder.create_block();
-
-        // self.builder.append_block_param(block, self.int);
-
-        self.builder.append_block_params_for_function_params(block);
-
-        // self.builder.switch_to_block(block);
-        self.builder.seal_block(block);
-        // TODO
-        // let mut block_return = self.builder.ins().iconst(self.int, 0);
-
-        let mut block_return = self.builder.ins().f64const(0.0);
-        for expr in expr_block {
-            block_return = self.translate_expr(expr)
-        }
-        // block_return
-        // self.builder.block_params(block)[0]
-        block_return
-    }
-
-    fn translate_if_else(
-        &mut self,
-        condition: Expr,
-        then_body: Vec<Expr>,
-        else_body: Vec<Expr>,
-    ) -> Value {
-        let condition_value = self.translate_expr(condition);
-        // Cast this back from a float to an int
-        let decoded_value = self.builder.ins().bitcast(I64, condition_value);
-        // let encoded_condition = self.decode_float_to_int(condition_value);
-
-        // Decode the condition - translate whatever value we have back to 0
-        // The _only_ value that will give us false here, is the FALSE_VALUE constant
-        let condition_value = self
-            .builder
-            .ins()
-            .iadd_imm(decoded_value, -(FALSE_VALUE as i64));
-
-        // TODO insert way to decode value from boolean to value cranelift can understand?
-
-        let then_block = self.builder.create_block();
-        let else_block = self.builder.create_block();
-        let merge_block = self.builder.create_block();
-
-        // If-else constructs in the toy language have a return value.
-        // In traditional SSA form, this would produce a PHI between
-        // the then and else bodies. Cranelift uses block parameters,
-        // so set up a parameter in the merge block, and we'll pass
-        // the return values to it from the branches.
-        self.builder.append_block_param(merge_block, self.int);
-
-        // Test the if condition and conditionally branch.
-        self.builder.ins().brz(condition_value, else_block, &[]);
-        // Fall through to then block.
-        self.builder.ins().jump(then_block, &[]);
-
-        self.builder.switch_to_block(then_block);
-        self.builder.seal_block(then_block);
-        // let mut then_return = self.builder.ins().iconst(self.int, 0);
-
-        let mut then_return = self.builder.ins().f64const(0.0);
-        for expr in then_body {
-            then_return = self.translate_expr(expr);
-        }
-
-        // Jump to the merge block, passing it the block return value.
-        self.builder.ins().jump(merge_block, &[then_return]);
-
-        self.builder.switch_to_block(else_block);
-        self.builder.seal_block(else_block);
-        // let mut else_return = self.builder.ins().iconst(self.int, 0);
-
-        let mut else_return = self.builder.ins().f64const(0.0);
-        for expr in else_body {
-            else_return = self.translate_expr(expr);
-        }
-
-        // Jump to the merge block, passing it the block return value.
-        self.builder.ins().jump(merge_block, &[else_return]);
-
-        // Switch to the merge block for subsequent statements.
-        self.builder.switch_to_block(merge_block);
-
-        // We've now seen all the predecessors of the merge block.
-        self.builder.seal_block(merge_block);
-
-        // Read the value of the if-else by reading the merge block
-        // parameter.
-        let phi = self.builder.block_params(merge_block)[0];
-
-        phi
-    }
-
-    fn translate_while_loop(&mut self, condition: Expr, loop_body: Vec<Expr>) -> Value {
-        let header_block = self.builder.create_block();
-        let body_block = self.builder.create_block();
-        let exit_block = self.builder.create_block();
-
-        self.builder.ins().jump(header_block, &[]);
-        self.builder.switch_to_block(header_block);
-
-        let condition_value = self.translate_expr(condition);
-        self.builder.ins().brz(condition_value, exit_block, &[]);
-        self.builder.ins().jump(body_block, &[]);
-
-        self.builder.switch_to_block(body_block);
-        self.builder.seal_block(body_block);
-
-        for expr in loop_body {
-            self.translate_expr(expr);
-        }
-        self.builder.ins().jump(header_block, &[]);
-
-        self.builder.switch_to_block(exit_block);
-
-        // We've reached the bottom of the loop, so there will be no
-        // more backedges to the header to exits to the bottom.
-        self.builder.seal_block(header_block);
-        self.builder.seal_block(exit_block);
-
-        // Just return 0 for now.
-        self.builder.ins().iconst(self.int, 0)
-    }
-
-    fn translate_call(&mut self, name: String, args: Vec<Expr>) -> Value {
-        let mut sig = self.module.make_signature();
-
-        // Add a parameter for each argument.
-        for _arg in &args {
-            sig.params.push(AbiParam::new(self.int));
-        }
-
-        // For simplicity for now, just make all calls return a single I64.
-        sig.returns.push(AbiParam::new(self.int));
-
-        // TODO: Streamline the API here?
-        let callee = self
-            .module
-            .declare_function(&name, Linkage::Import, &sig)
-            .expect("problem declaring function");
-        let local_callee = self
-            .module
-            .declare_func_in_func(callee, &mut self.builder.func);
-
-        let mut arg_values = Vec::new();
-        for arg in args {
-            arg_values.push(self.translate_expr(arg))
-        }
-        let call = self.builder.ins().call(local_callee, &arg_values);
-        self.builder.inst_results(call)[0]
-    }
-
-    fn translate_global_data_addr(&mut self, name: String) -> Value {
-        let sym = self
-            .module
-            .declare_data(&name, Linkage::Export, true, false)
-            .expect("problem declaring data object");
-        let local_id = self
-            .module
-            .declare_data_in_func(sym, &mut self.builder.func);
-
-        let pointer = self.module.target_config().pointer_type();
-        self.builder.ins().symbol_value(pointer, local_id)
-    }
-}
-
-fn declare_variables(
-    int: types::Type,
-    builder: &mut FunctionBuilder,
-    params: &[String],
-    the_return: &str,
-    stmts: &[Expr],
-    entry_block: Block,
-) -> HashMap<String, Variable> {
-    let mut variables = HashMap::new();
-    let mut index = 0;
-
-    for (i, name) in params.iter().enumerate() {
-        // TODO: cranelift_frontend should really have an API to make it easy to set
-        // up param variables.
-        let val = builder.block_params(entry_block)[i];
-        let var = declare_variable(int, builder, &mut variables, &mut index, name);
-        builder.def_var(var, val);
-    }
-    let zero = builder.ins().f64const(0.0);
-    let return_variable = declare_variable(int, builder, &mut variables, &mut index, the_return);
-    builder.def_var(return_variable, zero);
-    for expr in stmts {
-        declare_variables_in_stmt(int, builder, &mut variables, &mut index, expr);
-    }
-
-    variables
-}
-
-/// Recursively descend through the AST, translating all implicit
-/// variable declarations.
-fn declare_variables_in_stmt(
-    int: types::Type,
-    builder: &mut FunctionBuilder,
-    variables: &mut HashMap<String, Variable>,
-    index: &mut usize,
-    expr: &Expr,
-) {
-    match *expr {
-        Expr::Assign(ref name, ref expr) => {
-            declare_variable(int, builder, variables, index, name);
-            // Declare variables on the right hand side as well
-            declare_variables_in_stmt(int, builder, variables, index, expr);
-        }
-        Expr::IfElse(ref _condition, ref then_body, ref else_body) => {
-            for stmt in then_body {
-                declare_variables_in_stmt(int, builder, variables, index, &stmt);
-            }
-            for stmt in else_body {
-                declare_variables_in_stmt(int, builder, variables, index, &stmt);
-            }
-        }
-        Expr::WhileLoop(ref _condition, ref loop_body) => {
-            for stmt in loop_body {
-                declare_variables_in_stmt(int, builder, variables, index, &stmt);
-            }
-        }
-        Expr::Block(ref body) => {
-            for stmt in body {
-                declare_variables_in_stmt(int, builder, variables, index, &stmt);
-            }
-        }
-        _ => (),
-    }
-}
-
-/// Declare a single variable declaration.
-fn declare_variable(
-    int: types::Type,
-    builder: &mut FunctionBuilder,
-    variables: &mut HashMap<String, Variable>,
-    index: &mut usize,
-    name: &str,
-) -> Variable {
-    println!("Declaring: {}", name);
-    let var = Variable::new(*index);
-    if !variables.contains_key(name) {
-        variables.insert(name.into(), var);
-        builder.declare_var(var, int);
-        *index += 1;
-    }
-    var
-}
diff --git a/crates/steel-core/src/jit/ir.rs b/crates/steel-core/src/jit/ir.rs
deleted file mode 100644
index 0e1eb8fc4..000000000
--- a/crates/steel-core/src/jit/ir.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-use std::collections::HashMap;
-
-/// The AST node for expressions.
-#[derive(Clone, Debug)]
-pub enum Expr {
-    Literal(String),
-    Identifier(String),
-    Assign(String, Box<Expr>),
-    Eq(Box<Expr>, Box<Expr>),
-    Ne(Box<Expr>, Box<Expr>),
-    Lt(Box<Expr>, Box<Expr>),
-    Le(Box<Expr>, Box<Expr>),
-    Gt(Box<Expr>, Box<Expr>),
-    Ge(Box<Expr>, Box<Expr>),
-    Add(Box<Expr>, Box<Expr>),
-    Sub(Box<Expr>, Box<Expr>),
-    Mul(Box<Expr>, Box<Expr>),
-    Div(Box<Expr>, Box<Expr>),
-    IfElse(Box<Expr>, Vec<Expr>, Vec<Expr>),
-    WhileLoop(Box<Expr>, Vec<Expr>),
-    Call(String, Vec<Expr>),
-    GlobalDataAddr(String),
-    Block(Vec<Expr>),
-}
-
-/// The type representing JIT level operations
-/// Given an input type
-#[derive(Clone, Debug, Copy, PartialEq)]
-pub enum JitType {
-    Float,
-    Int,
-    List,
-    Bool,
-    Void,
-    Any,
-}
-
-#[derive(Clone, Debug)]
-pub struct JitFunctionSignature {
-    arguments: Vec<JitType>,
-    return_value: JitType,
-}
-
-impl JitFunctionSignature {
-    pub fn new(arguments: Vec<JitType>, return_value: JitType) -> Self {
-        Self {
-            arguments,
-            return_value,
-        }
-    }
-}
-
-pub enum TypedExpr {
-    Literal(String, JitType),
-    Identifier(String),
-    Equal(Box<TypedExpr>, Box<TypedExpr>),
-    Add(Box<TypedExpr>, Box<TypedExpr>),
-    Sub(Box<TypedExpr>, Box<TypedExpr>),
-    Mul(Box<TypedExpr>, Box<TypedExpr>),
-    LtE(Box<TypedExpr>, Box<TypedExpr>),
-    IfElse(Box<TypedExpr>, Vec<TypedExpr>, Vec<TypedExpr>),
-    Call(String, Vec<TypedExpr>),
-}
-
-pub fn typecheck(
-    expr: &TypedExpr,
-    bindings: &mut HashMap<String, JitType>,
-    functions: &HashMap<String, JitFunctionSignature>,
-) -> JitType {
-    match expr {
-        TypedExpr::Literal(_, ty) => *ty,
-        TypedExpr::Identifier(name) => bindings
-            .get(name)
-            .copied()
-            .expect(format!("Free Identifier: {}", name).as_str()),
-        TypedExpr::Equal(_, _) | TypedExpr::LtE(_, _) => JitType::Bool,
-        TypedExpr::Add(left, right) | TypedExpr::Sub(left, right) | TypedExpr::Mul(left, right) => {
-            let left_type = typecheck(left, bindings, functions);
-            let right_type = typecheck(right, bindings, functions);
-            if let (JitType::Int, JitType::Int) = (left_type, right_type) {
-                JitType::Int
-            } else {
-                JitType::Any
-            }
-        }
-        TypedExpr::IfElse(_, then_expr, else_expr) => {
-            let then_type = then_expr
-                .iter()
-                .map(|then_expr| typecheck(then_expr, bindings, functions))
-                .last()
-                .expect("Empty then expression");
-            let else_type = else_expr
-                .iter()
-                .map(|else_expr| typecheck(else_expr, bindings, functions))
-                .last()
-                .expect("Empty else expression");
-            if then_type == else_type {
-                then_type
-            } else {
-                JitType::Any
-            }
-        }
-        TypedExpr::Call(func, args) => {
-            let function_signature = functions
-                .get(func)
-                .expect(format!("Free Identifier: {}", func).as_str());
-
-            // Type check arguments
-            for (input_arg, func_arg_type) in args.iter().zip(&function_signature.arguments) {
-                let input_arg_type = typecheck(input_arg, bindings, functions);
-                if input_arg_type != *func_arg_type {
-                    return JitType::Any;
-                }
-            }
-
-            // If we made it to this point, we successfully type checked the function call and can
-            // Assume that the inputs are correct
-            function_signature.return_value
-        }
-    }
-}
-
-#[cfg(test)]
-mod type_checking {
-
-    use super::*;
-
-    #[test]
-    fn fib_test() {
-        let fib_test = TypedExpr::IfElse(
-            Box::new(TypedExpr::LtE(
-                Box::new(TypedExpr::Identifier("n".to_string())),
-                Box::new(TypedExpr::Literal("2".to_string(), JitType::Int)),
-            )),
-            vec![TypedExpr::Literal("1".to_string(), JitType::Int)],
-            vec![TypedExpr::Add(
-                Box::new(TypedExpr::Call(
-                    "fib".to_string(),
-                    vec![TypedExpr::Sub(
-                        Box::new(TypedExpr::Identifier("n".to_string())),
-                        Box::new(TypedExpr::Literal("1".to_string(), JitType::Int)),
-                    )],
-                )),
-                Box::new(TypedExpr::Call(
-                    "fib".to_string(),
-                    vec![TypedExpr::Sub(
-                        Box::new(TypedExpr::Identifier("n".to_string())),
-                        Box::new(TypedExpr::Literal("2".to_string(), JitType::Int)),
-                    )],
-                )),
-            )],
-        );
-
-        let mut bindings = HashMap::new();
-        bindings.insert("n".to_string(), JitType::Int);
-
-        let mut functions = HashMap::new();
-        functions.insert(
-            "fib".to_string(),
-            JitFunctionSignature::new(vec![JitType::Int], JitType::Int),
-        );
-
-        let output = typecheck(&fib_test, &mut bindings, &functions);
-
-        assert_eq!(output, JitType::Int)
-    }
-}
diff --git a/crates/steel-core/src/jit/lower.rs b/crates/steel-core/src/jit/lower.rs
deleted file mode 100644
index 32df28120..000000000
--- a/crates/steel-core/src/jit/lower.rs
+++ /dev/null
@@ -1,382 +0,0 @@
-#![allow(unused)]
-
-use crate::parser::ast::ExprKind;
-use crate::parser::tokens::TokenType;
-use crate::parser::visitors::VisitorMut;
-use crate::parser::{ast, interner::InternedString};
-
-use std::collections::HashSet;
-
-use im_rc::HashMap;
-
-use super::ir::Expr;
-
-// ((lambda (x y z) (+ x y z)) 10 20 30)
-// =>
-// (x = 10)
-// (y = 20)
-// (z = 30)
-// (+ x (+ y z))
-struct RenameShadowedVars<'a> {
-    depth: usize,
-    in_scope: HashSet<InternedString>,
-    shadowed: HashMap<InternedString, usize>,
-    args: Option<Vec<InternedString>>,
-    ret_val: Option<InternedString>,
-    legal_vars: &'a HashSet<InternedString>,
-}
-
-impl<'a> RenameShadowedVars<'a> {
-    pub fn new(legal_vars: &'a HashSet<InternedString>) -> Self {
-        Self {
-            depth: 0,
-            in_scope: HashSet::new(),
-            shadowed: HashMap::new(),
-            args: None,
-            ret_val: None,
-            legal_vars,
-        }
-    }
-}
-
-// If a new variable is introduced, we should just insert it into the map with an empty shadow
-// Removing should only remove if the
-// #[derive(Default)]
-// struct ScopeMap {
-//     inner: HashMap<String, Vec<String>>,
-// }
-
-// impl ScopeMap {
-
-//     fn insert()
-// }
-
-/// Checks that the input is in fact a lowered function
-pub fn lower_function(
-    expr: &ExprKind,
-    bound_vars: &mut HashSet<InternedString>,
-) -> Option<(String, Vec<String>, String, Vec<Expr>)> {
-    // let mut visitor = RenameShadowedVars::default();
-
-    if let ExprKind::Define(d) = expr {
-        let function_name = d.name.atom_identifier_or_else(|| unreachable!()).ok()?;
-
-        // Register the function itself as a legal function to be used
-        // NOTE: Unbind the function name if compilation fails
-        bound_vars.insert(function_name.to_string());
-
-        let mut visitor = RenameShadowedVars::new(&bound_vars);
-
-        if let ExprKind::LambdaFunction(_) = &d.body {
-            // let func_name = d.name.atom_identifier_or_else(|| unreachable!()).ok()?;
-            // let output = visitor.visit_define(&d)?;
-
-            match visitor.visit_define(&d) {
-                Some(Expr::Assign(func_name, stmt)) => {
-                    // return Some((func_name, visitor.args?, visitor.ret_val?, vec![*stmt]));
-                    return Some((func_name, visitor.args?, visitor.ret_val?, vec![*stmt]));
-                }
-                _ => {
-                    // Make this function name illegal if compilation failed
-                    bound_vars.remove(function_name);
-                }
-            }
-
-            // Make this function name illegal if compilation failed
-            // bound_vars.remove(function_name);
-
-            // if let Expr::Assign(func_name, stmt) = output {
-            //     // return Some((func_name, visitor.args?, visitor.ret_val?, vec![*stmt]));
-            //     return Some((func_name, visitor.args?, visitor.ret_val?, vec![*stmt]));
-            // }
-        }
-    }
-
-    None
-}
-
-impl<'a> VisitorMut for RenameShadowedVars<'a> {
-    type Output = Option<Expr>;
-
-    // Not great, but gets the job done
-    fn visit_if(&mut self, f: &ast::If) -> Self::Output {
-        let test = Box::new(self.visit(&f.test_expr)?);
-        let then_expr = self.visit(&f.then_expr)?;
-        let else_expr = self.visit(&f.else_expr)?;
-
-        match (&then_expr, &else_expr) {
-            (Expr::Block(t), Expr::Block(e)) => Some(Expr::IfElse(test, t.clone(), e.clone())),
-            (Expr::Block(t), _) => Some(Expr::IfElse(test, t.clone(), vec![else_expr])),
-            (_, Expr::Block(e)) => Some(Expr::IfElse(test, vec![then_expr], e.clone())),
-            (_, _) => Some(Expr::IfElse(test, vec![then_expr], vec![else_expr])),
-        }
-    }
-
-    // Define -> Assignment
-    fn visit_define(&mut self, define: &ast::Define) -> Self::Output {
-        let body = self.visit(&define.body)?;
-        let name = define
-            .name
-            .atom_identifier_or_else(|| unreachable!())
-            .ok()?
-            .to_owned();
-        // self.in_scope.insert(name.clone());
-        Some(Expr::Assign(name, Box::new(body)))
-    }
-
-    // If done correctly, this _should_ be unreachable
-    fn visit_lambda_function(&mut self, lambda_function: &ast::LambdaFunction) -> Self::Output {
-        // TODO identify return variables
-        // Do I need to specify the return or is the last value just there?
-        let args = lambda_function
-            .args
-            .iter()
-            .map(|x| {
-                x.atom_identifier_or_else(|| unreachable!())
-                    .ok()
-                    .map(|x| x.to_string())
-            })
-            .collect::<Option<Vec<_>>>()?;
-
-        // Make sure these are now in scope
-        for arg in &args {
-            self.in_scope.insert(arg.clone());
-        }
-
-        self.args = Some(args);
-
-        // Badly attach the return value label
-        self.ret_val = Some("###__return-value__###".to_string());
-        let output = Some(Expr::Assign(
-            "###__return-value__###".to_string(),
-            Box::new(self.visit(&lambda_function.body)?),
-        ));
-
-        output
-    }
-
-    fn visit_begin(&mut self, begin: &ast::Begin) -> Self::Output {
-        let body = begin
-            .exprs
-            .iter()
-            .map(|e| self.visit(e))
-            .collect::<Option<Vec<_>>>()?;
-        Some(Expr::Block(body))
-    }
-
-    fn visit_return(&mut self, _r: &ast::Return) -> Self::Output {
-        None
-    }
-
-    // fn visit_apply(&mut self, _apply: &ast::Apply) -> Self::Output {
-    //     None
-    // }
-
-    // fn visit_panic(&mut self, _p: &ast::Panic) -> Self::Output {
-    //     None
-    // }
-
-    // fn visit_transduce(&mut self, _transduce: &ast::Transduce) -> Self::Output {
-    //     None
-    // }
-
-    // fn visit_execute(&mut self, _execute: &ast::Execute) -> Self::Output {
-    //     None
-    // }
-
-    fn visit_quote(&mut self, _quote: &ast::Quote) -> Self::Output {
-        None
-    }
-
-    fn visit_macro(&mut self, _m: &ast::Macro) -> Self::Output {
-        None
-    }
-
-    // TODO fix this
-    fn visit_atom(&mut self, a: &ast::Atom) -> Self::Output {
-        use TokenType::*;
-        match &a.syn.ty {
-            Identifier(s) => {
-                // Short circuit if we reference a function that we can't yet reference
-                self.validate_identifier(s)?;
-
-                if let Some(depth) = self.shadowed.get(s) {
-                    // Create this busted shadowed nonsense
-                    Some(Expr::Identifier(
-                        "###__depth__".to_string() + depth.to_string().as_str() + s.as_str(),
-                    ))
-                } else {
-                    Some(Expr::Identifier(s.clone()))
-                }
-            }
-            IntegerLiteral(i) => Some(Expr::Literal(i.to_string())),
-            _ => None,
-        }
-    }
-
-    // Check explicit function application with let
-    fn visit_list(&mut self, l: &ast::List) -> Self::Output {
-        // The first should be the function, and the rest should be the args
-        let mut args = l.iter();
-
-        // The corresponds to either a symbol, or a lambda function in this case
-        // Anything else we don't care about
-        let func = args.next()?;
-
-        match func {
-            ExprKind::LambdaFunction(lam) => {
-                self.depth += 1;
-
-                // These need to be mangled?
-                let variable_names = lam
-                    .args
-                    .iter()
-                    .map(|x| x.atom_identifier_or_else(|| unreachable!()).ok().cloned())
-                    .collect::<Option<Vec<_>>>()?;
-
-                let pre_variables = self.shadowed.clone();
-
-                // These are the lowered assignments
-                let mut assignments = variable_names
-                    .clone()
-                    .into_iter()
-                    .zip(args)
-                    .map(|x| -> Option<Expr> {
-                        Some(Expr::Assign(
-                            {
-                                if self.in_scope.contains(&x.0) {
-                                    "###__depth__".to_string()
-                                        + self.depth.to_string().as_str()
-                                        + x.0.as_str()
-                                } else {
-                                    x.0
-                                }
-                            },
-                            Box::new(self.visit(x.1)?),
-                        ))
-                    })
-                    .collect::<Option<Vec<_>>>()?;
-
-                for variable in &variable_names {
-                    if self.in_scope.contains(variable) {
-                        println!("Shadowing: {}", variable);
-                        self.shadowed.insert(variable.clone(), self.depth);
-                    }
-                }
-
-                let body = self.visit(&lam.body)?;
-
-                // They're no longer in scope, take them out
-                for variable in &variable_names {
-                    self.in_scope.remove(variable);
-                    self.shadowed.remove(variable);
-                }
-
-                // Just reset the state for now
-                self.shadowed = pre_variables;
-
-                self.depth -= 1;
-
-                assignments.push(body);
-
-                Some(Expr::Block(assignments))
-            }
-            _ => {
-                let ident = func
-                    .atom_identifier_or_else(|| "Not a valid function here")
-                    .ok()?;
-
-                if let Some(binop) = symbol_to_binop(ident) {
-                    self.expr_list_to_bin_op(binop, args)
-                } else {
-                    self.validate_function_call_ident(ident)?;
-
-                    Some(Expr::Call(
-                        ident.to_owned(),
-                        args.map(|x| self.visit(x)).collect::<Option<Vec<_>>>()?,
-                    ))
-                }
-            }
-        }
-    }
-
-    fn visit_syntax_rules(&mut self, _l: &ast::SyntaxRules) -> Self::Output {
-        None
-    }
-
-    // This should be assignment
-    // but only if the variable being assigned is scoped locally to the function
-    fn visit_set(&mut self, _s: &ast::Set) -> Self::Output {
-        todo!()
-    }
-
-    fn visit_require(&mut self, _s: &ast::Require) -> Self::Output {
-        None
-    }
-
-    fn visit_let(&mut self, l: &ast::Let) -> Self::Output {
-        todo!()
-    }
-}
-
-impl<'a> RenameShadowedVars<'a> {
-    fn expr_list_to_bin_op<'b>(
-        &mut self,
-        binop: fn(Box<Expr>, Box<Expr>) -> Expr,
-        exprs: impl DoubleEndedIterator<Item = &'b ExprKind>,
-    ) -> Option<Expr> {
-        let mut args_iter = exprs.into_iter();
-
-        let left_initial = Box::new(self.visit(args_iter.next()?)?);
-        let right_initial = Box::new(self.visit(args_iter.next()?)?);
-
-        args_iter.try_fold(binop(left_initial, right_initial), |accum, next| {
-            Some(binop(Box::new(accum), Box::new(self.visit(next)?)))
-        })
-    }
-
-    fn validate_function_call_ident(&self, ident: &InternedString) -> Option<()> {
-        if self.legal_vars.contains(ident) {
-            println!("Validated: {}", ident);
-            println!("Legal vars: {:#?}", self.legal_vars);
-            Some(())
-        } else {
-            println!(
-                "Found a variable that cannot be referenced, aborting compilation: {}",
-                ident
-            );
-            None
-        }
-    }
-
-    fn validate_identifier(&self, ident: &InternedString) -> Option<()> {
-        if !self.shadowed.contains_key(ident)
-            && !self.in_scope.contains(ident)
-            && !self.legal_vars.contains(ident)
-        {
-            println!(
-                "Found a variable that cannot be referenced, aborting compilation: {}",
-                ident
-            );
-            None
-        } else {
-            Some(())
-        }
-    }
-}
-
-fn symbol_to_binop(symbol: &str) -> Option<fn(Box<Expr>, Box<Expr>) -> Expr> {
-    match symbol {
-        "+" => Some(Expr::Add),
-        "-" => Some(Expr::Sub),
-        "/" => Some(Expr::Div),
-        "*" => Some(Expr::Mul),
-        "=" | "equal?" | "eq?" => Some(Expr::Eq),
-        "<" => Some(Expr::Lt),
-        ">" => Some(Expr::Gt),
-        "!=" => Some(Expr::Ne),
-        ">=" => Some(Expr::Ge),
-        "<=" => Some(Expr::Le),
-        _ => None,
-    }
-}
diff --git a/crates/steel-core/src/jit/mod.rs b/crates/steel-core/src/jit/mod.rs
deleted file mode 100644
index e62348982..000000000
--- a/crates/steel-core/src/jit/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-#![allow(unused)]
-
-pub mod code_gen;
-pub mod ir;
-pub mod lower;
-pub mod sig;
-pub mod value;
diff --git a/crates/steel-core/src/jit/sig.rs b/crates/steel-core/src/jit/sig.rs
deleted file mode 100644
index a29589bec..000000000
--- a/crates/steel-core/src/jit/sig.rs
+++ /dev/null
@@ -1,133 +0,0 @@
-use crate::gc::Gc;
-use crate::jit::code_gen::JIT;
-use crate::jit::value::{decode, to_encoded_double};
-use crate::SteelVal;
-
-#[derive(Clone, Copy)]
-pub enum Sig {
-    NoArgs = 0,
-    One,
-    Two,
-    Three,
-    Four,
-    Five,
-    Six,
-    Seven,
-    Eight,
-    Nine,
-    Ten,
-}
-
-impl Sig {
-    pub fn from_usize(arity: usize) -> Self {
-        use Sig::*;
-        match arity {
-            0 => NoArgs,
-            1 => One,
-            2 => Two,
-            3 => Three,
-            4 => Four,
-            5 => Five,
-            6 => Six,
-            7 => Seven,
-            8 => Eight,
-            9 => Nine,
-            10 => Ten,
-            _ => panic!("Unable to construct function pointer with more than 10 arguments"),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct JitFunctionPointer {
-    signature: Sig,
-    fn_ptr: *const u8,
-}
-
-impl JitFunctionPointer {
-    pub(crate) fn new(signature: Sig, fn_ptr: *const u8) -> Self {
-        JitFunctionPointer { signature, fn_ptr }
-    }
-
-    pub(crate) fn arity(&self) -> usize {
-        (self.signature as u8) as usize
-    }
-}
-
-macro_rules! pop_values_and_call {
-    ($func:expr, $stack:expr => $($param:ident),* => $($reference:ident),*) => {
-        {
-
-            $(
-                let $param = Gc::new($stack.pop().expect("Empty stack"));
-            )*
-
-            let output = decode($func($(
-                to_encoded_double(&$reference)
-            ,)*));
-
-            JIT::free();
-
-            return output;
-        }
-    };
-}
-
-impl JitFunctionPointer {
-    pub fn call_func(&self, stack: &mut Vec<SteelVal>) -> SteelVal {
-        unsafe { self.call_func_unsafe(stack) }
-    }
-
-    unsafe fn call_func_unsafe(&self, stack: &mut Vec<SteelVal>) -> SteelVal {
-        // Get at the internal function pointer that this points to
-        // We'll need to transform it into an actual function pointer later
-        let fn_ptr = self.fn_ptr;
-
-        match self.signature {
-            // If it has no args, it can't construct anything
-            // Should just be an integer
-            Sig::NoArgs => {
-                let func: fn() -> isize = std::mem::transmute(fn_ptr);
-                let output = func();
-                SteelVal::IntV(output)
-            }
-            Sig::One => {
-                let func: fn(f64) -> f64 = std::mem::transmute(fn_ptr);
-                pop_values_and_call!(func, stack => first => first);
-            }
-            Sig::Two => {
-                let func: fn(f64, f64) -> f64 = std::mem::transmute(fn_ptr);
-
-                pop_values_and_call!(func, stack => first, second => second, first);
-            }
-            Sig::Three => {
-                let func: fn(f64, f64, f64) -> f64 = std::mem::transmute(fn_ptr);
-                pop_values_and_call!(func, stack => first, second, third => third, second, first);
-            }
-            Sig::Four => {
-                let func: fn(f64, f64, f64, f64) -> f64 = std::mem::transmute(fn_ptr);
-                pop_values_and_call!(func, stack => first, second, third, fourth => fourth, third, second, first);
-            }
-            Sig::Five => {
-                let func: fn(f64, f64, f64, f64, f64) -> f64 = std::mem::transmute(fn_ptr);
-                pop_values_and_call!(func, stack => first, second, third, fourth, fifth => fifth, fourth, third, second, first);
-            }
-            Sig::Six => {
-                let func: fn(f64, f64, f64, f64, f64, f64) -> f64 = std::mem::transmute(fn_ptr);
-                pop_values_and_call!(func, stack => first, second, third, fourth, fifth, sixth => sixth, fifth, fourth, third, second, first);
-            }
-            Sig::Seven => {
-                let func: fn(f64, f64, f64, f64, f64, f64, f64) -> f64 =
-                    std::mem::transmute(fn_ptr);
-                pop_values_and_call!(func, stack => first, second, third, fourth, fifth, sixth, seventh => seventh, sixth, fifth, fourth, third, second, first);
-            }
-            Sig::Eight => {
-                let func: fn(f64, f64, f64, f64, f64, f64, f64, f64) -> f64 =
-                    std::mem::transmute(fn_ptr);
-                pop_values_and_call!(func, stack => first, second, third, fourth, fifth, sixth, seventh, eigth => eigth, seventh, sixth, fifth, fourth, third, second, first);
-            }
-            Sig::Nine => todo!(),
-            Sig::Ten => todo!(),
-        }
-    }
-}
diff --git a/crates/steel-core/src/jit/value.rs b/crates/steel-core/src/jit/value.rs
deleted file mode 100644
index 96e8619f8..000000000
--- a/crates/steel-core/src/jit/value.rs
+++ /dev/null
@@ -1,314 +0,0 @@
-use crate::rvals::{FromSteelVal, IntoSteelVal};
-use crate::SteelVal;
-use crate::{gc::Gc, rvals::SteelString};
-
-use super::code_gen::JIT;
-
-// pub fn is_negative_zero(number: f64) -> bool {
-//     number == 0 && (number as isize) != 0
-// }
-
-// TODO: Make tags for everything
-// Tags
-pub const PTR_TAG: u64 = 0xfffa000000000000;
-pub const MAX_DOUBLE: u64 = 0xfff8000000000000;
-pub const INT32_TAG: u64 = 0xfff9000000000000;
-pub const STRING_TAG: u64 = 0xfff7000000000000;
-
-// pub const BOOLEAN_MASK: u64 = 0xfffb000000000002;
-// pub const TRUE_VALUE: u64 = BOOLEAN_MASK | 3;
-// pub const FALSE_VALUE: u64 = BOOLEAN_MASK | 2;
-
-// pub const BOOELAN_MASK: 0xfff
-
-// TODO should this be true - 6 false - 7 or the other way around
-pub const TRUE_VALUE: u64 = 0x07;
-pub const FALSE_VALUE: u64 = 0x06;
-
-// pub const BOOL_TAG: u64 = 0x06;
-
-pub fn is_bool(bits: u64) -> bool {
-    bits == TRUE_VALUE || bits == FALSE_VALUE
-}
-
-pub fn get_as_bool(bits: u64) -> u64 {
-    bits & 0x1
-}
-
-pub fn get_as_rust_bool(bits: u64) -> bool {
-    is_bool(bits) && bits == TRUE_VALUE
-}
-
-pub fn encode_bool(b: bool) -> f64 {
-    unsafe { std::mem::transmute(if b { TRUE_VALUE } else { FALSE_VALUE }) }
-}
-
-pub fn to_float(bits: u64) -> f64 {
-    unsafe { std::mem::transmute(bits) }
-}
-
-pub fn is_double(bits: u64) -> bool {
-    bits < MAX_DOUBLE
-}
-
-pub fn is_int32(bits: u64) -> bool {
-    (bits & INT32_TAG) == INT32_TAG
-}
-
-pub fn is_pointer(bits: f64) -> bool {
-    let bits = bits.to_bits();
-    (bits & PTR_TAG) == PTR_TAG
-}
-
-pub fn is_string(bits: u64) -> bool {
-    (bits & STRING_TAG) == STRING_TAG
-}
-
-fn coerce_value(bits: u64) -> f64 {
-    assert!((bits & PTR_TAG) == 0);
-
-    to_float(bits | PTR_TAG)
-}
-
-fn coerce_string(bits: u64) -> f64 {
-    assert!((bits & STRING_TAG) == 0);
-
-    to_float(bits | STRING_TAG)
-}
-
-pub fn get_pointer(bits: f64) -> u64 {
-    // If this isn't a pointer, things will go poorly
-    assert!(is_pointer(bits));
-
-    let bits = bits.to_bits();
-    bits & !PTR_TAG
-}
-
-pub fn from_i32(value: i32) -> f64 {
-    let bits = unsafe {
-        let bits: u64 = std::mem::transmute(i64::from(value));
-        bits | INT32_TAG
-    };
-
-    to_float(bits)
-}
-
-// inline Value(const int32_t number) {
-//     asBits = number | Int32Tag;
-// }
-
-// If this is a double, just return it
-pub fn get_double(bits: u64) -> f64 {
-    assert!(is_double(bits));
-
-    to_float(bits)
-}
-
-pub fn get_int32(value: f64) -> i64 {
-    unsafe { std::mem::transmute(value.to_bits() & !INT32_TAG) }
-}
-
-pub(crate) trait ToNanTaggedValue {
-    fn encode(self) -> f64;
-}
-
-impl ToNanTaggedValue for &Gc<SteelVal> {
-    fn encode(self) -> f64 {
-        to_encoded_double(self)
-    }
-}
-
-impl ToNanTaggedValue for &SteelVal {
-    fn encode(self) -> f64 {
-        to_encoded_double_raw(self)
-    }
-}
-
-impl<T: IntoSteelVal> ToNanTaggedValue for T {
-    fn encode(self) -> f64 {
-        let value = self
-            .into_steelval()
-            .expect("Value coercion to steelval failed!");
-
-        let boxed = Gc::new(value);
-
-        JIT::allocate(&boxed);
-
-        boxed.encode()
-    }
-}
-
-// Take a pointer to a value that implements from steel val and retrieve it
-// Since these functions do coercion, this might be expensive and it may be better
-// to move back and forth directly
-// pub(crate) fn from_nan_tagged_value<T: FromSteelVal>(ptr: f64) -> T {
-//     T::from_steelval(&decode(ptr)).expect("Unable to coerce type from steelval")
-// }
-
-// pub trait FromSteelVal: Sized {
-//     fn from_steelval(val: SteelVal) -> Result<Self>;
-// }
-
-// inline int32_t getInt32() const {
-//     assert(isInt32());
-
-//     return static_cast<int32_t>(asBits & ~Int32Tag);
-// }
-
-pub fn to_encoded_double(value: &Gc<SteelVal>) -> f64 {
-    match value.as_ref() {
-        SteelVal::IntV(i) => from_i32(*i as i32),
-        SteelVal::NumV(n) => *n,
-        SteelVal::BoolV(b) => {
-            if *b {
-                to_float(TRUE_VALUE)
-            } else {
-                to_float(FALSE_VALUE)
-            }
-        }
-        _ => coerce_value(value.as_ptr() as u64),
-    }
-}
-
-pub fn to_encoded_double_raw(value: &SteelVal) -> f64 {
-    match value {
-        SteelVal::IntV(i) => from_i32(*i as i32),
-        SteelVal::NumV(n) => *n,
-        SteelVal::BoolV(b) => {
-            if *b {
-                to_float(TRUE_VALUE)
-            } else {
-                to_float(FALSE_VALUE)
-            }
-        }
-        _ => coerce_value((value as *const SteelVal) as u64),
-    }
-}
-
-pub fn to_encoded_double_raw_value(value: SteelVal) -> f64 {
-    match value {
-        SteelVal::IntV(i) => from_i32(i as i32),
-        SteelVal::NumV(n) => n,
-        SteelVal::BoolV(b) => {
-            if b {
-                to_float(TRUE_VALUE)
-            } else {
-                to_float(FALSE_VALUE)
-            }
-        }
-        SteelVal::StringV(s) => {
-            let raw: *const String = std::rc::Rc::into_raw(s.into());
-
-            coerce_string(raw as u64)
-        }
-        _ => todo!(),
-    }
-}
-
-// TODO move this to a trait
-pub fn to_encoded_double_from_const_ptr(value: *const SteelVal) -> f64 {
-    coerce_value(value as u64)
-}
-
-pub fn decode(ptr: f64) -> SteelVal {
-    let bits = ptr.to_bits();
-    if is_int32(bits) {
-        // println!("Decoding an int");
-        SteelVal::IntV(get_int32(ptr) as isize)
-    } else if is_double(bits) {
-        // println!("Decoding a double");
-        SteelVal::NumV(ptr)
-    } else if is_bool(bits) {
-        SteelVal::BoolV(get_as_rust_bool(bits))
-    } else if is_string(bits) {
-        // println!("Decoding a steelval ref");
-        unsafe { get_string_from_double(ptr) }
-    } else {
-        todo!()
-    }
-}
-
-pub unsafe fn get_ref_from_double(ptr: f64) -> SteelVal {
-    (&*(get_pointer(ptr) as *const SteelVal)).clone()
-}
-
-// This is super duper spooky
-pub unsafe fn get_value_from_double(ptr: f64) -> SteelVal {
-    SteelVal::StringV(std::rc::Rc::from_raw(get_pointer(ptr) as *const String).into())
-}
-
-pub unsafe fn get_string_from_double(ptr: f64) -> SteelVal {
-    SteelVal::StringV(std::rc::Rc::from_raw(get_pointer(ptr) as *const String).into())
-}
-
-pub fn is_float_encoded_value(value: isize) -> bool {
-    let bits: f64 = unsafe { std::mem::transmute(value) };
-    is_pointer(bits)
-}
-
-#[cfg(test)]
-mod value_tests {
-
-    use super::*;
-    use crate::gc::Gc;
-    use crate::SteelVal;
-    use std::rc::Rc;
-
-    // #[test]
-    // fn test_pointer_converstion() {
-    //     let value = Gc::new(SteelVal::StringV("hello world".into()));
-    //     let coerced = to_encoded_double(&value);
-    //     let result = unsafe { get_ref_from_double(coerced) };
-    //     assert_eq!(result, SteelVal::StringV("hello world".into()));
-    // }
-
-    // #[test]
-    // fn test_pointer_conversion_raw() {
-    //     let value = SteelVal::StringV("hello world".into());
-    //     let coerced = to_encoded_double_raw_value(value.clone());
-    //     let result = decode(coerced);
-    //     assert_eq!(result, SteelVal::StringV("hello world".into()));
-    // }
-
-    #[test]
-    fn test_is_float() {
-        let value: f64 = 10.0;
-
-        assert!(is_double(value.to_bits()))
-    }
-
-    #[test]
-    fn test_ints() {
-        let value: i32 = 1000;
-        let encoded = from_i32(value);
-        let decoded = decode(encoded);
-
-        assert_eq!(SteelVal::IntV(1000), decoded);
-    }
-
-    #[test]
-    fn test_bools() {
-        let encoded_true: f64 = unsafe { std::mem::transmute(TRUE_VALUE) };
-
-        let output = get_as_rust_bool(encoded_true.to_bits());
-
-        assert_eq!(output, true);
-
-        let encoded_false: f64 = unsafe { std::mem::transmute(FALSE_VALUE) };
-
-        let output = get_as_rust_bool(encoded_false.to_bits());
-
-        assert_eq!(output, false);
-    }
-
-    // #[test]
-    // fn test_addition() {
-    //     let left = 10;
-    //     let right = 20;
-
-    //     // let encoded_left =
-    // }
-
-    // #[test]
-    // fn test_is_float_encoded_value()
-}
diff --git a/crates/steel-core/src/lib.rs b/crates/steel-core/src/lib.rs
deleted file mode 100644
index 630c1dde2..000000000
--- a/crates/steel-core/src/lib.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-extern crate im_rc;
-#[macro_use]
-mod env;
-#[macro_use]
-pub mod core;
-pub mod compiler;
-pub mod primitives;
-#[macro_use]
-pub mod rerrs;
-pub mod rvals;
-pub mod stdlib;
-#[macro_use]
-pub mod gc;
-mod containers;
-mod conversions;
-
-// #[cfg(feature = "jit")]
-// pub mod jit;
-pub mod parser;
-pub mod steel_vm;
-
-#[cfg(test)]
-mod tests;
-pub(crate) mod values;
-
-pub use self::{rerrs::SteelErr, rvals::SteelVal, stdlib::PRELUDE};
-pub use im_lists::list::List;
-pub use im_rc::HashMap;
-pub use primitives::UnRecoverableResult;
-pub use values::RootToken;
-pub use values::RootedSteelVal;
diff --git a/crates/steel-core/src/parser/ast.rs b/crates/steel-core/src/parser/ast.rs
deleted file mode 100644
index 9bc19bc54..000000000
--- a/crates/steel-core/src/parser/ast.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-use crate::parser::{
-    parser::SyntaxObject, tokens::TokenType::*, tryfrom_visitor::TryFromExprKindForSteelVal,
-};
-
-// use std::{convert::TryFrom, fmt::Write, sync::atomic::Ordering};
-
-// use pretty::RcDoc;
-// use serde::{Deserialize, Serialize};
-// use std::fmt;
-// use std::ops::Deref;
-use steel_parser::tokens::MaybeBigInt;
-
-use crate::{
-    rerrs::SteelErr,
-    rvals::SteelVal::{self, *},
-};
-
-pub use steel_parser::ast::{
-    AstTools, Atom, Begin, Define, ExprKind, If, IteratorExtensions, LambdaFunction, Let, List,
-    Macro, PatternPair, Quote, Require, Return, Set, SyntaxRules, STANDARD_MODULE_GET,
-    UNREADABLE_MODULE_GET,
-};
-
-impl TryFrom<ExprKind> for SteelVal {
-    type Error = SteelErr;
-
-    fn try_from(e: ExprKind) -> std::result::Result<Self, Self::Error> {
-        TryFromExprKindForSteelVal::try_from_expr_kind(e)
-    }
-}
-
-/// Convert this ExprKind into a typed version of the AST
-/// TODO: Matt -> actually do a full visitor on the AST
-// pub(crate) fn from_list_repr_to_ast(expr: ExprKind) -> Result<ExprKind, ParseError> {
-//     if let ExprKind::List(l) = expr {
-//         ExprKind::try_from(
-//             l.args
-//                 .into_iter()
-//                 .map(from_list_repr_to_ast)
-//                 .collect::<Result<Vec<_>, ParseError>>()?,
-//         )
-//     } else {
-//         Ok(expr)
-//     }
-// }
-
-#[derive(Debug)]
-pub(crate) struct TryFromSteelValVisitorForExprKind {
-    pub(crate) qq_depth: usize,
-    pub(crate) quoted: bool,
-}
-
-impl TryFromSteelValVisitorForExprKind {
-    pub fn root(value: &SteelVal) -> std::result::Result<ExprKind, SteelErr> {
-        Self {
-            qq_depth: 0,
-            quoted: false,
-        }
-        .visit(value)
-    }
-
-    // type Error = &'static str;
-    pub fn visit(&mut self, value: &SteelVal) -> std::result::Result<ExprKind, SteelErr> {
-        match value {
-            BoolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                BooleanLiteral(*x),
-            )))),
-            NumV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                NumberLiteral(*x),
-            )))),
-            IntV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                IntegerLiteral(MaybeBigInt::Small(*x)),
-            )))),
-
-            BigNum(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                IntegerLiteral(MaybeBigInt::Big(x.unwrap())),
-            )))),
-
-            VectorV(lst) => {
-                let items: std::result::Result<Vec<ExprKind>, _> =
-                    lst.iter().map(|x| self.visit(x)).collect();
-                Ok(ExprKind::List(List::new(items?)))
-            }
-            Void => stop!(Generic => "Can't convert from Void to expression!"),
-            StringV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                StringLiteral(x.to_string()),
-            )))),
-            FuncV(_) => stop!(Generic => "Can't convert from Function to expression!"),
-            // LambdaV(_) => Err("Can't convert from Lambda to expression!"),
-            // MacroV(_) => Err("Can't convert from Macro to expression!"),
-            SymbolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                Identifier(x.as_str().into()),
-            )))),
-
-            // TODO: Change the implementation here to respect quotes correctly
-            SyntaxObject(s) => self.visit_syntax_object(s),
-            Custom(_) => {
-                // TODO: if the returned object is a custom type, check
-                // to see if its a Syntax struct to replace the span with
-                stop!(Generic => "Can't convert from Custom Type to expression!")
-            }
-            ListV(l) => {
-                // Rooted - things operate as normal
-                if self.qq_depth == 0 {
-                    let maybe_special_form = l.first().and_then(|x| {
-                        x.as_symbol()
-                            .or_else(|| x.as_syntax_object().and_then(|x| x.syntax.as_symbol()))
-                    });
-
-                    // dbg!(&maybe_special_form);
-
-                    match maybe_special_form {
-                        Some(x) if x.as_str() == "quote" => {
-                            if self.quoted {
-                                let items: std::result::Result<Vec<ExprKind>, _> =
-                                    l.iter().map(|x| self.visit(x)).collect();
-
-                                return Ok(ExprKind::List(List::new(items?)));
-                            }
-
-                            self.quoted = true;
-
-                            let return_value = Ok(l
-                                .into_iter()
-                                .map(|x| self.visit(x))
-                                .collect::<std::result::Result<Vec<_>, _>>()?
-                                .try_into()?);
-
-                            // dbg!(&return_value);
-
-                            self.quoted = false;
-
-                            return return_value;
-                        } // "quasiquote" => {
-                        //     self.qq_depth += 1;
-                        // }
-
-                        // Empty list, just return as a quoted list
-                        // None => {
-                        // return Ok(ExprKind::empty());
-                        // }
-                        _ => {}
-                    }
-                }
-
-                Ok(l.into_iter()
-                    .map(|x| self.visit(x))
-                    .collect::<std::result::Result<Vec<_>, _>>()?
-                    .try_into()?)
-
-                // If we're not quoted, we need to just return this pushed down to an ast
-                // let items: std::result::Result<Vec<ExprKind>, &'static str> =
-                // l.iter().map(|x| self.visit(x)).collect();
-
-                // Ok(ExprKind::List(List::new(items?)))
-            }
-            CharV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                CharacterLiteral(*x),
-            )))),
-            unknown => {
-                stop!(Generic => "Unable to convert from value to expression: {:?}", unknown)
-            }
-        }
-    }
-}
-
-/// Sometimes you want to execute a list
-/// as if it was an expression
-impl TryFrom<&SteelVal> for ExprKind {
-    type Error = &'static str;
-    fn try_from(r: &SteelVal) -> std::result::Result<Self, Self::Error> {
-        fn inner_try_from(
-            r: &SteelVal,
-            depth: usize,
-        ) -> std::result::Result<ExprKind, &'static str> {
-            if depth > 64 {
-                return Err("Unable to convert steel val to exprkind - depth was too large!");
-            }
-
-            match r {
-                BoolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                    BooleanLiteral(*x),
-                )))),
-                NumV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                    NumberLiteral(*x),
-                )))),
-                IntV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                    IntegerLiteral(MaybeBigInt::Small(*x)),
-                )))),
-
-                BigNum(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                    IntegerLiteral(MaybeBigInt::Big(x.unwrap())),
-                )))),
-
-                VectorV(lst) => {
-                    let items: std::result::Result<Vec<ExprKind>, &'static str> =
-                        lst.iter().map(|x| inner_try_from(x, depth + 1)).collect();
-                    Ok(ExprKind::List(List::new(items?)))
-                }
-                Void => Err("Can't convert from Void to expression!"),
-                StringV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                    StringLiteral(x.to_string()),
-                )))),
-                FuncV(_) => Err("Can't convert from Function to expression!"),
-                // LambdaV(_) => Err("Can't convert from Lambda to expression!"),
-                // MacroV(_) => Err("Can't convert from Macro to expression!"),
-                SymbolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                    Identifier(x.as_str().into()),
-                )))),
-                SyntaxObject(s) => s
-                    .to_exprkind()
-                    .map_err(|_| "Unable to convert syntax object back to exprkind"),
-                Custom(_) => {
-                    // TODO: if the returned object is a custom type, check
-                    // to see if its a Syntax struct to replace the span with
-                    Err("Can't convert from Custom Type to expression!")
-                }
-                ListV(l) => {
-                    let items: std::result::Result<Vec<ExprKind>, &'static str> =
-                        l.iter().map(|x| inner_try_from(x, depth + 1)).collect();
-
-                    Ok(ExprKind::List(List::new(items?)))
-                }
-                CharV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                    CharacterLiteral(*x),
-                )))),
-
-                Pair(_) => Err("Can't convert from pair to expression!"),
-
-                // StructClosureV(_) => Err("Can't convert from struct-function to expression!"),
-                PortV(_) => Err("Can't convert from port to expression!"),
-                Closure(_) => Err("Can't convert from bytecode closure to expression"),
-                HashMapV(_) => Err("Can't convert from hashmap to expression!"),
-                HashSetV(_) => Err("Can't convert from hashset to expression!"),
-                IterV(_) => Err("Can't convert from iterator to expression!"),
-                FutureFunc(_) => Err("Can't convert from future function to expression!"),
-                FutureV(_) => Err("Can't convert future to expression!"),
-                // Promise(_) => Err("Can't convert from promise to expression!"),
-                StreamV(_) => Err("Can't convert from stream to expression!"),
-                // Contract(_) => Err("Can't convert from contract to expression!"),
-                // ContractedFunction(_) => Err("Can't convert from contracted function to expression!"),
-                BoxedFunction(_) => Err("Can't convert from boxed function to expression!"),
-                ContinuationFunction(_) => Err("Can't convert from continuation to expression!"),
-                // #[cfg(feature = "jit")]
-                // CompiledFunction(_) => Err("Can't convert from function to expression!"),
-                MutFunc(_) => Err("Can't convert from function to expression!"),
-                BuiltIn(_) => Err("Can't convert from function to expression!"),
-                ReducerV(_) => Err("Can't convert from reducer to expression!"),
-                MutableVector(_) => Err("Can't convert from vector to expression!"),
-                CustomStruct(_) => Err("Can't convert from struct to expression!"),
-                BoxedIterator(_) => Err("Can't convert from boxed iterator to expression!"),
-                Boxed(_) => Err("Can't convert from boxed steel val to expression!"),
-                Reference(_) => Err("Can't convert from opaque reference type to expression!"),
-                HeapAllocated(_) => Err("Can't convert from heap allocated value to expression!"),
-            }
-        }
-
-        inner_try_from(r, 0)
-    }
-}
diff --git a/crates/steel-core/src/parser/builder.rs b/crates/steel-core/src/parser/builder.rs
deleted file mode 100644
index 6bc9309d6..000000000
--- a/crates/steel-core/src/parser/builder.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-use super::ast::ExprKind;
-
-/// AST-IR Builder
-
-pub struct AstBuilder {
-    _program: Vec<ExprKind>,
-}
-
-impl AstBuilder {}
diff --git a/crates/steel-core/src/parser/expand_visitor.rs b/crates/steel-core/src/parser/expand_visitor.rs
deleted file mode 100644
index 36e4d7d01..000000000
--- a/crates/steel-core/src/parser/expand_visitor.rs
+++ /dev/null
@@ -1,1194 +0,0 @@
-// use itertools::Itertools;
-
-use quickscope::ScopeSet;
-use steel_parser::ast::{parse_lambda, LAMBDA, LAMBDA_SYMBOL};
-
-use crate::compiler::passes::reader::MultipleArityFunctions;
-use crate::compiler::passes::Folder;
-use crate::compiler::program::REQUIRE_DYLIB;
-use crate::parser::ast::ExprKind;
-use crate::parser::parser::SyntaxObject;
-use crate::parser::span_visitor::get_span;
-use crate::parser::visitors::ConsumingVisitor;
-use crate::steel_vm::builtin::BuiltInModule;
-use crate::steel_vm::engine::ModuleContainer;
-use crate::{compiler::program::AS_KEYWORD, parser::tokens::TokenType};
-use crate::{compiler::program::REQUIRE_BUILTIN, rvals::Result};
-
-use steel_parser::expr_list;
-
-use super::{
-    ast::{Atom, Define, LambdaFunction, List, Quote},
-    interner::InternedString,
-    kernel::Kernel,
-};
-
-use std::borrow::Cow;
-use std::collections::{HashMap, HashSet};
-
-use crate::parser::expander::SteelMacro;
-
-// pub const REQUIRE_BUILTIN: &str = "require-builtin";
-// pub const DOC_MACRO: &str = "@doc";
-
-pub fn extract_macro_defs(
-    exprs: Vec<ExprKind>,
-    macro_map: &mut HashMap<InternedString, SteelMacro>,
-) -> Result<Vec<ExprKind>> {
-    let mut non_macros = Vec::new();
-    for expr in exprs {
-        if let ExprKind::Macro(m) = expr {
-            let generated_macro = SteelMacro::parse_from_ast_macro(m)?;
-            let name = generated_macro.name();
-            macro_map.insert(*name, generated_macro);
-        } else {
-            non_macros.push(expr)
-        }
-    }
-    Ok(non_macros)
-}
-
-pub fn expand(expr: ExprKind, map: &HashMap<InternedString, SteelMacro>) -> Result<ExprKind> {
-    Expander {
-        map,
-        changed: false,
-        in_scope_values: ScopeSet::new(),
-    }
-    .visit(expr)
-}
-
-pub struct Expander<'a> {
-    map: &'a HashMap<InternedString, SteelMacro>,
-    pub(crate) changed: bool,
-    // We're going to actually check if the macro is in scope
-    in_scope_values: ScopeSet<InternedString>,
-}
-
-impl<'a> Expander<'a> {
-    pub fn new(map: &'a HashMap<InternedString, SteelMacro>) -> Self {
-        Self {
-            map,
-            changed: false,
-            in_scope_values: ScopeSet::new(),
-        }
-    }
-
-    pub fn expand(&mut self, expr: ExprKind) -> Result<ExprKind> {
-        self.visit(expr)
-    }
-}
-
-// TODO: See if we can do this without blowing the stack
-impl<'a> ConsumingVisitor for Expander<'a> {
-    type Output = Result<ExprKind>;
-
-    fn visit_if(&mut self, mut f: Box<super::ast::If>) -> Self::Output {
-        f.test_expr = self.visit(f.test_expr)?;
-        f.then_expr = self.visit(f.then_expr)?;
-        f.else_expr = self.visit(f.else_expr)?;
-        Ok(ExprKind::If(f))
-    }
-
-    fn visit_define(&mut self, mut define: Box<super::ast::Define>) -> Self::Output {
-        define.body = self.visit(define.body)?;
-        Ok(ExprKind::Define(define))
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        mut lambda_function: Box<super::ast::LambdaFunction>,
-    ) -> Self::Output {
-        self.in_scope_values.push_layer();
-
-        for value in &lambda_function.args {
-            if let Some(ident) = value.atom_identifier() {
-                self.in_scope_values.define(*ident);
-            }
-        }
-
-        lambda_function.body = self.visit(lambda_function.body)?;
-
-        self.in_scope_values.pop_layer();
-
-        Ok(ExprKind::LambdaFunction(lambda_function))
-    }
-
-    fn visit_begin(&mut self, mut begin: super::ast::Begin) -> Self::Output {
-        begin.exprs = begin
-            .exprs
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-        Ok(ExprKind::Begin(begin))
-    }
-
-    fn visit_return(&mut self, mut r: Box<super::ast::Return>) -> Self::Output {
-        r.expr = self.visit(r.expr)?;
-        Ok(ExprKind::Return(r))
-    }
-
-    fn visit_quote(&mut self, quote: Box<super::ast::Quote>) -> Self::Output {
-        // println!("Visiting quote with : {:?}", quote);
-        // quote.expr = self.visit(quote.expr)?;
-        Ok(ExprKind::Quote(quote))
-    }
-
-    fn visit_macro(&mut self, m: Box<super::ast::Macro>) -> Self::Output {
-        stop!(BadSyntax => format!("unexpected macro definition in expand visitor: {}", m); m.location.span)
-    }
-
-    fn visit_atom(&mut self, a: Atom) -> Self::Output {
-        Ok(ExprKind::Atom(a))
-    }
-
-    fn visit_list(&mut self, mut l: super::ast::List) -> Self::Output {
-        match l.first() {
-            Some(ExprKind::Atom(
-                ident @ Atom {
-                    syn:
-                        SyntaxObject {
-                            ty: TokenType::Identifier(s),
-                            ..
-                        },
-                },
-            )) if *s == *LAMBDA_SYMBOL || *s == *LAMBDA => {
-                if let ExprKind::LambdaFunction(lambda) = parse_lambda(&ident.clone(), l.args)? {
-                    return self.visit_lambda_function(lambda);
-                } else {
-                    unreachable!()
-                }
-            }
-
-            Some(ExprKind::Atom(
-                ident @ Atom {
-                    syn:
-                        SyntaxObject {
-                            ty: TokenType::Lambda,
-                            ..
-                        },
-                },
-            )) => {
-                if let ExprKind::LambdaFunction(lambda) = parse_lambda(&ident.clone(), l.args)? {
-                    return self.visit_lambda_function(lambda);
-                } else {
-                    unreachable!()
-                }
-            }
-
-            Some(ExprKind::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::Identifier(s),
-                        span: sp,
-                        ..
-                    },
-            })) => {
-                if let Some(m) = self.map.get(s) {
-                    // If this macro has been overwritten by any local value, respect
-                    // the local binding and do not expand the macro
-                    if !self.in_scope_values.contains(s) {
-                        let expanded = m.expand(l.clone(), *sp)?;
-                        self.changed = true;
-                        return self.visit(expanded);
-                    }
-                }
-            }
-            _ => {}
-        }
-
-        l.args = l
-            .args
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(ExprKind::List(l))
-    }
-
-    fn visit_syntax_rules(&mut self, l: Box<super::ast::SyntaxRules>) -> Self::Output {
-        dbg!(l.to_string());
-
-        stop!(Generic => "unexpected syntax-rules definition"; l.location.span)
-    }
-
-    fn visit_set(&mut self, mut s: Box<super::ast::Set>) -> Self::Output {
-        s.variable = self.visit(s.variable)?;
-        s.expr = self.visit(s.expr)?;
-        Ok(ExprKind::Set(s))
-    }
-
-    fn visit_require(&mut self, s: super::ast::Require) -> Self::Output {
-        Ok(ExprKind::Require(s))
-        // stop!(Generic => "unexpected require statement during expansion"; s.location.span)
-    }
-
-    fn visit_let(&mut self, mut l: Box<super::ast::Let>) -> Self::Output {
-        let mut visited_bindings = Vec::new();
-
-        for (binding, expr) in l.bindings {
-            visited_bindings.push((self.visit(binding)?, self.visit(expr)?));
-        }
-
-        l.bindings = visited_bindings;
-        l.body_expr = self.visit(l.body_expr)?;
-
-        Ok(ExprKind::Let(l))
-    }
-}
-
-pub fn expand_kernel_in_env_with_allowed(
-    expr: ExprKind,
-    kernel: Option<&mut Kernel>,
-    builtin_modules: ModuleContainer,
-    env: String,
-    allowed: &HashSet<InternedString>,
-) -> Result<(ExprKind, bool)> {
-    let mut expander = KernelExpander {
-        map: kernel,
-        changed: false,
-        builtin_modules,
-        environment: Some(Cow::from(env)),
-        depth: 0,
-        allowed_macros: Some(allowed),
-    };
-
-    expander.visit(expr).map(|x| (x, expander.changed))
-}
-
-pub fn expand_kernel_in_env_with_change(
-    expr: ExprKind,
-    kernel: Option<&mut Kernel>,
-    builtin_modules: ModuleContainer,
-    env: String,
-) -> Result<(ExprKind, bool)> {
-    let mut expander = KernelExpander {
-        map: kernel,
-        changed: false,
-        builtin_modules,
-        environment: Some(Cow::from(env)),
-        depth: 0,
-        allowed_macros: None,
-    };
-
-    expander.visit(expr).map(|x| (x, expander.changed))
-}
-
-pub fn expand_kernel_in_env(
-    expr: ExprKind,
-    kernel: Option<&mut Kernel>,
-    builtin_modules: ModuleContainer,
-    env: String,
-) -> Result<ExprKind> {
-    KernelExpander {
-        map: kernel,
-        changed: false,
-        builtin_modules,
-        environment: Some(Cow::from(env)),
-        depth: 0,
-        allowed_macros: None,
-    }
-    .visit(expr)
-}
-
-pub fn expand_kernel(
-    expr: ExprKind,
-    kernel: Option<&mut Kernel>,
-    builtin_modules: ModuleContainer,
-) -> Result<ExprKind> {
-    KernelExpander {
-        map: kernel,
-        changed: false,
-        builtin_modules,
-        environment: None,
-        depth: 0,
-        allowed_macros: None,
-    }
-    .visit(expr)
-}
-
-pub struct KernelExpander<'a> {
-    map: Option<&'a mut Kernel>,
-    pub(crate) changed: bool,
-    builtin_modules: ModuleContainer,
-    environment: Option<Cow<'static, str>>,
-    depth: usize,
-    allowed_macros: Option<&'a HashSet<InternedString>>,
-}
-
-impl<'a> KernelExpander<'a> {
-    pub fn new(map: Option<&'a mut Kernel>, builtin_modules: ModuleContainer) -> Self {
-        Self {
-            map,
-            changed: false,
-            builtin_modules,
-            environment: None,
-            depth: 0,
-            allowed_macros: None,
-        }
-    }
-
-    pub fn expand(&mut self, expr: ExprKind) -> Result<ExprKind> {
-        self.visit(expr)
-    }
-}
-
-fn _expand_default_arguments(
-    lambda_function: Box<super::ast::LambdaFunction>,
-) -> Result<Box<super::ast::LambdaFunction>> {
-    // todo!()
-
-    let _args_len = lambda_function.args.len();
-
-    let mut found_pair = false;
-    for argument in &lambda_function.args {
-        if let ExprKind::List(_) = argument {
-            found_pair = true;
-        } else if found_pair {
-            stop!(BadSyntax => "Non default argument occurs after a default argument"; lambda_function.location.span)
-        }
-    }
-
-    let _non_default_bindings = lambda_function
-        .args
-        .iter()
-        .filter(|x| !matches!(x, ExprKind::List(_)))
-        .collect::<Vec<_>>();
-
-    // let bindings = lambda_function
-    //     .args
-    //     .iter()
-    //     .enumerate()
-    //     .filter(|x| matches!(x.1, ExprKind::List(_)))
-    //     .map(|x| {
-    //         if let ExprKind::List(l) = x.1 {
-    //             let var_name = l
-    //                 .get(0)
-    //                 .ok_or_else(throw!(BadSyntax => "empty default argument"))?;
-    //             let expr = l.get(1).ok_or_else(
-    //                 throw!(BadSyntax => "default argument missing default expression"),
-    //             )?;
-
-    //             let index = ExprKind::integer_literal(x.0 as isize, lambda_function.location.span);
-
-    //             let body = vec![
-
-    //             ]
-
-    //             todo!()
-    //         } else {
-    //             unreachable!()
-    //         }
-    //     })
-    //     .collect::<Result<Vec<_>>>();
-
-    todo!()
-}
-
-// Adjust the generated code to raise a specific error saying certain keys were missing.
-fn expand_keyword_arguments(
-    lambda_function: Box<super::ast::LambdaFunction>,
-) -> Result<Box<super::ast::LambdaFunction>> {
-    // todo!()
-
-    // TODO: Check if this already has a rest argument - if so, the generated code will need to be changed.
-    // The naive generated code will not handle rest arguments with keyword arguments, which can be a concern.
-    // In addition, this naively assumes that keyword arguments cannot be applied before positional arguments - which
-    // on its own is not the worst restriction, and perhaps we can leave that in place.
-    //
-    // If there are rest arguments though, we'll need to split the rest argument list into two - the first half will then get
-    // applied to the hashmap list, while the rest of the arguments will get applied to the correct place.
-
-    // We don't want to do this! This is going to allocate extra!
-    let lambda_function = MultipleArityFunctions::new()
-        .visit_lambda_function(lambda_function)
-        .into_lambda_function()
-        .unwrap();
-
-    // If this already has a rest arguments, we need to slice out the
-    // remaining function values from the keywords, and then bind those to whatever variable in the original
-    // list before we create the hash. Making the hash itself is also not exactly my favorite pattern - we need
-    // to allocate extra stuff - what we should probably do is create a special keyword allocation that we
-    // can consistently reuse inside the VM. If we can reuse that allocation repeatedly, we should be able
-    // to avoid much of the overhead of the allocation.
-
-    // TODO: Can partition these directly into the two groups
-    let keyword_args: Vec<&ExprKind> = lambda_function
-        .args
-        .iter()
-        .skip_while(|x| {
-            !matches!(
-                x,
-                ExprKind::Atom(Atom {
-                    syn: SyntaxObject {
-                        ty: TokenType::Keyword(_),
-                        ..
-                    }
-                })
-            )
-        })
-        .collect();
-
-    // If there is a rest argument, we'll want to grab it for later use in the expansion
-    // TODO: @Matt - Come back to this one
-    // let mut rest_arg_expr = None;
-
-    // Bail out if theres no keyword args
-    if keyword_args.is_empty() {
-        return Ok(lambda_function);
-    }
-
-    if (keyword_args.len() % 2 != 0 && !lambda_function.rest)
-        || (lambda_function.rest && keyword_args.len() - 1 % 2 != 0)
-    {
-        // The last argument is going to be the rest argument
-        // if lambda_function.rest {
-        //     rest_arg_expr = keyword_args.pop();
-        // }
-
-        stop!(Generic => "keyword arguments malformed - each option requires a value"; lambda_function.location.span)
-    }
-
-    let mut non_keyword_args: Vec<ExprKind> = lambda_function
-        .args
-        .iter()
-        .take_while(|x| {
-            !matches!(
-                x,
-                ExprKind::Atom(Atom {
-                    syn: SyntaxObject {
-                        ty: TokenType::Keyword(_),
-                        ..
-                    }
-                })
-            )
-        })
-        .cloned()
-        .collect();
-
-    // From the keyword args, group them into pairs
-    let keyword_map = keyword_args
-        .chunks(2)
-        .into_iter()
-        .map(|x| (x[0], x[1]))
-        .collect::<Vec<_>>();
-
-    if !keyword_map.iter().map(|x| x.0).all(|x| {
-        matches!(
-            x,
-            ExprKind::Atom(Atom {
-                syn: SyntaxObject {
-                    ty: TokenType::Keyword(_),
-                    ..
-                }
-            })
-        )
-    }) {
-        dbg!(&keyword_map);
-
-        stop!(Generic => "Non keyword arguments found after the first keyword argument"; lambda_function.location.span)
-    }
-
-    let bindings = keyword_map
-        .into_iter()
-        .map(|x| {
-            let keyword = x.0;
-            let original_var_name = x.1;
-
-            // This is a bit wasteful... come back to this
-            let (var_name, expr) = if let ExprKind::List(l) = original_var_name {
-                (l[0].clone(), l[1].clone())
-            } else {
-                (original_var_name.clone(), original_var_name.clone())
-            };
-
-            // println!("{:?}", original_var_name);
-
-            // TODO: Go here to implement default arguments
-            let expression = ExprKind::default_if(
-                expr_list![
-                    ExprKind::ident("hash-contains?"),
-                    ExprKind::ident("!!dummy-rest-arg!!"),
-                    ExprKind::Quote(Box::new(Quote::new(
-                        keyword.clone(),
-                        lambda_function.location.clone(),
-                    ))),
-                ],
-                var_name.clone(),
-                ExprKind::default_if(
-                    ExprKind::bool_lit(matches!(original_var_name, ExprKind::List(_))),
-                    expr,
-                    expr_list![
-                        ExprKind::ident("error!"),
-                        ExprKind::string_lit(format!(
-                            "Function application missing required keyword argument: {keyword}"
-                        ))
-                    ],
-                ),
-            );
-
-            let func = ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                vec![var_name.clone()],
-                expression,
-                SyntaxObject::default(TokenType::Lambda),
-            )));
-
-            let application = expr_list![
-                func,
-                expr_list![
-                    ExprKind::ident("hash-try-get"),
-                    ExprKind::ident("!!dummy-rest-arg!!"),
-                    ExprKind::Quote(Box::new(Quote::new(
-                        keyword.clone(),
-                        lambda_function.location.clone(),
-                    ))),
-                ],
-            ];
-
-            (var_name, application)
-        })
-        .collect::<Vec<_>>();
-
-    non_keyword_args.push(ExprKind::ident("!!dummy-rest-arg!!"));
-
-    let mut inner_application = vec![ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-        bindings.iter().map(|x| x.0.clone()).collect(),
-        lambda_function.body.clone(),
-        SyntaxObject::default(TokenType::Lambda),
-    )))];
-
-    inner_application.extend(bindings.iter().map(|x| x.1.clone()));
-
-    Ok(Box::new(LambdaFunction::new_with_rest_arg(
-        non_keyword_args,
-        expr_list![
-            ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                vec![ExprKind::ident("!!dummy-rest-arg!!")],
-                ExprKind::List(List::new(inner_application)),
-                SyntaxObject::default(TokenType::Lambda),
-            ))),
-            expr_list![
-                ExprKind::ident("apply"),
-                ExprKind::ident("%keyword-hash"), // This shouldn't be `hash` directly - something with a specific error
-                // TODO: do like, `(take x !!dummy-rest-arg!!)`
-                ExprKind::ident("!!dummy-rest-arg!!"),
-            ],
-        ],
-        SyntaxObject::default(TokenType::Lambda),
-    )))
-}
-
-impl<'a> ConsumingVisitor for KernelExpander<'a> {
-    type Output = Result<ExprKind>;
-
-    fn visit_if(&mut self, mut f: Box<super::ast::If>) -> Self::Output {
-        f.test_expr = self.visit(f.test_expr)?;
-        f.then_expr = self.visit(f.then_expr)?;
-        f.else_expr = self.visit(f.else_expr)?;
-        Ok(ExprKind::If(f))
-    }
-
-    fn visit_define(&mut self, mut define: Box<super::ast::Define>) -> Self::Output {
-        define.body = self.visit(define.body)?;
-        Ok(ExprKind::Define(define))
-    }
-
-    // TODO: Kernel expander should have the liberty to parse everything
-    // As a normal expression in order to match behavior
-    fn visit_lambda_function(
-        &mut self,
-        mut lambda_function: Box<super::ast::LambdaFunction>,
-    ) -> Self::Output {
-        // TODO: Unfortunately this wipes out the span
-        // There needs to be
-
-        lambda_function.body = self.visit(lambda_function.body)?;
-
-        // Expand keyword arguments if we can
-        lambda_function = expand_keyword_arguments(lambda_function)?;
-
-        // Expand default arguments here
-
-        // if let Some(map) = &mut self.map {
-        //     // println!("Function: {}", lambda_function);
-        //     if map.contains_macro("%test-lambda%") {
-        //         let arguments = ExprKind::List(super::ast::List::new(vec![
-        //             ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Lambda))),
-        //             ExprKind::List(super::ast::List::new(lambda_function.args)),
-        //             lambda_function.body,
-        //         ]));
-
-        //         let expanded = map.expand("%lambda%", arguments)?;
-        //         self.changed = true;
-        //         if let ExprKind::LambdaFunction(_) = &expanded {
-        //             return Ok(expanded);
-        //         } else {
-        //             unreachable!("The expansion above should always return a lambda")
-        //         }
-        //     }
-        // }
-
-        // lambda_function.body = self.visit(lambda_function.body)?;
-        Ok(ExprKind::LambdaFunction(lambda_function))
-    }
-
-    fn visit_begin(&mut self, mut begin: super::ast::Begin) -> Self::Output {
-        begin.exprs = begin
-            .exprs
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-        Ok(ExprKind::Begin(begin))
-    }
-
-    fn visit_return(&mut self, mut r: Box<super::ast::Return>) -> Self::Output {
-        r.expr = self.visit(r.expr)?;
-        Ok(ExprKind::Return(r))
-    }
-
-    fn visit_quote(&mut self, mut quote: Box<super::ast::Quote>) -> Self::Output {
-        quote.expr = self.visit(quote.expr)?;
-        Ok(ExprKind::Quote(quote))
-    }
-
-    fn visit_macro(&mut self, m: Box<super::ast::Macro>) -> Self::Output {
-        stop!(BadSyntax => format!("unexpected macro definition in kernel expander: {}", m); m.location.span)
-    }
-
-    fn visit_atom(&mut self, a: Atom) -> Self::Output {
-        Ok(ExprKind::Atom(a))
-    }
-
-    // TODO: This is not the best way of doing things, but for now we can accept it for the sake of progress
-    fn visit_list(&mut self, mut l: super::ast::List) -> Self::Output {
-        // todo!()
-        if let Some(ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::Identifier(s),
-                    ..
-                },
-        })) = l.first().cloned()
-        {
-            if let Some(map) = &mut self.map {
-                /*
-
-
-                if s == *DOC_MACRO {
-                    if l.len() != 3 {
-                        stop!(BadSyntax => "Malformed @doc statement!")
-                    }
-
-                    let mut args = l.into_iter();
-                    args.next(); // Skip past the doc macro
-
-                    let comment = args.next().unwrap();
-                    let top_level_define = args.next().unwrap();
-
-                    // println!("Getting here - {}", top_level_define);
-                    // println!("{:?}", top_level_define);
-
-                    match &top_level_define {
-                        // A classic @doc case
-                        // (@doc "comment" (define <name> <body>))
-                        ExprKind::Define(d) => {
-                            let doc_expr = ExprKind::Define(Box::new(Define::new(
-                                ExprKind::atom(
-                                    d.name.atom_identifier().unwrap().to_string() + "__doc__",
-                                ),
-                                comment,
-                                SyntaxObject::default(TokenType::Define),
-                            )));
-
-                            // let ast_name = ExprKind::atom(
-                            // d.name.atom_identifier().unwrap().to_string() + "__ast__",
-                            // );
-
-                            // Include the metadata table
-                            let metadata_table_addition = ExprKind::List(List::new(vec![
-                                ExprKind::atom("#%function-ptr-table-add"),
-                                ExprKind::atom("#%function-ptr-table"),
-                                ExprKind::atom(d.name.atom_identifier().unwrap().clone()),
-                                ExprKind::atom(
-                                    d.name.atom_identifier().unwrap().to_string() + "__doc__",
-                                ),
-                            ]));
-
-                            let expanded_expr = self.visit(top_level_define)?;
-
-                            // let quoted_ast = define_quoted_ast_node(ast_name, &expanded_expr);
-
-                            return Ok(ExprKind::Begin(Begin::new(
-                                vec![doc_expr, expanded_expr, metadata_table_addition],
-                                SyntaxObject::default(TokenType::Begin),
-                            )));
-                        }
-
-                        // An edge case that should eventually be realized:
-                        //
-                        ExprKind::Begin(b) => match &b.exprs.as_slice() {
-                            // If this is a sequence of two things, catch the latter one like above
-                            &[ExprKind::Define(d), ExprKind::Set(s), _]
-                                if d.name.atom_identifier() == s.variable.atom_identifier() =>
-                            {
-                                let doc_expr = ExprKind::Define(Box::new(Define::new(
-                                    ExprKind::atom(
-                                        d.name.atom_identifier().unwrap().to_string() + "__doc__",
-                                    ),
-                                    comment,
-                                    SyntaxObject::default(TokenType::Define),
-                                )));
-
-                                // let ast_name = ExprKind::atom(
-                                // d.name.atom_identifier().unwrap().to_string() + "__ast__",
-                                // );
-
-                                let expanded_expr = self.visit(top_level_define)?;
-
-                                // let quoted_ast = define_quoted_ast_node(ast_name, &expanded_expr);
-
-                                return Ok(ExprKind::Begin(Begin::new(
-                                    vec![doc_expr, expanded_expr],
-                                    SyntaxObject::default(TokenType::Begin),
-                                )));
-                            }
-                            _ => return self.visit(top_level_define),
-                        },
-
-                        ExprKind::List(struct_def)
-                            if struct_def.first_ident() == Some(&STRUCT_KEYWORD) =>
-                        {
-                            if let Some(struct_name) =
-                                struct_def.get(1).and_then(|x| x.atom_identifier())
-                            {
-                                let doc_expr = ExprKind::Define(Box::new(Define::new(
-                                    ExprKind::atom(struct_name.to_string() + "__doc__"),
-                                    comment,
-                                    SyntaxObject::default(TokenType::Define),
-                                )));
-
-                                // let ast_name = ExprKind::atom(struct_name.to_string() + "__ast__");
-
-                                // let quoted_ast =
-                                // define_quoted_ast_node(ast_name, &top_level_define);
-
-                                return Ok(ExprKind::Begin(Begin::new(
-                                    vec![doc_expr, self.visit(top_level_define)?],
-                                    SyntaxObject::default(TokenType::Begin),
-                                )));
-                            }
-
-                            return self.visit(top_level_define);
-                        }
-
-                        // This should... probably happen after the expansion?
-                        ExprKind::List(unlowered_define)
-                            if unlowered_define.first_ident() == Some(&DEFINE)
-                                || unlowered_define
-                                    .first()
-                                    .and_then(|x| x.atom_syntax_object())
-                                    .map(|x| x.ty == TokenType::Define)
-                                    .unwrap_or_default() =>
-                        {
-                            // Depends on how this has been expanded at this point. We could have
-                            // (define (foo x) x) or (define foo (lambda (x) x))
-                            // So we need to handle accordingly, since the lowering hasn't happened
-                            // yet.
-
-                            // println!("Matching define");
-
-                            let name = match unlowered_define.get(1) {
-                                Some(ExprKind::List(l)) => l.first_ident(),
-                                Some(ExprKind::Atom(a)) => a.ident(),
-                                _ => return self.visit(top_level_define),
-                            }
-                            .unwrap();
-
-                            let doc_expr = ExprKind::Define(Box::new(Define::new(
-                                ExprKind::atom(name.resolve().to_string() + "__doc__"),
-                                comment,
-                                SyntaxObject::default(TokenType::Define),
-                            )));
-
-                            // let ast_name = ExprKind::atom(
-                            // d.name.atom_identifier().unwrap().to_string() + "__ast__",
-                            // );
-
-                            // Include the metadata table
-                            let metadata_table_addition = ExprKind::List(List::new(vec![
-                                ExprKind::atom("#%function-ptr-table-add"),
-                                ExprKind::atom("#%function-ptr-table"),
-                                ExprKind::atom(*name),
-                                ExprKind::atom(name.resolve().to_string() + "__doc__"),
-                            ]));
-
-                            let expanded_expr = self.visit(top_level_define)?;
-
-                            // let quoted_ast = define_quoted_ast_node(ast_name, &expanded_expr);
-
-                            return Ok(ExprKind::Begin(Begin::new(
-                                vec![doc_expr, expanded_expr, metadata_table_addition],
-                                SyntaxObject::default(TokenType::Begin),
-                            )));
-                        }
-
-                        ExprKind::List(unlowered_define)
-                            if unlowered_define.first_ident() == Some(&BEGIN) =>
-                        {
-                            return self.visit(top_level_define);
-                        }
-
-                        _ => {
-                            // println!("Not matching...");
-
-                            return self.visit(top_level_define);
-                        }
-                    }
-                }
-
-                */
-
-                if map
-                    .contains_syntax_object_macro(&s, self.environment.as_ref().map(|x| x.as_ref()))
-                    && self
-                        .allowed_macros
-                        .as_ref()
-                        .map(|x| x.contains(&s))
-                        .unwrap_or(true)
-                {
-                    let expanded = map.expand_syntax_object(
-                        &s,
-                        ExprKind::List(l),
-                        self.environment
-                            .as_ref()
-                            .map(|x| x.as_ref())
-                            .unwrap_or("default"),
-                    )?;
-                    self.changed = true;
-
-                    self.depth += 1;
-
-                    let result = self.visit(expanded);
-
-                    self.depth -= 1;
-
-                    return result;
-                }
-            }
-
-            //
-            if s == *REQUIRE_DYLIB {
-                match &l.args[1..] {
-                    [ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::StringLiteral(dylib_name),
-                                ..
-                            },
-                    }), ExprKind::List(List { args, .. })] => {
-                        // TODO: if it can't be found, the module needs to be marked as `MaybeDylib`
-                        // and use the binds that are listed in the dylib require spec, something like:
-                        // (require-builtin steel/obviouslydylib/sqlite (only-in ... ... ...)) <-
-                        // Then, we can _attempt_ to load the dylib at runtime. If we can't we move on, and
-                        // otherwise we can error if the identifiers are not lining up.
-                        // (require-dylib "<name>.so" (onlt-in <spec> ))
-
-                        // if let Some(module) = self.builtin_modules.get(s.as_str()) {
-                        //     return Ok(module.to_syntax(None));
-                        // } else {
-                        //     stop!(BadSyntax => "require-builtin: module not found: {}", s);
-                        // }
-
-                        match args.as_slice() {
-                            [ExprKind::Atom(Atom {
-                                syn:
-                                    SyntaxObject {
-                                        ty: TokenType::Identifier(s),
-                                        ..
-                                    },
-                            }), rest @ ..]
-                                if s.resolve() == "only-in" =>
-                            {
-                                // self.builtin_modules.
-
-                                let mut names = Vec::with_capacity(rest.len());
-
-                                for expr in rest {
-                                    if let Some(identifier) = expr.atom_identifier() {
-                                        names.push(identifier);
-                                    } else {
-                                        stop!(BadSyntax => "require-dylib `only-in` modifier expects identifiers")
-                                    }
-                                }
-
-                                return Ok(BuiltInModule::dylib_to_syntax(
-                                    dylib_name.as_str(),
-                                    names.iter().map(|x| x.resolve()),
-                                    None,
-                                ));
-                            }
-                            _ => {
-                                stop!(BadSyntax => "require-dylib expects on `only-in` modifier")
-                            }
-                        }
-                    }
-
-                    _ => {
-                        stop!(BadSyntax => "require-dylib malformed")
-                    }
-                }
-            }
-
-            if s == *REQUIRE_BUILTIN {
-                match &l.args[1..] {
-                    [ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::StringLiteral(s),
-                                span,
-                                ..
-                            },
-                    })] => {
-                        // TODO: if it can't be found, the module needs to be marked as `MaybeDylib`
-                        // and use the binds that are listed in the dylib require spec, something like:
-                        // (require-builtin steel/obviouslydylib/sqlite (only-in ... ... ...)) <-
-                        // Then, we can _attempt_ to load the dylib at runtime. If we can't we move on, and
-                        // otherwise we can error if the identifiers are not lining up.
-                        if let Some(module) = self.builtin_modules.get(s.as_str()) {
-                            return Ok(module.to_syntax(None));
-                        } else {
-                            stop!(BadSyntax => format!("require-builtin: module not found: {}", s); *span);
-                        }
-                    }
-
-                    [ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Identifier(s),
-                                span,
-                                ..
-                            },
-                    })] => {
-                        if let Some(module) = self.builtin_modules.get(s.resolve()) {
-                            return Ok(module.to_syntax(None));
-                        } else {
-                            stop!(BadSyntax => format!("require-builtin: module not found: {}", s); *span);
-                        }
-                    }
-
-                    [ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::StringLiteral(s),
-                                span,
-                                ..
-                            },
-                    }), ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Identifier(az),
-                                ..
-                            },
-                    }), ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Identifier(prefix),
-                                ..
-                            },
-                    })] if *az == *AS_KEYWORD => {
-                        if let Some(module) = self.builtin_modules.get(s.as_str()) {
-                            return Ok(module.to_syntax(Some(prefix.resolve())));
-                        } else {
-                            stop!(BadSyntax => format!("require-builtin: module not found: {}", s); *span);
-                        }
-                    }
-
-                    [ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Identifier(s),
-                                span,
-                                ..
-                            },
-                    }), ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Identifier(az),
-                                ..
-                            },
-                    }), ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Identifier(prefix),
-                                ..
-                            },
-                    })] if *az == *AS_KEYWORD => {
-                        if let Some(module) = self.builtin_modules.get(s.resolve()) {
-                            return Ok(module.to_syntax(Some(prefix.resolve())));
-                        } else {
-                            stop!(BadSyntax => format!("require-builtin: module not found: {}", s); *span);
-                        }
-                    }
-
-                    _ => {
-                        stop!(ArityMismatch => "require-builtin malformed - follows the pattern (require-builtin \"<module>\") or (require-builtin \"<module>\" as <prefix>")
-                    }
-                }
-            }
-        }
-
-        l.args = l
-            .args
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(ExprKind::List(l))
-    }
-
-    fn visit_syntax_rules(&mut self, l: Box<super::ast::SyntaxRules>) -> Self::Output {
-        dbg!(l.to_string());
-
-        stop!(Generic => "unexpected syntax-rules definition"; l.location.span)
-    }
-
-    fn visit_set(&mut self, mut s: Box<super::ast::Set>) -> Self::Output {
-        s.variable = self.visit(s.variable)?;
-        s.expr = self.visit(s.expr)?;
-        Ok(ExprKind::Set(s))
-    }
-
-    fn visit_require(&mut self, s: super::ast::Require) -> Self::Output {
-        Ok(ExprKind::Require(s))
-        // stop!(Generic => "unexpected require statement during expansion"; s.location.span)
-    }
-
-    fn visit_let(&mut self, mut l: Box<super::ast::Let>) -> Self::Output {
-        let mut visited_bindings = Vec::new();
-
-        for (binding, expr) in l.bindings {
-            visited_bindings.push((self.visit(binding)?, self.visit(expr)?));
-        }
-
-        l.bindings = visited_bindings;
-        l.body_expr = self.visit(l.body_expr)?;
-
-        Ok(ExprKind::Let(l))
-    }
-
-    fn visit(&mut self, expr: ExprKind) -> Self::Output {
-        if self.depth > 96 {
-            stop!(BadSyntax => "Current expansion depth of defmacro style macros exceeded: depth capped at 96"; get_span(&expr));
-        }
-
-        let res = match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Let(l) => self.visit_let(l),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-        };
-
-        // self.depth -= 1;
-
-        res
-    }
-}
-
-fn _define_quoted_ast_node(ast_name: ExprKind, expanded_expr: &ExprKind) -> ExprKind {
-    ExprKind::Define(Box::new(Define::new(
-        ast_name,
-        ExprKind::Quote(Box::new(Quote::new(
-            expanded_expr.clone(),
-            SyntaxObject::default(TokenType::Quote),
-        ))),
-        SyntaxObject::default(TokenType::Define),
-    )))
-}
-
-#[cfg(test)]
-mod expansion_tests {
-    use steel_parser::span::Span;
-
-    use super::*;
-
-    use crate::parser::expander::MacroCase;
-    use crate::parser::expander::MacroPattern;
-
-    use crate::parser::ast::{Begin, If, List};
-    use crate::parser::tokens::TokenType;
-
-    fn atom_identifier(s: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            s.into(),
-        ))))
-    }
-
-    fn ellipses() -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Ellipses)))
-    }
-
-    #[test]
-    fn test_basic_expansion() {
-        // (define-syntax when
-        //     (syntax-rules ()
-        //       [(when a b ...)
-        //        (if a (begin b ...) void)]))
-        let m = SteelMacro::new(
-            "when".into(),
-            Vec::new(),
-            vec![MacroCase::new(
-                vec![
-                    MacroPattern::Syntax("when".into()),
-                    MacroPattern::Single("a".into()),
-                    MacroPattern::Many("b".into()),
-                ],
-                If::new(
-                    atom_identifier("a"),
-                    Begin::new(
-                        vec![atom_identifier("b"), ellipses()],
-                        SyntaxObject::default(TokenType::Begin),
-                    )
-                    .into(),
-                    atom_identifier("void"),
-                    SyntaxObject::default(TokenType::If),
-                )
-                .into(),
-            )],
-            Span::default(),
-        );
-
-        let mut map = HashMap::new();
-        map.insert("when".into(), m);
-
-        let input: ExprKind = List::new(vec![
-            atom_identifier("when"),
-            atom_identifier("blagh"),
-            atom_identifier("do-thing"),
-        ])
-        .into();
-
-        let expected: ExprKind = If::new(
-            atom_identifier("blagh"),
-            Begin::new(
-                vec![atom_identifier("do-thing")],
-                SyntaxObject::default(TokenType::Begin),
-            )
-            .into(),
-            atom_identifier("void"),
-            SyntaxObject::default(TokenType::If),
-        )
-        .into();
-
-        let output = expand(input, &map).unwrap();
-
-        assert_eq!(expected, output)
-    }
-}
diff --git a/crates/steel-core/src/parser/expander.rs b/crates/steel-core/src/parser/expander.rs
deleted file mode 100644
index c049073cb..000000000
--- a/crates/steel-core/src/parser/expander.rs
+++ /dev/null
@@ -1,1364 +0,0 @@
-use crate::compiler::program::{BEGIN, DEFINE};
-use crate::parser::ast::{Atom, ExprKind, List, Macro, PatternPair};
-use crate::parser::parser::SyntaxObject;
-use crate::parser::rename_idents::RenameIdentifiersVisitor;
-use crate::parser::replace_idents::replace_identifiers;
-use crate::parser::tokens::TokenType;
-
-use crate::parser::span::Span;
-
-use crate::rvals::Result;
-use std::{
-    collections::HashMap,
-    fs::File,
-    io::{Read, Write},
-    iter::FromIterator,
-    path::{Path, PathBuf},
-};
-
-use log::error;
-use serde::{Deserialize, Serialize};
-use steel_parser::tokens::MaybeBigInt;
-
-use super::{ast::Quote, interner::InternedString, parser::Parser};
-
-// Given path, update the extension
-fn update_extension(mut path: PathBuf, extension: &str) -> PathBuf {
-    path.set_extension(extension);
-    path
-}
-
-// Prepend the given path with the working directory
-pub fn path_from_working_dir<P: AsRef<Path>>(path: P) -> std::io::Result<PathBuf> {
-    let mut working_dir = std::env::current_dir()?;
-    working_dir.push(path);
-    Ok(working_dir)
-}
-
-/// Manages macros for a single namespace
-#[derive(Default, Serialize, Deserialize, Debug)]
-pub struct LocalMacroManager {
-    macros: HashMap<InternedString, SteelMacro>,
-}
-
-impl LocalMacroManager {
-    /// Look to see if it exists on disk, otherwise parse from the associated file
-    pub fn initialize_from_path(path: PathBuf, force_update: bool) -> Result<Self> {
-        let raw_path = update_extension(path.clone(), "rkt");
-        let compiled_path = update_extension(path, "macro");
-
-        // println!("Raw path: {:?}", raw_path);
-        // println!("Compiled path: {:?}", compiled_path);
-
-        if compiled_path.exists() && !force_update {
-            Self::from_file(compiled_path)
-        } else if raw_path.exists() {
-            let parsed = Self::from_expression_file(raw_path)?;
-            parsed.write_to_file(compiled_path)?;
-
-            Ok(parsed)
-        } else {
-            stop!(Generic => "path to macro file does not exist")
-        }
-    }
-
-    fn write_to_file(&self, path: PathBuf) -> Result<()> {
-        let mut file = File::create(path)?;
-
-        match bincode::serialize(self) {
-            Ok(bytes) => {
-                file.write_all(&bytes)?;
-                Ok(())
-            }
-            Err(e) => stop!(Generic => format!("Unable to write macro to file: {e:?}")),
-        }
-    }
-
-    /// Expand the expressions according to the macros in the current scope
-    pub fn expand(&self, exprs: impl IntoIterator<Item = ExprKind>) -> Result<Vec<ExprKind>> {
-        exprs
-            .into_iter()
-            .map(|expr| crate::parser::expand_visitor::expand(expr, &self.macros))
-            .collect()
-    }
-
-    /// Read in a file of expressions containing macros, parse then, and create the data struture
-    fn from_expression_file(path: PathBuf) -> Result<Self> {
-        let mut file = File::open(path)?;
-        let mut raw_exprs = String::new();
-        file.read_to_string(&mut raw_exprs)?;
-        let parsed_exprs = Parser::parse(&raw_exprs)?;
-        Self::from_exprs(parsed_exprs)
-    }
-
-    /// After serializing the macro manager to a file and read from that file
-    fn from_file(path: PathBuf) -> Result<Self> {
-        let mut file = File::open(path)?;
-        let mut buffer = Vec::new();
-        let _ = file.read_to_end(&mut buffer)?;
-        match bincode::deserialize(&buffer) {
-            Ok(inner) => Ok(inner),
-            Err(e) => {
-                stop!(Generic => format!("Unable to deserialize local macro manager from file: {e:?}"))
-            }
-        }
-    }
-
-    /// Initialize the macro manager from a vec of macro expressions
-    /// Note: this will fail if passed other expressions
-    pub fn from_exprs(exprs: impl IntoIterator<Item = ExprKind>) -> Result<Self> {
-        exprs
-            .into_iter()
-            .map(|x| {
-                if let ExprKind::Macro(m) = x {
-                    SteelMacro::parse_from_ast_macro(m)
-                } else {
-                    stop!(Generic => "Unexpected non-macro definition")
-                }
-            })
-            .collect()
-    }
-}
-
-impl FromIterator<SteelMacro> for LocalMacroManager {
-    fn from_iter<T>(iter: T) -> Self
-    where
-        T: IntoIterator<Item = SteelMacro>,
-    {
-        Self {
-            macros: iter.into_iter().map(|x| (x.name.clone(), x)).collect(),
-        }
-    }
-}
-
-// Global macro manager, manages macros across modules
-pub struct GlobalMacroManager {
-    _scopes: HashMap<PathBuf, HashMap<String, SteelMacro>>,
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct SteelMacro {
-    name: InternedString,
-    special_forms: Vec<InternedString>,
-    cases: Vec<MacroCase>,
-    mangled: bool,
-    location: Span,
-}
-
-impl SteelMacro {
-    #[cfg(test)]
-    pub fn new(
-        name: InternedString,
-        special_forms: Vec<InternedString>,
-        cases: Vec<MacroCase>,
-        location: Span,
-    ) -> Self {
-        SteelMacro {
-            name,
-            special_forms,
-            cases,
-            mangled: false,
-            location,
-        }
-    }
-
-    pub fn name(&self) -> &InternedString {
-        &self.name
-    }
-
-    pub fn exprs_mut(&mut self) -> impl Iterator<Item = &mut ExprKind> {
-        self.cases.iter_mut().map(|x| &mut x.body)
-    }
-
-    pub fn exprs(&self) -> impl Iterator<Item = &ExprKind> {
-        self.cases.iter().map(|x| &x.body)
-    }
-
-    pub fn mark_mangled(&mut self) {
-        self.mangled = true;
-    }
-
-    pub fn is_mangled(&self) -> bool {
-        self.mangled
-    }
-
-    pub fn parse_from_ast_macro(ast_macro: Box<Macro>) -> Result<Self> {
-        let name = *ast_macro
-            .name
-            .atom_identifier_or_else(throw!(BadSyntax => "macros only currently support 
-                    identifiers as the name"; ast_macro.location.span))?;
-
-        let sp = ast_macro.location.span;
-
-        let special_forms = ast_macro
-            .syntax_rules
-            .syntax
-            .into_iter()
-            .map(|x| {
-                x.atom_identifier_or_else(
-                    throw!(BadSyntax => format!("macros only support identifiers for special syntax, found: {}", x); sp),
-                )
-                .cloned()
-            })
-            .collect::<Result<Vec<_>>>()?;
-
-        let cases = ast_macro
-            .syntax_rules
-            .patterns
-            .into_iter()
-            .map(|x| MacroCase::parse_from_pattern_pair(x, &name, &special_forms))
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(SteelMacro {
-            name,
-            special_forms,
-            cases,
-            mangled: false,
-            location: ast_macro.location.span,
-        })
-    }
-
-    // TODO the case matching should be a little bit more informed than this
-    // I think it should also not be greedy, and should report if there are ambiguous matchings
-    fn match_case(&self, expr: &List) -> Result<&MacroCase> {
-        for case in &self.cases {
-            if (case.has_ellipses() && expr.len() >= (case.arity() - 1))
-                || case.arity() == expr.len()
-            {
-                if case.recursive_match(expr) {
-                    return Ok(case);
-                }
-            }
-        }
-        error!("Macro expansion unable to match case with: {}", expr);
-
-        if let Some(ExprKind::Atom(a)) = expr.first() {
-            stop!(BadSyntax => format!("macro expansion unable to match case: {expr}"); a.syn.span);
-        } else {
-            unreachable!()
-        }
-    }
-
-    pub fn expand(&self, expr: List, span: Span) -> Result<ExprKind> {
-        // if log::log_enabled!(log::Level::Debug) {
-        //     log::debug!("Expanding macro with tokens: {}", expr);
-        // }
-
-        // log::debug!("Expanding with span: {:?}", span);
-
-        let case_to_expand = self.match_case(&expr)?;
-        let expanded_expr = case_to_expand.expand(expr, span)?;
-
-        // if log::log_enabled!(log::Level::Debug) {
-        //     debug!("Macro Expansion: {}", expanded_expr);
-        // }
-
-        Ok(expanded_expr)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct MacroCase {
-    args: Vec<MacroPattern>,
-    body: ExprKind,
-}
-
-impl MacroCase {
-    #[cfg(test)]
-    pub fn new(args: Vec<MacroPattern>, body: ExprKind) -> Self {
-        MacroCase { args, body }
-    }
-
-    fn parse_from_pattern_pair(
-        pattern_pair: PatternPair,
-        name: &InternedString,
-        special_forms: &[InternedString],
-    ) -> Result<Self> {
-        let PatternPair { pattern, mut body } = pattern_pair;
-
-        let args = if let ExprKind::List(l) = pattern {
-            MacroPattern::parse_from_list(l, name, special_forms)?
-        } else {
-            stop!(Generic => "unable to parse macro");
-        };
-
-        let args_str: Vec<&InternedString> = args
-            .iter()
-            .flat_map(|x| x.deconstruct_without_syntax())
-            .collect();
-
-        // let syntaxes: Vec<&str> = args
-        //     .iter()
-        //     .map(|x| x.deconstruct_syntax())
-        //     .flatten()
-        //     .collect();
-
-        // println!("Args pre mangle: {:?}", &args_str);
-
-        RenameIdentifiersVisitor::new(&args_str, special_forms).rename_identifiers(&mut body);
-
-        let args = args.into_iter().map(|x| x.mangle(special_forms)).collect();
-
-        // println!("Found args: {:?}", args);
-        // println!("Renamed body: {:?}", &body);
-
-        Ok(MacroCase { args, body })
-    }
-
-    fn has_ellipses(&self) -> bool {
-        self.args
-            .iter()
-            .any(|x| matches!(x, MacroPattern::Many(_) | MacroPattern::ManyNested(_)))
-    }
-
-    fn arity(&self) -> usize {
-        self.args
-            .iter()
-            .map(|x| if let MacroPattern::Many(_) = x { 1 } else { 1 })
-            .sum()
-    }
-
-    fn recursive_match(&self, list: &List) -> bool {
-        // Don't match on the first argument
-        match_vec_pattern(&self.args[1..], &list.args[1..])
-    }
-
-    fn expand(&self, expr: List, span: Span) -> Result<ExprKind> {
-        // TODO: Consider using a thread local allocation, and just
-        // clear the hashmap after each use?
-        let mut bindings = HashMap::new();
-        let mut binding_kind = HashMap::new();
-        let mut fallback_bindings = HashMap::new();
-        collect_bindings(
-            &self.args[1..],
-            &expr[1..],
-            &mut bindings,
-            &mut binding_kind,
-        )?;
-        replace_identifiers(
-            self.body.clone(),
-            &mut bindings,
-            &mut binding_kind,
-            &mut fallback_bindings,
-            span,
-        )
-    }
-}
-
-#[derive(Clone, PartialEq, Serialize, Deserialize)]
-pub enum MacroPattern {
-    Single(InternedString),
-    Syntax(InternedString),
-    Many(InternedString),
-    Nested(Vec<MacroPattern>),
-    ManyNested(Vec<MacroPattern>),
-    CharacterLiteral(char),
-    IntLiteral(isize),
-    StringLiteral(String),
-    FloatLiteral(f64),
-    BooleanLiteral(bool),
-    QuotedExpr(Box<Quote>),
-    Quote(InternedString),
-}
-
-// pub enum QuotedLiteral {
-
-// }
-
-impl std::fmt::Debug for MacroPattern {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            MacroPattern::Single(s) => f.debug_tuple("Single").field(&s.resolve()).finish(),
-            MacroPattern::Syntax(s) => f.debug_tuple("Syntax").field(&s.resolve()).finish(),
-            MacroPattern::Many(m) => f.debug_tuple("Many").field(&m.resolve()).finish(),
-            MacroPattern::Nested(n) => f.debug_tuple("Nested").field(n).finish(),
-            MacroPattern::CharacterLiteral(c) => {
-                f.debug_tuple("CharacterLiteral").field(c).finish()
-            }
-            MacroPattern::IntLiteral(i) => f.debug_tuple("IntLiteral").field(i).finish(),
-            MacroPattern::StringLiteral(s) => f.debug_tuple("StringLiteral").field(s).finish(),
-            MacroPattern::FloatLiteral(fl) => f.debug_tuple("FloatLiteral").field(fl).finish(),
-            MacroPattern::BooleanLiteral(b) => f.debug_tuple("BooleanLiteral").field(b).finish(),
-            MacroPattern::QuotedExpr(s) => f.debug_tuple("QuotedExpr").field(s).finish(),
-            MacroPattern::Quote(i) => f.debug_tuple("Quote").field(&i.resolve()).finish(),
-            MacroPattern::ManyNested(n) => f.debug_tuple("ManyNested").field(n).finish(),
-        }
-    }
-}
-
-impl MacroPattern {
-    fn mangle(&self, special_forms: &[InternedString]) -> Self {
-        use MacroPattern::*;
-        match self {
-            Single(s) => {
-                if special_forms.contains(s) {
-                    Single(*s)
-                } else {
-                    Single(("##".to_string() + s.resolve()).into())
-                }
-            }
-            Syntax(s) => {
-                // if special_forms.contains(s) {
-                Syntax(*s)
-                // } else {
-                // Syntax("##".to_string() + s)
-                // }
-            }
-            Many(s) => {
-                if special_forms.contains(s) {
-                    Many(*s)
-                } else {
-                    Many(("##".to_string() + s.resolve()).into())
-                }
-            }
-            // Silly, needs revisiting
-            ManyNested(m) => ManyNested(m.iter().map(|x| x.mangle(special_forms)).collect()),
-            Nested(v) => Nested(v.iter().map(|x| x.mangle(special_forms)).collect()),
-            _ => self.clone(),
-        }
-    }
-
-    fn parse_from_list(
-        list: List,
-        macro_name: &InternedString,
-        special_forms: &[InternedString],
-    ) -> Result<Vec<Self>> {
-        let mut pattern_vec: Vec<MacroPattern> = Vec::new();
-        let mut peek_token_iter = list.args.into_iter().peekable();
-
-        while let Some(token) = peek_token_iter.next() {
-            match token {
-                ExprKind::Atom(Atom {
-                    syn: SyntaxObject { ty: s, span, .. },
-                }) => match s {
-                    TokenType::Identifier(t) => {
-                        if t == *macro_name || special_forms.contains(&t) {
-                            pattern_vec.push(MacroPattern::Syntax(t.clone()))
-                        } else {
-                            match peek_token_iter.peek() {
-                                Some(ExprKind::Atom(Atom {
-                                    syn:
-                                        SyntaxObject {
-                                            ty: TokenType::Ellipses,
-                                            ..
-                                        },
-                                })) => {
-                                    peek_token_iter.next();
-                                    pattern_vec.push(MacroPattern::Many(t.clone()));
-                                }
-                                _ => {
-                                    pattern_vec.push(MacroPattern::Single(t.clone()));
-                                }
-                            }
-                        }
-                    }
-                    // TODO: Add all of the tokens here
-                    TokenType::Begin => {
-                        pattern_vec.push(MacroPattern::Syntax(*BEGIN));
-                    }
-                    TokenType::Define => {
-                        pattern_vec.push(MacroPattern::Syntax(*DEFINE));
-                    }
-                    TokenType::BooleanLiteral(b) => {
-                        pattern_vec.push(MacroPattern::BooleanLiteral(b));
-                    }
-                    TokenType::IntegerLiteral(MaybeBigInt::Small(i)) => {
-                        pattern_vec.push(MacroPattern::IntLiteral(i));
-                    }
-                    TokenType::CharacterLiteral(c) => {
-                        pattern_vec.push(MacroPattern::CharacterLiteral(c));
-                    }
-                    TokenType::NumberLiteral(n) => {
-                        pattern_vec.push(MacroPattern::FloatLiteral(n));
-                    }
-                    TokenType::StringLiteral(s) => {
-                        pattern_vec.push(MacroPattern::StringLiteral(s));
-                    }
-                    // TODO: Crunch the quoted values here, and pull them in so that this
-                    // holds a body of possible quoted values
-                    TokenType::Quote => {
-                        // pattern_vec.push(MacroPattern::Quote);
-                        // match peek_token_iter.peek() {
-                        //     Some(ExprKind::Atom(Atom {
-                        //         syn:
-                        //             SyntaxObject {
-                        //                 ty: TokenType::Ellipses,
-                        //                 ..
-                        //             },
-                        //     })) => {
-                        //         peek_token_iter.next();
-                        //         pattern_vec.push(MacroPattern::Many(t.clone()));
-                        //     }
-                        //     _ => {
-                        //         pattern_vec.push(MacroPattern::Single(t.clone()));
-                        //     }
-                        // }
-
-                        let next = peek_token_iter.next();
-
-                        match next {
-                            Some(ExprKind::Atom(Atom {
-                                syn:
-                                    SyntaxObject {
-                                        ty: TokenType::Identifier(s),
-                                        ..
-                                    },
-                            })) => {
-                                pattern_vec.push(MacroPattern::Quote(s));
-                            }
-                            _ => {
-                                stop!(TypeMismatch => "syntax-rules with quote don't 
-                                    yet support arbitrary constants yet")
-                                // pattern_vec.push(MacroPattern::Single(t.clone()));
-                            }
-                        }
-                    }
-                    TokenType::Ellipses => {
-                        if let Some(MacroPattern::Nested(inner)) = pattern_vec.pop() {
-                            pattern_vec.push(MacroPattern::ManyNested(inner));
-                        } else {
-                            stop!(BadSyntax => "cannot bind pattern to ellipses"; span)
-                        }
-                    }
-                    _ => {
-                        stop!(BadSyntax => "syntax-rules requires identifiers in the pattern"; span);
-                    }
-                },
-                ExprKind::List(l) => pattern_vec.push(MacroPattern::Nested(Self::parse_from_list(
-                    l,
-                    macro_name,
-                    special_forms,
-                )?)),
-                ExprKind::Quote(q) => pattern_vec.push(MacroPattern::QuotedExpr(q)),
-                _ => {
-                    // TODO: Add pattern matching on other kinds of forms here - probably just a special IR
-                    // for the pattern to match against here
-                    stop!(BadSyntax => format!("illegal special form found in macro pattern: {}", token));
-                }
-            }
-        }
-        Ok(pattern_vec)
-    }
-}
-
-impl MacroPattern {
-    // TODO make this not so trash
-    pub fn deconstruct(&self) -> Vec<&InternedString> {
-        match self {
-            Self::Syntax(s) => vec![s],
-            Self::Single(s) => vec![s],
-            Self::Many(s) => vec![s],
-            Self::ManyNested(v) => v.iter().flat_map(|x| x.deconstruct()).collect(),
-            Self::Nested(v) => v.iter().flat_map(|x| x.deconstruct()).collect(),
-            _ => vec![],
-        }
-    }
-
-    pub fn deconstruct_without_syntax(&self) -> Vec<&InternedString> {
-        match self {
-            Self::Single(s) => vec![s],
-            Self::Many(s) => vec![s],
-            Self::Nested(v) => v.iter().flat_map(|x| x.deconstruct()).collect(),
-            Self::ManyNested(v) => v.iter().flat_map(|x| x.deconstruct()).collect(),
-            _ => vec![],
-        }
-    }
-
-    pub fn is_many(&self) -> bool {
-        matches!(self, MacroPattern::Many(_) | MacroPattern::ManyNested(_))
-    }
-}
-
-pub fn match_vec_pattern(args: &[MacroPattern], list: &[ExprKind]) -> bool {
-    let mut token_iter = list.iter();
-
-    for pat in args {
-        if let Some(val) = token_iter.next() {
-            // dbg!(&pat);
-            // println!("{}", val);
-
-            match pat {
-                MacroPattern::Single(_) | MacroPattern::Many(_) => continue,
-                // TODO: @Matt - if the atom is bound locally, then do not match on this
-                MacroPattern::Syntax(v) => match val {
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Identifier(s),
-                                ..
-                            },
-                    }) if s == v => continue,
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Define,
-                                ..
-                            },
-                    }) if *v == *DEFINE => continue,
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Begin,
-                                ..
-                            },
-                    }) if *v == *BEGIN => continue,
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::Ellipses,
-                                ..
-                            },
-                    }) => continue,
-                    _ => return false,
-                },
-                MacroPattern::BooleanLiteral(b) => match val {
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::BooleanLiteral(s),
-                                ..
-                            },
-                    }) if s == b => continue,
-                    _ => return false,
-                },
-                MacroPattern::IntLiteral(i) => match val {
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::IntegerLiteral(MaybeBigInt::Small(s)),
-                                ..
-                            },
-                    }) if s == i => continue,
-                    _ => return false,
-                },
-                MacroPattern::FloatLiteral(f) => match val {
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::NumberLiteral(s),
-                                ..
-                            },
-                    }) if s == f => continue,
-                    _ => return false,
-                },
-                MacroPattern::CharacterLiteral(c) => match val {
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::CharacterLiteral(s),
-                                ..
-                            },
-                    }) if s == c => continue,
-                    _ => return false,
-                },
-                MacroPattern::StringLiteral(s) => match val {
-                    ExprKind::Atom(Atom {
-                        syn:
-                            SyntaxObject {
-                                ty: TokenType::StringLiteral(b),
-                                ..
-                            },
-                    }) if s == b => continue,
-                    _ => return false,
-                },
-                MacroPattern::QuotedExpr(q) => {
-                    // println!("MATCHING QUOTED EXPR: {}", q);
-                    match val {
-                        ExprKind::Quote(boxed_q) if q == boxed_q => continue,
-                        _ => {
-                            return false;
-                        }
-                    }
-                }
-                // TODO: Come back here and do constants
-                MacroPattern::Quote(_q) => {
-                    // println!("MATCHING QUOTE {} with val: {}", q, val);
-                    match val {
-                        ExprKind::Quote(_) => return true,
-
-                        // ExprKind::Atom(Atom {
-                        //     syn:
-                        //         SyntaxObject {
-                        //             ty: TokenType::Quote | TokenType::QuoteTick,
-                        //             ..
-                        //         },
-                        // }) => {
-                        //     println!("MATCHING ON QUOTE");
-                        //     continue;
-                        // }
-
-                        // ExprKind::Atom(Atom {
-                        //     syn:
-                        //         SyntaxObject {
-                        //             ty: TokenType::Identifier(s),
-                        //             ..
-                        //         },
-                        // }) if s.resolve() == "QUOTE" => {
-                        //     println!("MATCHING ON QUOTE");
-                        //     continue;
-                        // }
-                        // ExprKind::Quote()
-                        _ => return false,
-                    }
-                }
-                // Now that we have ManyNested - need to figure out
-                // the recursive step better here
-                MacroPattern::Nested(vec) => {
-                    if let ExprKind::List(l) = val {
-                        // TODO more elegant let* case
-                        if vec.is_empty() && !l.is_empty() {
-                            return false;
-                        }
-
-                        // This solves the destructuring test case
-                        if vec.len() < l.len() && !vec.iter().any(|x| x.is_many()) {
-                            // log::debug!("Matching failed - ellipses doesn't match up");
-                            return false;
-                        }
-
-                        // Make the recursive call on the next layer
-                        if match_vec_pattern(vec, l) {
-                            continue;
-                        } else {
-                            // log::debug!("Matching failed due to child not matching");
-                            return false;
-                        }
-                    } else if let ExprKind::Quote(_) = val {
-                        // TODO: Come back here
-                        return matches!(vec.as_slice(), &[MacroPattern::Quote(_)]);
-                        // return true;
-                    } else {
-                        // log::debug!("Matching failed - atom does not match list");
-                        return false;
-                    }
-                }
-                MacroPattern::ManyNested(vec) => {
-                    if let ExprKind::List(l) = val {
-                        if !match_vec_pattern(vec, l) {
-                            return false;
-                        }
-                    } else {
-                        return false;
-                    }
-
-                    for maybe_next in token_iter {
-                        if let ExprKind::List(l) = maybe_next {
-                            if match_vec_pattern(vec, l) {
-                                continue;
-                            }
-                        } else {
-                            return false;
-                        }
-                    }
-
-                    return true;
-                }
-            }
-        } else {
-            // In the case where we have no more patterns, we should be able to contninue matching
-            if pat.is_many() {
-                continue;
-            } else {
-                // log::debug!(
-                //     "Matching failed due to insufficient tokens - next pat: {:?}",
-                //     pat
-                // );
-                return false;
-            }
-        }
-    }
-
-    if token_iter.next().is_some() && !matches!(args.last(), Some(MacroPattern::Many(_))) {
-        // log::debug!("Matching failed due to leftover tokens");
-        return false;
-    }
-
-    true
-}
-
-pub enum BindingKind {
-    Many,
-    Single,
-}
-
-pub fn collect_bindings(
-    args: &[MacroPattern],
-    list: &[ExprKind],
-    bindings: &mut HashMap<InternedString, ExprKind>,
-    binding_kind: &mut HashMap<InternedString, BindingKind>,
-) -> Result<()> {
-    let mut token_iter = list.iter();
-
-    for arg in args {
-        match arg {
-            // bind the expression to a single variable
-            MacroPattern::Single(s) => {
-                if let Some(e) = token_iter.next() {
-                    bindings.insert(*s, e.clone());
-                } else {
-                    stop!(ArityMismatch => "macro invocation expected a value, found none");
-                }
-            }
-            // actually check if the syntax matches
-            MacroPattern::Syntax(s) => {
-                let error_func = throw!(BadSyntax => format!("macro expand expected keyword {s} - within {:?}", list));
-
-                let e = token_iter.next().ok_or_else(error_func)?;
-
-                if let ExprKind::Atom(Atom {
-                    syn:
-                        SyntaxObject {
-                            ty: TokenType::Identifier(syn),
-                            ..
-                        },
-                }) = e
-                {
-                    if s != syn {
-                        stop!(BadSyntax => "macro expansion expected keyword, found: {}", syn)
-                    }
-                }
-            }
-            // bind the ellipses to the rest of the statement
-            MacroPattern::Many(ident) => {
-                let rest: Vec<_> = token_iter.cloned().collect();
-                bindings.insert(*ident, List::new(rest).into());
-                binding_kind.insert(*ident, BindingKind::Many);
-                break;
-            }
-            MacroPattern::Nested(children) => {
-                let child = token_iter
-                    .next()
-                    .ok_or_else(throw!(ArityMismatch => "Macro expected a pattern"))?;
-
-                if let ExprKind::List(l) = child {
-                    collect_bindings(children, l, bindings, binding_kind)?;
-                } else if let ExprKind::Quote(q) = child {
-                    if let &[MacroPattern::Quote(x)] = children.as_slice() {
-                        bindings.insert(x, q.expr.clone());
-                    } else {
-                        stop!(BadSyntax => "macro expected a list of values, not including keywords, found: {}", child)
-                    }
-                } else {
-                    stop!(BadSyntax => "macro expected a list of values, not including keywords, found: {}", child)
-                }
-            }
-            MacroPattern::ManyNested(children) => {
-                // dbg!(children);
-
-                let exprs_to_destruct = token_iter.collect::<Vec<_>>();
-
-                for i in 0..children.len() {
-                    let mut values_to_bind = Vec::new();
-
-                    let is_ellipses_pattern = matches!(&children[i], MacroPattern::Many(_));
-
-                    for expr in &exprs_to_destruct {
-                        if let ExprKind::List(l) = expr {
-                            // Not what we want to do here!
-
-                            if is_ellipses_pattern {
-                                // Bind the "rest" of the values into this
-                                values_to_bind.push(List::new(l[i..].to_vec()).into());
-                            } else {
-                                values_to_bind.push(l[i].clone());
-                            }
-                        } else {
-                            unreachable!()
-                        }
-                    }
-
-                    match &children[i] {
-                        MacroPattern::Single(ident) => {
-                            let list_of_values = List::new(values_to_bind).into();
-
-                            // Turn this into a many!
-                            bindings.insert(*ident, list_of_values);
-                            binding_kind.insert(*ident, BindingKind::Many);
-                        }
-                        // MacroPattern::Syntax(_) => todo!(),
-                        MacroPattern::Many(ident) => {
-                            let list_of_values = List::new(values_to_bind).into();
-
-                            // println!("-- Binding: {} => {}", ident, list_of_values);
-
-                            bindings.insert(*ident, list_of_values);
-                            binding_kind.insert(*ident, BindingKind::Many);
-                        }
-                        // These I'll need to handle
-                        MacroPattern::Nested(nested_children) => {
-                            let mut final_bindings: HashMap<_, Vec<_>> = HashMap::new();
-
-                            for expr in values_to_bind {
-                                let list_expr =
-                                    expr.list_or_else(throw!(BadSyntax => "Unreachable!"))?;
-                                let mut new_bindings = HashMap::new();
-                                collect_bindings(
-                                    nested_children,
-                                    list_expr,
-                                    &mut new_bindings,
-                                    binding_kind,
-                                )?;
-
-                                for (key, value) in new_bindings {
-                                    // println!("Marking as a many binding => {}", key);
-                                    binding_kind.insert(key, BindingKind::Many);
-
-                                    if let Some(x) = final_bindings.get_mut(&key) {
-                                        x.push(value);
-                                    } else {
-                                        final_bindings.insert(key, vec![value]);
-                                    }
-                                }
-                            }
-
-                            for (key, value) in final_bindings {
-                                bindings.insert(key, List::new(value).into());
-                            }
-                        }
-                        MacroPattern::ManyNested(_) => {
-                            stop!(BadSyntax => "Internal compiler error - unexpected ellipses expansion found within ellipses expansion")
-                        }
-                        _ => {
-                            continue;
-                        }
-                    }
-                }
-
-                return Ok(());
-            }
-
-            MacroPattern::Quote(s) => {
-                if let Some(e) = token_iter.next() {
-                    if let ExprKind::Quote(inner) = e {
-                        bindings.insert(*s, inner.expr.clone());
-                    } else {
-                        stop!(Generic => "something went wrong with macro expansion")
-                    }
-                } else {
-                    stop!(ArityMismatch => "macro invocation expected a value, found none");
-                }
-            }
-
-            // Matching on literals
-            _ => {
-                token_iter.next();
-            }
-        }
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod match_vec_pattern_tests {
-    use super::*;
-
-    fn atom_identifier(s: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            s.into(),
-        ))))
-    }
-
-    fn atom_int(n: isize) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::IntegerLiteral(
-            MaybeBigInt::Small(n),
-        ))))
-    }
-
-    #[test]
-    fn test_match_basic() {
-        let pattern_args = vec![
-            MacroPattern::Syntax("and".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Single("b".into()),
-        ];
-        let list_expr = List::new(vec![
-            atom_identifier("and"),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        ]);
-
-        assert!(match_vec_pattern(&pattern_args, &list_expr));
-    }
-
-    #[test]
-    fn test_match_many() {
-        let pattern_args = vec![
-            MacroPattern::Syntax("and".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Many("b".into()),
-        ];
-        let list_expr = List::new(vec![
-            atom_identifier("and"),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        ]);
-        assert!(match_vec_pattern(&pattern_args, &list_expr));
-    }
-
-    #[test]
-    fn test_match_many_multiple() {
-        let pattern_args = vec![
-            MacroPattern::Syntax("and".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Many("b".into()),
-        ];
-        let list_expr = List::new(vec![
-            atom_identifier("and"),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-            atom_identifier("+"),
-            atom_identifier("x"),
-            atom_identifier("y"),
-        ]);
-        assert!(match_vec_pattern(&pattern_args, &list_expr));
-    }
-
-    #[test]
-    fn test_nested() {
-        let pattern_args = vec![
-            MacroPattern::Syntax("->>".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Nested(vec![
-                MacroPattern::Single("b".into()),
-                MacroPattern::Many("c".into()),
-            ]),
-        ];
-
-        let list_expr = List::new(vec![
-            atom_identifier("->>"),
-            atom_int(1),
-            ExprKind::List(List::new(vec![
-                atom_identifier("apple"),
-                atom_identifier("sauce"),
-                atom_identifier("is-good"),
-            ])),
-        ]);
-        assert!(match_vec_pattern(&pattern_args, &list_expr));
-    }
-
-    #[test]
-    fn test_no_match_simple() {
-        let pattern_args = vec![
-            MacroPattern::Syntax("->>".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Single("bad".into()),
-        ];
-
-        let list_expr = List::new(vec![
-            atom_identifier("->>"),
-            atom_int(1),
-            atom_int(2),
-            atom_int(3),
-        ]);
-
-        assert!(!match_vec_pattern(&pattern_args, &list_expr));
-    }
-
-    #[test]
-    fn test_nested_no_match() {
-        let pattern_args = vec![
-            MacroPattern::Syntax("->>".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Single("bad".into()),
-            MacroPattern::Nested(vec![
-                MacroPattern::Single("b".into()),
-                MacroPattern::Many("c".into()),
-            ]),
-        ];
-
-        let list_expr = List::new(vec![
-            atom_identifier("->>"),
-            atom_int(1),
-            ExprKind::List(List::new(vec![
-                atom_identifier("apple"),
-                atom_identifier("sauce"),
-                atom_identifier("is-good"),
-            ])),
-        ]);
-
-        assert!(!match_vec_pattern(&pattern_args, &list_expr));
-    }
-}
-
-#[cfg(test)]
-mod collect_bindings_tests {
-
-    use super::*;
-
-    fn atom_identifier(s: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            s.into(),
-        ))))
-    }
-
-    fn atom_int(n: isize) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::IntegerLiteral(
-            MaybeBigInt::Small(n),
-        ))))
-    }
-
-    #[test]
-    fn test_collect_basic() {
-        let mut bindings = HashMap::new();
-        let mut binding_kind = HashMap::new();
-        let pattern_args = vec![
-            MacroPattern::Syntax("and".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Single("b".into()),
-        ];
-        let list_expr = List::new(vec![
-            atom_identifier("and"),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        ]);
-
-        collect_bindings(&pattern_args, &list_expr, &mut bindings, &mut binding_kind).unwrap();
-
-        let mut post_bindings = HashMap::new();
-        post_bindings.insert(
-            "a".into(),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        );
-
-        post_bindings.insert(
-            "b".into(),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        );
-
-        assert_eq!(bindings, post_bindings);
-    }
-
-    #[test]
-    fn test_collect_many() {
-        let mut bindings = HashMap::new();
-        let mut binding_kind = HashMap::new();
-        let pattern_args = vec![
-            MacroPattern::Syntax("and".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Many("b".into()),
-        ];
-        let list_expr = List::new(vec![
-            atom_identifier("and"),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        ]);
-
-        collect_bindings(&pattern_args, &list_expr, &mut bindings, &mut binding_kind).unwrap();
-
-        let mut post_bindings = HashMap::new();
-        post_bindings.insert(
-            "a".into(),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        );
-        post_bindings.insert(
-            "b".into(),
-            ExprKind::List(List::new(vec![ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ]))])),
-        );
-
-        assert_eq!(bindings, post_bindings);
-    }
-
-    #[test]
-    fn test_collect_many_multiple_singles() {
-        let mut bindings = HashMap::new();
-        let mut binding_kind = HashMap::new();
-        let pattern_args = vec![
-            MacroPattern::Syntax("and".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Many("b".into()),
-        ];
-        let list_expr = List::new(vec![
-            atom_identifier("and"),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-            atom_identifier("+"),
-            atom_identifier("x"),
-            atom_identifier("y"),
-        ]);
-
-        collect_bindings(&pattern_args, &list_expr, &mut bindings, &mut binding_kind).unwrap();
-        let mut post_bindings = HashMap::new();
-
-        post_bindings.insert(
-            "a".into(),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        );
-
-        post_bindings.insert(
-            "b".into(),
-            ExprKind::List(List::new(vec![
-                atom_identifier("+"),
-                atom_identifier("x"),
-                atom_identifier("y"),
-            ])),
-        );
-
-        assert_eq!(bindings, post_bindings);
-    }
-
-    #[test]
-    fn test_nested() {
-        let mut bindings = HashMap::new();
-        let mut binding_kind = HashMap::new();
-        // (->> a (b c ...))
-        let pattern_args = vec![
-            MacroPattern::Syntax("->>".into()),
-            MacroPattern::Single("a".into()),
-            MacroPattern::Nested(vec![
-                MacroPattern::Single("b".into()),
-                MacroPattern::Many("c".into()),
-            ]),
-        ];
-
-        let list_expr = List::new(vec![
-            atom_identifier("->>"),
-            atom_int(1),
-            ExprKind::List(List::new(vec![
-                atom_identifier("apple"),
-                atom_identifier("sauce"),
-                atom_identifier("is-good"),
-            ])),
-        ]);
-
-        let mut post_bindings = HashMap::new();
-
-        collect_bindings(&pattern_args, &list_expr, &mut bindings, &mut binding_kind).unwrap();
-        post_bindings.insert("a".into(), atom_int(1));
-        post_bindings.insert("b".into(), atom_identifier("apple"));
-        post_bindings.insert(
-            "c".into(),
-            ExprKind::List(List::new(vec![
-                atom_identifier("sauce"),
-                atom_identifier("is-good"),
-            ])),
-        );
-
-        assert_eq!(bindings, post_bindings);
-    }
-}
-
-#[cfg(test)]
-mod macro_case_expand_test {
-    use super::MacroCase;
-
-    use super::*;
-
-    // macro_rules! map {
-    //     ($ ( $key:expr => $value:expr ), *,) => {{
-    //         let mut hm: HashMap<String, ExprKind> = HashMap::new();
-    //         $ (hm.insert($key.to_string(), $value); ) *
-    //         hm
-    //     }};
-    // }
-
-    fn atom_identifier(s: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            s.into(),
-        ))))
-    }
-
-    fn atom_int(n: isize) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::IntegerLiteral(
-            MaybeBigInt::Small(n),
-        ))))
-    }
-
-    #[test]
-    fn test_basic_expansion() {
-        let case = MacroCase {
-            args: vec![
-                MacroPattern::Syntax("test".into()),
-                MacroPattern::Single("a".into()),
-                MacroPattern::Single("b".into()),
-                MacroPattern::Single("c".into()),
-            ],
-            body: List::new(vec![
-                atom_identifier("fun-call"),
-                atom_identifier("inserted-variable"),
-                atom_identifier("a"),
-                atom_identifier("b"),
-                atom_identifier("c"),
-            ])
-            .into(),
-        };
-
-        let input = List::new(vec![
-            atom_identifier("test"),
-            atom_int(1),
-            atom_identifier("apple"),
-            atom_int(2),
-        ]);
-
-        let expected: ExprKind = List::new(vec![
-            atom_identifier("fun-call"),
-            atom_identifier("inserted-variable"),
-            atom_int(1),
-            atom_identifier("apple"),
-            atom_int(2),
-        ])
-        .into();
-
-        let output = case.expand(input, Span::new(0, 0, None)).unwrap();
-
-        assert_eq!(output, expected);
-    }
-}
diff --git a/crates/steel-core/src/parser/interner.rs b/crates/steel-core/src/parser/interner.rs
deleted file mode 100644
index c1c560578..000000000
--- a/crates/steel-core/src/parser/interner.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-pub use steel_parser::interner::*;
-
-use crate::{rvals::SteelString, SteelVal};
-
-impl From<InternedString> for SteelVal {
-    fn from(value: InternedString) -> Self {
-        SteelVal::StringV(value.into())
-    }
-}
-
-impl From<InternedString> for SteelString {
-    fn from(value: InternedString) -> Self {
-        value.resolve().into()
-    }
-}
diff --git a/crates/steel-core/src/parser/kernel.rs b/crates/steel-core/src/parser/kernel.rs
deleted file mode 100644
index aa089da6c..000000000
--- a/crates/steel-core/src/parser/kernel.rs
+++ /dev/null
@@ -1,547 +0,0 @@
-use std::{
-    collections::{HashMap, HashSet},
-    sync::{Arc, RwLock},
-};
-
-use steel_parser::tokens::TokenType;
-
-use crate::{
-    compiler::{
-        passes::analysis::SemanticAnalysis,
-        program::{RawProgramWithSymbols, BEGIN_FOR_SYNTAX, DEFMACRO},
-    },
-    parser::{
-        ast::{Atom, Set},
-        parser::SyntaxObject,
-    },
-    rvals::{Result, SteelString},
-    steel_vm::register_fn::RegisterFn,
-    values::lists::List,
-};
-use crate::{stdlib::KERNEL, steel_vm::engine::Engine, SteelVal};
-
-use steel_parser::expr_list;
-
-use super::{
-    ast::{ExprKind, TryFromSteelValVisitorForExprKind},
-    interner::InternedString,
-    replace_idents::RewriteSpan,
-    span_visitor::get_span,
-    visitors::ConsumingVisitor,
-};
-
-thread_local! {
-    pub(crate) static KERNEL_IMAGE: Engine = Engine::new_bootstrap_kernel();
-}
-
-pub(crate) fn fresh_kernel_image() -> Engine {
-    KERNEL_IMAGE.with(|x| x.clone())
-}
-
-type TransformerMap = HashMap<String, HashSet<InternedString>>;
-
-// Internal set of transformers that we'll embed
-#[derive(Clone, Debug)]
-struct Transformers {
-    set: Arc<RwLock<TransformerMap>>,
-}
-
-/// The Kernel is an engine context used to evaluate defmacro style macros
-/// It lives inside the compiler, so in theory there could be tiers of kernels
-/// Note: this will be called along side syntax rules style macros. In this case macro
-/// expansion then is a one step process, dispatching on the macros. However, at the moment this
-/// will not support user defined def macros -> this kernel will only support the built in def macros
-/// for structs.
-#[derive(Clone)]
-pub struct Kernel {
-    transformers: Transformers,
-    constants: HashSet<InternedString>,
-    pub(crate) engine: Box<Engine>,
-}
-
-impl Default for Kernel {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Kernel {
-    pub fn new() -> Self {
-        let mut engine = fresh_kernel_image();
-
-        let transformers = Transformers {
-            set: Arc::new(RwLock::new(HashMap::default())),
-        };
-
-        let embedded_transformer_object = transformers.clone();
-        engine.register_fn(
-            "register-macro-transformer!",
-            move |name: String, env: String| {
-                embedded_transformer_object
-                    .set
-                    .write()
-                    .unwrap()
-                    .entry(env)
-                    .or_default()
-                    .insert(name.as_str().into())
-            },
-        );
-
-        let embedded_transformer_object = transformers.clone();
-        engine.register_fn(
-            "current-macro-transformers!",
-            move |env: SteelString| -> SteelVal {
-                embedded_transformer_object
-                    .set
-                    .read()
-                    .unwrap()
-                    .get(env.as_str())
-                    .map(|set| {
-                        set.iter()
-                            .map(|x| x.resolve().to_string())
-                            .map(|x| SteelVal::SymbolV(x.into()))
-                            .collect::<crate::values::lists::List<SteelVal>>()
-                            .into()
-                    })
-                    .unwrap_or_else(|| SteelVal::ListV(List::new()))
-            },
-        );
-
-        // Run the script for building the core interface for structs
-        engine.compile_and_run_raw_program(KERNEL).unwrap();
-
-        // let mut macros = HashSet::new();
-        // macros.insert("%better-lambda%".to_string());
-        // macros.insert(*STRUCT_KEYWORD);
-        // macros.insert(*DEFINE_VALUES);
-
-        Kernel {
-            // macros,
-            transformers,
-            constants: HashSet::new(),
-            engine: Box::new(engine),
-        }
-    }
-
-    pub(crate) fn bootstrap(_engine: Engine) -> (Self, RawProgramWithSymbols) {
-        todo!()
-
-        // let transformers = Transformers {
-        //     set: Arc::new(RwLock::new(HashSet::default())),
-        // };
-
-        // let embedded_transformer_object = transformers.clone();
-        // engine.register_fn("register-macro-transformer!", move |name: String| {
-        //     embedded_transformer_object
-        //         .set
-        //         .write()
-        //         .unwrap()
-        //         .insert(name.as_str().into())
-        // });
-
-        // let embedded_transformer_object = transformers.clone();
-        // engine.register_fn("current-macro-transformers!", move || -> SteelVal {
-        //     embedded_transformer_object
-        //         .set
-        //         .read()
-        //         .unwrap()
-        //         .iter()
-        //         .map(|x| x.resolve().to_string())
-        //         .map(|x| SteelVal::SymbolV(x.into()))
-        //         .collect::<crate::values::lists::List<SteelVal>>()
-        //         .into()
-        // });
-
-        // Run the script for building the core interface for structs
-        // engine.compile_and_run_raw_program(KERNEL).unwrap();
-
-        // let raw_program = engine.emit_raw_program_no_path(KERNEL).unwrap();
-        // engine.run_raw_program(raw_program.clone()).unwrap();
-
-        // let mut macros = HashSet::new();
-        // macros.insert("%better-lambda%".to_string());
-        // macros.insert(*STRUCT_KEYWORD);
-        // macros.insert(*DEFINE_VALUES);
-
-        // (
-        //     Kernel {
-        //         // macros,
-        //         transformers,
-        //         constants: HashSet::new(),
-        //         engine: Box::new(engine),
-        //     },
-        //     raw_program,
-        // )
-    }
-
-    pub(crate) fn initialize_post_bootstrap(_engine: Engine) -> Self {
-        // let transformers = Transformers {
-        //     set: Arc::new(RwLock::new(HashSet::default())),
-        // };
-
-        // let embedded_transformer_object = transformers.clone();
-        // engine.register_fn("register-macro-transformer!", move |name: String| {
-        //     embedded_transformer_object
-        //         .set
-        //         .write()
-        //         .unwrap()
-        //         .insert(name.as_str().into())
-        // });
-
-        // let embedded_transformer_object = transformers.clone();
-        // engine.register_fn("current-macro-transformers!", move || -> SteelVal {
-        //     embedded_transformer_object
-        //         .set
-        //         .read()
-        //         .unwrap()
-        //         .iter()
-        //         .map(|x| x.resolve().to_string())
-        //         .map(|x| SteelVal::SymbolV(x.into()))
-        //         .collect::<crate::values::lists::List<SteelVal>>()
-        //         .into()
-        // });
-
-        // Kernel {
-        //     // macros,
-        //     transformers,
-        //     constants: HashSet::new(),
-        //     engine: Box::new(engine),
-        // }
-
-        todo!()
-    }
-
-    pub fn is_constant(&self, ident: &InternedString) -> bool {
-        self.constants.contains(ident)
-    }
-
-    // Define environment? Each module has its own set of transformers?
-    pub fn load_syntax_transformers(
-        &mut self,
-        exprs: &mut Vec<ExprKind>,
-        environment: String,
-    ) -> Result<()> {
-        enum IndexKind {
-            DefMacro(usize),
-            BeginForSyntax(usize),
-        }
-
-        let mut def_macro_expr_indices = Vec::new();
-
-        let mut provide_definitions = vec![ExprKind::ident("provide")];
-
-        for (i, expr) in exprs.iter_mut().enumerate() {
-            let first_ident = expr.list().and_then(|l| l.first_ident());
-
-            match first_ident {
-                Some(ident) if *ident == *DEFMACRO => {
-                    let underlying = expr.list_mut_or_else(|| unreachable!()).unwrap();
-
-                    match &underlying[1] {
-                        ExprKind::List(l) => provide_definitions.push(l[0].clone()),
-                        ExprKind::Atom(_) => {
-                            provide_definitions.push(underlying.args[1].clone());
-                        }
-                        _ => {
-                            let span = underlying[0].atom_syntax_object().unwrap().span;
-                            stop!(BadSyntax => "malformed defmacro"; span);
-                        }
-                    }
-
-                    underlying
-                        .args
-                        .insert(1, ExprKind::string_lit(environment.clone()));
-
-                    def_macro_expr_indices.push(IndexKind::DefMacro(i));
-                }
-
-                Some(ident) if *ident == *BEGIN_FOR_SYNTAX => {
-                    def_macro_expr_indices.push(IndexKind::BeginForSyntax(i));
-                }
-
-                _ => {}
-            }
-        }
-
-        if def_macro_expr_indices.is_empty() {
-            return Ok(());
-        }
-
-        // Fill up the define macro expressions with the correct ones
-        // Lets do some debug logging to make sure this even makes sense
-        // in the first place
-        let mut def_macro_exprs = Vec::with_capacity(def_macro_expr_indices.len());
-
-        def_macro_exprs.push(ExprKind::ident("#%syntax-transformer-module"));
-        def_macro_exprs.push(ExprKind::ident(&environment));
-        def_macro_exprs.push(ExprKind::List(steel_parser::ast::List::new(
-            provide_definitions,
-        )));
-
-        let mut exprs_buffer = Vec::with_capacity(def_macro_expr_indices.len());
-
-        while let Some(i) = def_macro_expr_indices.pop() {
-            match i {
-                IndexKind::DefMacro(i) => {
-                    let def_macro = exprs.remove(i);
-
-                    exprs_buffer.push(def_macro);
-                }
-                IndexKind::BeginForSyntax(i) => {
-                    let begin_for_syntax = exprs.remove(i);
-
-                    let mut iter = begin_for_syntax.into_list().args.into_iter();
-                    iter.next();
-
-                    exprs_buffer.extend(iter);
-                }
-            }
-        }
-
-        exprs_buffer.reverse();
-
-        def_macro_exprs.append(&mut exprs_buffer);
-
-        // Create the generated module
-        let generated_module = ExprKind::List(steel_parser::ast::List::new(def_macro_exprs));
-
-        // TODO: Load this as a module instead, so that way we have some real
-        // separation from each other.
-        //
-        // Meaning something like:
-        // (create-environment <environment> (provide <defmacros> ...) <defmacro definitions> ...)
-        //
-        // Expands into something like:
-        //
-        // (define env (let () <defmacro definitions> (hash <defmacro defs>)))
-        //
-        // Then, expansion would work by just interacting with that environment - something like
-        // (call-function-in-environment foo env)
-        // Which will extract the function from the module, and call it with the arguments. In theory
-        // that should give us the necessary isolation between modules that we want
-        // for the purposes of this.
-        self.engine
-            .run_raw_program_from_exprs(vec![generated_module])?;
-
-        Ok(())
-    }
-
-    // TODO: Have this report errors
-    pub fn load_program_for_comptime(
-        &mut self,
-        constants: im_rc::HashMap<InternedString, SteelVal>,
-        exprs: &mut Vec<ExprKind>,
-    ) -> Result<()> {
-        let mut analysis = SemanticAnalysis::new(exprs);
-
-        let result = analysis.run_black_box(constants, false);
-
-        // Only select expressions which are identified as constant
-        let subset = analysis
-            .exprs
-            .iter()
-            .filter_map(|expr| {
-                match expr {
-                    ExprKind::Define(define) => {
-                        if let ExprKind::LambdaFunction(_) = &define.body {
-                            let name = define.name.atom_identifier().unwrap().clone();
-
-                            return if result.contains_key(&name) {
-                                Some(expr.clone())
-                            } else if self.engine.global_exists(name.resolve()) {
-                                // If this global exists, nuke it in the engine
-
-                                self.engine.register_value(name.resolve(), SteelVal::Void);
-
-                                None
-                            } else {
-                                None
-                            };
-                        }
-                    }
-                    ExprKind::Begin(b) => {
-                        let begin = b
-                            .exprs
-                            .iter()
-                            .filter(|expr| {
-                                if let ExprKind::Define(define) = expr {
-                                    if let ExprKind::LambdaFunction(_) = &define.body {
-                                        let name = define.name.atom_identifier().unwrap().clone();
-
-                                        return if result.contains_key(&name) {
-                                            true
-                                        } else if self.engine.global_exists(name.resolve()) {
-                                            false
-                                        } else {
-                                            false
-                                        };
-                                    }
-                                }
-
-                                false
-                            })
-                            .cloned()
-                            .collect();
-
-                        return Some(ExprKind::Begin(crate::parser::ast::Begin::new(
-                            begin,
-                            b.location.clone(),
-                        )));
-                    }
-
-                    _ => {}
-                }
-
-                return None;
-
-                // TODO: Also check begin statements here as well
-                // if let ExprKind::Define(define) = expr {
-                //     if let ExprKind::LambdaFunction(_) = &define.body {
-                //         let name = define.name.atom_identifier().unwrap().clone();
-
-                //         return result.contains_key(&name);
-                //     }
-                // }
-            })
-            // .cloned()
-            .collect::<Vec<_>>();
-
-        log::debug!("Loading constant functions");
-
-        if subset.is_empty() {
-            log::debug!("Found no constant functions");
-
-            return Ok(());
-        }
-
-        self.engine.run_raw_program_from_exprs(subset)?;
-
-        fn set(var: ExprKind, expr: ExprKind) -> ExprKind {
-            ExprKind::Set(Box::new(Set::new(
-                var,
-                expr,
-                SyntaxObject::default(TokenType::Set),
-            )))
-        }
-
-        let mut set_idents = Vec::with_capacity(result.len());
-
-        let memoize: InternedString = "%make-memoize".into();
-
-        for ident in result.keys() {
-            self.constants.insert(ident.clone());
-
-            let set_ident = ExprKind::Atom(Atom::new(SyntaxObject::default(
-                TokenType::Identifier(ident.clone()),
-            )));
-            let memoize_expr = expr_list!(
-                ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-                    memoize.clone()
-                )))),
-                set_ident.clone()
-            );
-
-            set_idents.push(set(set_ident, memoize_expr));
-        }
-
-        self.engine.run_raw_program_from_exprs(set_idents)?;
-
-        log::debug!("Constant functions loaded");
-
-        // dbg!(&self
-        //     .constants
-        //     .iter()
-        //     .map(|x| x.resolve())
-        //     .collect::<Vec<_>>());
-
-        Ok(())
-
-        // todo!("Run through every expression, and memoize them by calling (set! <ident> (make-memoize <ident>))")
-    }
-
-    pub fn contains_syntax_object_macro(
-        &self,
-        ident: &InternedString,
-        environment: Option<&str>,
-    ) -> bool {
-        if let Some(environment) = environment {
-            // TODO: Come back to this - but we really just
-            // want a chain of environment that we've added to
-            // transformers
-            let base_environment = self
-                .transformers
-                .set
-                .read()
-                .unwrap()
-                .get(environment)
-                .map(|x| x.contains(ident))
-                .unwrap_or_default();
-
-            base_environment
-                || self
-                    .transformers
-                    .set
-                    .read()
-                    .unwrap()
-                    .get("default")
-                    .map(|x| x.contains(ident))
-                    .unwrap_or_default()
-        } else {
-            self.transformers
-                .set
-                .read()
-                .unwrap()
-                .get("default")
-                .map(|x| x.contains(ident))
-                .unwrap_or_default()
-        }
-    }
-
-    pub fn call_function(&mut self, ident: &InternedString, args: &[SteelVal]) -> Result<SteelVal> {
-        let function = self.engine.extract_value(ident.resolve())?;
-
-        self.engine.call_function_with_args(function, args.to_vec())
-    }
-
-    pub(crate) fn expand_syntax_object(
-        &mut self,
-        ident: &InternedString,
-        expr: ExprKind,
-        environment: &str,
-    ) -> Result<ExprKind> {
-        // println!("Expanding: {} with {}", ident, expr);
-
-        let span = get_span(&expr);
-
-        let syntax_objects =
-            super::tryfrom_visitor::SyntaxObjectFromExprKind::try_from_expr_kind(expr.clone())?;
-
-        let function = if environment == "default" {
-            // TODO: This actually needs to go through the proper resolution process,
-            // probably some sort of transformer map.
-            self.engine.extract_value(ident.resolve())?
-        } else {
-            // Check if there is anything to expand in this environment
-            if let Ok(SteelVal::HashMapV(map)) = self.engine.extract_value(environment) {
-                if let Some(func) = map.get(&SteelVal::SymbolV(ident.resolve().to_string().into()))
-                {
-                    func.clone()
-                } else {
-                    self.engine.extract_value(ident.resolve())?
-                }
-            } else {
-                self.engine.extract_value(ident.resolve())?
-            }
-        };
-
-        let result = self
-            .engine
-            .call_function_with_args(function, vec![syntax_objects])
-            .map_err(|x| x.set_span(span))?;
-
-        // This shouldn't be lowering all the way. It should just be back to list right?
-        TryFromSteelValVisitorForExprKind::root(&result)
-            // TODO: We don't want this forever, but for now its okay
-            .and_then(|x| RewriteSpan::new(span).visit(x))
-    }
-}
diff --git a/crates/steel-core/src/parser/lexer.rs b/crates/steel-core/src/parser/lexer.rs
deleted file mode 100644
index b8047a602..000000000
--- a/crates/steel-core/src/parser/lexer.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub use steel_parser::lexer::{OwnedTokenStream, TokenStream};
diff --git a/crates/steel-core/src/parser/mod.rs b/crates/steel-core/src/parser/mod.rs
deleted file mode 100644
index 47cd99566..000000000
--- a/crates/steel-core/src/parser/mod.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-pub mod ast;
-pub mod builder;
-pub mod expand_visitor;
-pub mod expander;
-pub mod interner;
-pub mod kernel;
-pub mod lexer;
-#[allow(clippy::module_inception)]
-pub mod parser;
-pub mod rename_idents;
-pub mod replace_idents;
-pub mod span;
-pub mod span_visitor;
-pub mod tokens;
-pub mod tryfrom_visitor;
-pub mod visitors;
-
-#[cfg(test)]
-mod prop;
diff --git a/crates/steel-core/src/parser/parser.rs b/crates/steel-core/src/parser/parser.rs
deleted file mode 100644
index 43ca1333a..000000000
--- a/crates/steel-core/src/parser/parser.rs
+++ /dev/null
@@ -1,204 +0,0 @@
-use crate::rvals::{IntoSteelVal, SteelString};
-use crate::{parser::tokens::TokenType::*, rvals::FromSteelVal};
-
-use std::str;
-use std::sync::{Arc, Mutex};
-use std::{collections::HashMap, path::PathBuf};
-use steel_parser::tokens::MaybeBigInt;
-
-use serde::{Deserialize, Serialize};
-use std::convert::TryFrom;
-
-use crate::rerrs::{ErrorKind, SteelErr};
-use crate::rvals::SteelVal;
-use crate::rvals::SteelVal::*;
-
-pub use steel_parser::parser::{
-    lower_entire_ast, lower_macro_and_require_definitions, lower_syntax_rules, FunctionId, ListId,
-    ParseError, Parser, RawSyntaxObject, SourceId, SyntaxObject, SyntaxObjectId, SYNTAX_OBJECT_ID,
-};
-
-impl IntoSteelVal for SourceId {
-    fn into_steelval(self) -> crate::rvals::Result<SteelVal> {
-        self.0.into_steelval()
-    }
-}
-
-impl FromSteelVal for SourceId {
-    fn from_steelval(val: &SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::IntV(v) = val {
-            Ok(SourceId(*v as usize))
-        } else {
-            stop!(TypeMismatch => "Unable to convert steelval: {} into source id", val)
-        }
-    }
-}
-
-#[derive(Default, Clone, Serialize, Deserialize)]
-pub(crate) struct InterierSources {
-    paths: HashMap<SourceId, PathBuf>,
-    reverse: HashMap<PathBuf, SourceId>,
-    sources: Vec<String>,
-}
-
-impl InterierSources {
-    pub fn new() -> Self {
-        InterierSources {
-            paths: HashMap::new(),
-            reverse: HashMap::new(),
-            sources: Vec::new(),
-        }
-    }
-
-    pub fn size_in_bytes(&self) -> usize {
-        self.sources
-            .iter()
-            .map(|x| std::mem::size_of_val(&*x))
-            .sum()
-    }
-
-    // TODO: Source Id should probably be a weak pointer back here rather than an ID
-    // that way if in the event we _do_ leak some strings or the sources are just unreachable
-    // we can clean up any remaining things
-    pub fn add_source(&mut self, source: String, path: Option<PathBuf>) -> SourceId {
-        // We're overwriting the existing source
-        if let Some(path) = &path {
-            if let Some(id) = self.reverse.get(path) {
-                self.sources[id.0] = source;
-                return *id;
-            }
-        }
-
-        let index = self.sources.len();
-        self.sources.push(source);
-
-        let id = SourceId(index);
-
-        if let Some(path) = path {
-            self.paths.insert(id, path.clone());
-            self.reverse.insert(path, id);
-        }
-
-        id
-    }
-
-    pub fn get(&self, source_id: SourceId) -> Option<&String> {
-        self.sources.get(source_id.0)
-    }
-
-    pub fn get_path(&self, source_id: &SourceId) -> Option<PathBuf> {
-        self.paths.get(source_id).cloned()
-    }
-
-    pub fn get_id(&self, path: &PathBuf) -> Option<SourceId> {
-        self.reverse.get(path).copied()
-    }
-}
-
-#[derive(Clone, Serialize, Deserialize)]
-pub struct Sources {
-    pub(crate) sources: Arc<Mutex<InterierSources>>,
-}
-
-impl Default for Sources {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Sources {
-    pub fn new() -> Self {
-        Sources {
-            sources: Arc::new(Mutex::new(InterierSources::new())),
-        }
-    }
-
-    pub fn add_source(&mut self, source: String, path: Option<PathBuf>) -> SourceId {
-        self.sources.lock().unwrap().add_source(source, path)
-    }
-
-    pub fn get_source_id(&self, path: &PathBuf) -> Option<SourceId> {
-        self.sources.lock().unwrap().get_id(path)
-    }
-
-    pub fn get_path(&self, source_id: &SourceId) -> Option<PathBuf> {
-        self.sources.lock().unwrap().get_path(source_id)
-    }
-
-    pub fn size_in_bytes(&self) -> usize {
-        self.sources.lock().unwrap().size_in_bytes()
-    }
-}
-
-thread_local! {
-    static LAMBDA_SYMBOL: SteelString = "lambda".into();
-}
-
-impl TryFrom<SyntaxObject> for SteelVal {
-    type Error = SteelErr;
-
-    fn try_from(e: SyntaxObject) -> std::result::Result<Self, Self::Error> {
-        let span = e.span;
-        match e.ty {
-            OpenParen => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, "(".to_string()).with_span(span))
-            }
-            CloseParen => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, ")".to_string()).with_span(span))
-            }
-            CharacterLiteral(x) => Ok(CharV(x)),
-            BooleanLiteral(x) => Ok(BoolV(x)),
-            Identifier(x) => Ok(SymbolV(x.into())),
-            NumberLiteral(x) => Ok(NumV(x)),
-            IntegerLiteral(MaybeBigInt::Small(x)) => Ok(IntV(x)),
-
-            IntegerLiteral(MaybeBigInt::Big(b)) => b.into_steelval(),
-
-            StringLiteral(x) => Ok(StringV(x.into())),
-            Keyword(x) => Ok(SymbolV(x.into())),
-            QuoteTick => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, "'".to_string()).with_span(span))
-            }
-            Unquote => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, ",".to_string()).with_span(span))
-            }
-            QuasiQuote => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, "`".to_string()).with_span(span))
-            }
-            UnquoteSplice => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, ",@".to_string()).with_span(span))
-            }
-            Error => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, "error".to_string()).with_span(span))
-            }
-            Comment => Err(
-                SteelErr::new(ErrorKind::UnexpectedToken, "comment".to_string()).with_span(span),
-            ),
-            If => Ok(SymbolV("if".into())),
-            Define => Ok(SymbolV("define".into())),
-            Let => Ok(SymbolV("let".into())),
-            TestLet => Ok(SymbolV("%plain-let".into())),
-            Return => Ok(SymbolV("return!".into())),
-            Begin => Ok(SymbolV("begin".into())),
-            Lambda => Ok(SymbolV(LAMBDA_SYMBOL.with(|x| x.clone()))),
-            Quote => Ok(SymbolV("quote".into())),
-            DefineSyntax => Ok(SymbolV("define-syntax".into())),
-            SyntaxRules => Ok(SymbolV("syntax-rules".into())),
-            Ellipses => Ok(SymbolV("...".into())),
-            Set => Ok(SymbolV("set!".into())),
-            Require => Ok(SymbolV("require".into())),
-            QuasiQuoteSyntax => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, "#`".to_string()).with_span(span))
-            }
-            UnquoteSyntax => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, "#,".to_string()).with_span(span))
-            }
-            QuoteSyntax => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, "#'".to_string()).with_span(span))
-            }
-            UnquoteSpliceSyntax => {
-                Err(SteelErr::new(ErrorKind::UnexpectedToken, "#,@".to_string()).with_span(span))
-            }
-        }
-    }
-}
diff --git a/crates/steel-core/src/parser/prop/mod.rs b/crates/steel-core/src/parser/prop/mod.rs
deleted file mode 100644
index ade27398c..000000000
--- a/crates/steel-core/src/parser/prop/mod.rs
+++ /dev/null
@@ -1,189 +0,0 @@
-use super::parser::SyntaxObject;
-use super::tokens::TokenType;
-use super::{ast::*, interner::InternedString};
-use crate::parser::parser::Parser;
-use crate::parser::span::Span;
-// use super::
-use proptest::prelude::*;
-use std::convert::TryFrom;
-
-use crate::parser::ast::{Atom, Begin, Define, If, List, Quote};
-
-// #[derive(Clone, Debug, PartialEq)]
-// pub enum ExprKind {
-//     Atom(Atom),
-//     If(Box<If>),
-//     Define(Box<Define>),
-//     LambdaFunction(Box<LambdaFunction>),
-//     Begin(Begin),
-//     Return(Box<Return>),
-//     Apply(Box<Apply>),
-//     Panic(Box<Panic>),
-//     Transduce(Box<Transduce>),
-//     Read(Box<Read>),
-//     Execute(Box<Execute>),
-//     Quote(Box<Quote>),
-//     Struct(Box<Struct>),
-//     Macro(Macro),
-//     SyntaxRules(SyntaxRules),
-//     Eval(Box<Eval>),
-//     List(List),
-//     Set(Box<Set>),
-// }
-
-proptest! {
-    // The next line modifies the number of tests.
-    #![proptest_config(ProptestConfig::with_cases(100))]
-    #[ignore]
-    #[test]
-    fn test_basic(expr in exprkind_strategy()) {
-
-        let expr_string = expr.to_string();
-
-        println!("{expr_string}");
-
-        let resulting_expr = Parser::parse(&expr_string).unwrap();
-
-        assert_eq!(expr, resulting_expr[0]);
-    }
-}
-
-fn if_vec_strategy(
-    inner: impl Strategy<Value = ExprKind> + Clone,
-) -> impl Strategy<Value = ExprKind> {
-    prop::collection::vec(inner, 3).prop_map(|x| {
-        ExprKind::If(Box::new(If::new(
-            x[0].clone(),
-            x[1].clone(),
-            x[2].clone(),
-            SyntaxObject::default(TokenType::If),
-        )))
-    })
-}
-
-fn define_vec_strategy(
-    inner: impl Strategy<Value = ExprKind> + Clone,
-) -> impl Strategy<Value = ExprKind> {
-    (
-        prop::collection::vec(inner, 0..10),
-        atom_identifier_strategy().prop_map(ExprKind::Atom),
-    )
-        .prop_map(|(vector, identifier)| {
-            ExprKind::Define(Box::new(Define::new(
-                identifier,
-                ExprKind::try_from(vector).unwrap(),
-                SyntaxObject::default(TokenType::Define),
-            )))
-        })
-}
-
-fn begin_vec_strategy(
-    inner: impl Strategy<Value = ExprKind> + Clone,
-) -> impl Strategy<Value = ExprKind> {
-    prop::collection::vec(inner, 0..10).prop_map(|x| {
-        ExprKind::Begin(Begin::new(
-            x,
-            SyntaxObject::new(TokenType::Begin, Span::new(0, 0, None)),
-        ))
-    })
-}
-
-fn naive_list_vec_strategy(
-    inner: impl Strategy<Value = ExprKind> + Clone,
-) -> impl Strategy<Value = ExprKind> {
-    prop::collection::vec(inner, 0..10).prop_map(|x| {
-        if x.is_empty() {
-            ExprKind::Quote(Box::new(Quote::new(
-                ExprKind::List(List::new(x)),
-                SyntaxObject::default(TokenType::Quote),
-            )))
-        } else {
-            ExprKind::List(List::new(x))
-        }
-    })
-}
-
-fn exprkind_strategy() -> BoxedStrategy<ExprKind> {
-    let leaf = atom_strategy().prop_map(ExprKind::Atom);
-
-    leaf.prop_recursive(4, 64, 10, |inner| {
-        prop_oneof![
-            define_vec_strategy(inner.clone()),
-            if_vec_strategy(inner.clone()),
-            begin_vec_strategy(inner.clone()),
-            naive_list_vec_strategy(inner)
-        ]
-    })
-    .boxed()
-}
-
-prop_compose! {
-    fn atom_strategy()(
-        syntax_object in syntax_object_strategy()
-    ) -> Atom {
-        Atom::new(syntax_object)
-    }
-}
-
-prop_compose! {
-    fn if_strategy()(
-        test_expr in exprkind_strategy(),
-        then_expr in exprkind_strategy(),
-        else_expr in exprkind_strategy()
-    ) -> If {
-        If::new(test_expr, then_expr, else_expr, SyntaxObject::default(TokenType::If))
-    }
-}
-
-prop_compose! {
-    fn define_strategy()(
-        name in atom_identifier_strategy().prop_map(ExprKind::Atom),
-        body in exprkind_strategy()
-    ) -> Define {
-        Define::new(name, body, SyntaxObject::default(TokenType::Define))
-    }
-}
-
-fn tokentype_strategy() -> impl Strategy<Value = TokenType<InternedString>> {
-    use TokenType::*;
-    prop_oneof![
-        any::<char>().prop_map(CharacterLiteral),
-        string_strategy().prop_map(StringLiteral),
-        ident_strategy().prop_map(Identifier),
-        any::<isize>().prop_map(|x| IntegerLiteral(steel_parser::tokens::MaybeBigInt::Small(x))),
-        any::<bool>().prop_map(BooleanLiteral),
-        any::<f64>().prop_map(NumberLiteral)
-    ]
-}
-
-prop_compose! {
-    fn string_strategy()(
-        str_lit in r#"([^"\\]|\\t|\\u|\\n|\\")*"#
-    ) -> String {
-        str_lit
-    }
-}
-
-prop_compose! {
-    fn ident_strategy()(
-        ident in r#"[_\+\-\*\x2F%\&\|!?\~<>=@\.\p{XID_Start}\p{Emoji_Presentation}]['_\+\-\*\x2F%\&\|!?\~<>=@\.\p{XID_Continue}\p{Emoji_Presentation}]*"#
-    ) -> InternedString {
-        ident.into()
-    }
-}
-
-prop_compose! {
-    fn atom_identifier_strategy()(
-        identifier in ident_strategy().prop_map(TokenType::Identifier)
-    ) -> Atom {
-        Atom::new(SyntaxObject::default(identifier))
-    }
-}
-
-prop_compose! {
-    fn syntax_object_strategy()(
-        token_type in tokentype_strategy()
-    ) -> SyntaxObject {
-        SyntaxObject::new(token_type, Span::new(0, 0, None))
-    }
-}
diff --git a/crates/steel-core/src/parser/rename_idents.rs b/crates/steel-core/src/parser/rename_idents.rs
deleted file mode 100644
index f93b62261..000000000
--- a/crates/steel-core/src/parser/rename_idents.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-use crate::parser::ast::ExprKind;
-use crate::parser::parser::SyntaxObject;
-use crate::parser::tokens::TokenType;
-use crate::parser::visitors::VisitorMutRef;
-
-use std::collections::HashSet;
-
-use super::interner::InternedString;
-
-pub struct RenameIdentifiersVisitor<'a> {
-    introduced_identifiers: HashSet<InternedString>,
-    pattern_variables: &'a [&'a InternedString],
-    syntax: &'a [InternedString],
-}
-
-impl<'a> RenameIdentifiersVisitor<'a> {
-    pub fn new(pattern_variables: &'a [&'a InternedString], syntax: &'a [InternedString]) -> Self {
-        RenameIdentifiersVisitor {
-            introduced_identifiers: HashSet::new(),
-            pattern_variables,
-            syntax,
-        }
-    }
-
-    pub fn add(&mut self, ident: InternedString) {
-        self.introduced_identifiers.insert(ident);
-    }
-
-    pub fn is_gensym(&self, ident: &InternedString) -> bool {
-        self.introduced_identifiers.contains(ident) || self.pattern_variables.contains(&ident)
-    }
-
-    pub fn rename_identifiers(&mut self, expr: &mut ExprKind) {
-        self.visit(expr);
-    }
-}
-
-impl<'a> VisitorMutRef for RenameIdentifiersVisitor<'a> {
-    type Output = ();
-
-    fn visit_if(&mut self, f: &mut super::ast::If) -> Self::Output {
-        self.visit(&mut f.test_expr);
-        self.visit(&mut f.then_expr);
-        self.visit(&mut f.else_expr);
-    }
-
-    fn visit_define(&mut self, define: &mut super::ast::Define) -> Self::Output {
-        if let ExprKind::Atom(a) = &mut define.name {
-            if let SyntaxObject {
-                ty: TokenType::Identifier(ref s),
-                ..
-            } = a.syn
-            {
-                // If this is a special pattern variable, don't do any mangling of the variable
-                if !self.pattern_variables.contains(&s) {
-                    self.add(*s);
-                    // a.syn = SyntaxObject::default(TokenType::Identifier("##".to_string() + s));
-                }
-
-                a.syn = SyntaxObject::default(TokenType::Identifier(
-                    ("##".to_string() + s.resolve()).into(),
-                ));
-            }
-        }
-
-        self.visit(&mut define.body)
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        lambda_function: &mut super::ast::LambdaFunction,
-    ) -> Self::Output {
-        // todo!()
-        for arg in &mut lambda_function.args {
-            if let ExprKind::Atom(a) = arg {
-                if let SyntaxObject {
-                    ty: TokenType::Identifier(ref s),
-                    ..
-                } = a.syn
-                {
-                    if !self.pattern_variables.contains(&s) {
-                        self.add(*s);
-                        // a.syn = SyntaxObject::default(TokenType::Identifier("##".to_string() + s));
-                    }
-
-                    a.syn = SyntaxObject::default(TokenType::Identifier(
-                        ("##".to_string() + s.resolve()).into(),
-                    ));
-                }
-            }
-        }
-
-        self.visit(&mut lambda_function.body)
-    }
-
-    fn visit_begin(&mut self, begin: &mut super::ast::Begin) -> Self::Output {
-        for expr in &mut begin.exprs {
-            self.visit(expr)
-        }
-    }
-
-    fn visit_return(&mut self, r: &mut super::ast::Return) -> Self::Output {
-        self.visit(&mut r.expr)
-    }
-
-    fn visit_quote(&mut self, quote: &mut super::ast::Quote) -> Self::Output {
-        self.visit(&mut quote.expr);
-    }
-
-    fn visit_macro(&mut self, _m: &mut super::ast::Macro) -> Self::Output {
-        todo!()
-    }
-
-    fn visit_atom(&mut self, a: &mut super::ast::Atom) -> Self::Output {
-        let token = a.syn.ty.clone();
-        if let TokenType::Identifier(s) = token {
-            if self.syntax.contains(&s) {
-                return;
-            }
-
-            if self.is_gensym(&s) {
-                a.syn.ty = TokenType::Identifier(("##".to_string() + s.resolve()).into());
-            }
-        }
-    }
-
-    fn visit_list(&mut self, l: &mut super::ast::List) -> Self::Output {
-        for expr in &mut l.args {
-            self.visit(expr);
-        }
-    }
-
-    fn visit_syntax_rules(&mut self, _l: &mut super::ast::SyntaxRules) -> Self::Output {
-        todo!()
-    }
-
-    fn visit_set(&mut self, s: &mut super::ast::Set) -> Self::Output {
-        self.visit(&mut s.variable);
-        self.visit(&mut s.expr);
-    }
-
-    fn visit_require(&mut self, s: &mut super::ast::Require) -> Self::Output {
-        for module in &mut s.modules {
-            self.visit(module);
-        }
-    }
-
-    fn visit_let(&mut self, l: &mut super::ast::Let) -> Self::Output {
-        for (_, expr) in &mut l.bindings {
-            self.visit(expr);
-        }
-
-        self.visit(&mut l.body_expr);
-    }
-}
-
-#[cfg(test)]
-mod rename_visitor_tests {
-
-    use steel_parser::tokens::MaybeBigInt;
-
-    use super::TokenType::*;
-    use super::*;
-    use crate::parser::ast::{Atom, Define, If, LambdaFunction, List};
-
-    fn atom_identifier(s: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            s.into(),
-        ))))
-    }
-
-    fn atom_int(n: isize) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::IntegerLiteral(
-            MaybeBigInt::Small(n),
-        ))))
-    }
-
-    #[test]
-    fn test_rename_identifiers() {
-        let mut pre_condition = ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-            vec![ExprKind::Atom(Atom::new(SyntaxObject::default(
-                Identifier("x".into()),
-            )))],
-            ExprKind::List(List::new(vec![
-                ExprKind::Atom(Atom::new(SyntaxObject::default(Identifier("+".into())))),
-                ExprKind::Atom(Atom::new(SyntaxObject::default(Identifier("x".into())))),
-                atom_int(10),
-            ])),
-            SyntaxObject::default(TokenType::Lambda),
-        )));
-
-        let post_condition = ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-            vec![ExprKind::Atom(Atom::new(SyntaxObject::default(
-                Identifier("##x".into()),
-            )))],
-            ExprKind::List(List::new(vec![
-                ExprKind::Atom(Atom::new(SyntaxObject::default(Identifier("+".into())))),
-                ExprKind::Atom(Atom::new(SyntaxObject::default(Identifier("##x".into())))),
-                atom_int(10),
-            ])),
-            SyntaxObject::default(TokenType::Lambda),
-        )));
-
-        let mut visitor = RenameIdentifiersVisitor::new(&[], &[]);
-
-        visitor.visit(&mut pre_condition);
-
-        assert_eq!(pre_condition, post_condition);
-    }
-
-    #[test]
-    fn test_should_do_nothing() {
-        let mut pre_condition = ExprKind::If(Box::new(If::new(
-            ExprKind::Atom(Atom::new(SyntaxObject::default(BooleanLiteral(true)))),
-            ExprKind::Atom(Atom::new(SyntaxObject::default(BooleanLiteral(true)))),
-            ExprKind::If(Box::new(If::new(
-                ExprKind::Atom(Atom::new(SyntaxObject::default(BooleanLiteral(false)))),
-                atom_int(10),
-                atom_int(20),
-                SyntaxObject::default(If),
-            ))),
-            SyntaxObject::default(If),
-        )));
-
-        let post_condition = pre_condition.clone();
-
-        let mut visitor = RenameIdentifiersVisitor::new(&[], &[]);
-        visitor.visit(&mut pre_condition);
-        assert_eq!(pre_condition, post_condition);
-    }
-
-    #[test]
-    fn test_rename_define() {
-        let mut pre_condition: ExprKind = Define::new(
-            atom_identifier("applesauce"),
-            atom_int(10),
-            SyntaxObject::default(TokenType::Define),
-        )
-        .into();
-
-        let post_condition: ExprKind = Define::new(
-            atom_identifier("##applesauce"),
-            atom_int(10),
-            SyntaxObject::default(TokenType::Define),
-        )
-        .into();
-
-        let mut visitor = RenameIdentifiersVisitor::new(&[], &[]);
-        visitor.visit(&mut pre_condition);
-        assert_eq!(pre_condition, post_condition);
-    }
-
-    #[test]
-    fn test_rename_define_datum_syntax() {
-        let mut pre_condition: ExprKind = Define::new(
-            List::new(vec![
-                atom_identifier("datum->syntax"),
-                atom_identifier("escaping-definition"),
-            ])
-            .into(),
-            atom_int(1),
-            SyntaxObject::default(TokenType::Define),
-        )
-        .into();
-
-        let post_condition: ExprKind = Define::new(
-            List::new(vec![
-                atom_identifier("datum->syntax"),
-                atom_identifier("escaping-definition"),
-            ])
-            .into(),
-            atom_int(1),
-            SyntaxObject::default(TokenType::Define),
-        )
-        .into();
-
-        let mut visitor = RenameIdentifiersVisitor::new(&[], &[]);
-        visitor.visit(&mut pre_condition);
-        assert_eq!(pre_condition, post_condition);
-    }
-}
diff --git a/crates/steel-core/src/parser/replace_idents.rs b/crates/steel-core/src/parser/replace_idents.rs
deleted file mode 100644
index 5f15dfa74..000000000
--- a/crates/steel-core/src/parser/replace_idents.rs
+++ /dev/null
@@ -1,823 +0,0 @@
-use crate::compiler::passes::VisitorMutControlFlow;
-use crate::compiler::program::SYNTAX_SPAN;
-use crate::parser::span::Span;
-use crate::parser::tokens::TokenType;
-use crate::parser::visitors::ConsumingVisitor;
-use crate::{compiler::program::DEFINE, parser::parser::SyntaxObject};
-use crate::{
-    compiler::program::{DATUM_SYNTAX, SYNTAX_CONST_IF},
-    parser::ast::ExprKind,
-};
-
-use crate::rvals::Result;
-
-use super::expander::BindingKind;
-use super::{ast::Atom, interner::InternedString};
-
-use std::collections::{HashMap, HashSet};
-use std::ops::ControlFlow;
-
-// const DATUM_TO_SYNTAX: &str = "datum->syntax";
-// const SYNTAX_CONST_IF: &str = "syntax-const-if";
-// TODO: Add level for pure macros to run at compile time... More or less const functions, that still
-// have access to the span?
-// const CURRENT_FILE: &str = "const-current-file!";
-
-pub fn replace_identifiers(
-    expr: ExprKind,
-    bindings: &mut HashMap<InternedString, ExprKind>,
-    binding_kind: &mut HashMap<InternedString, BindingKind>,
-    fallback_bindings: &mut HashMap<InternedString, ExprKind>,
-    span: Span,
-) -> Result<ExprKind> {
-    let rewrite_spans = RewriteSpan::new(span).visit(expr)?;
-
-    ReplaceExpressions::new(bindings, binding_kind, fallback_bindings).visit(rewrite_spans)
-}
-
-// struct ConstExprKindTransformers {
-//     functions: HashMap<&'static str, fn(&ReplaceExpressions<'_>, ExprKind) -> Result<ExprKind>>,
-// }
-
-pub struct ReplaceExpressions<'a> {
-    bindings: &'a mut HashMap<InternedString, ExprKind>,
-    fallback_bindings: &'a mut HashMap<InternedString, ExprKind>,
-    binding_kind: &'a mut HashMap<InternedString, BindingKind>,
-}
-
-fn check_ellipses(expr: &ExprKind) -> bool {
-    matches!(
-        expr,
-        ExprKind::Atom(Atom {
-            syn: SyntaxObject {
-                ty: TokenType::Ellipses,
-                ..
-            },
-        })
-    )
-}
-
-struct EllipsesExpanderVisitor<'a> {
-    bindings: &'a mut HashMap<InternedString, ExprKind>,
-    binding_kind: &'a mut HashMap<InternedString, BindingKind>,
-    found_length: Option<usize>,
-    collected: HashSet<InternedString>,
-    error: Option<String>,
-}
-
-impl<'a> EllipsesExpanderVisitor<'a> {
-    fn find_expansion_width_and_collect_ellipses_expanders(
-        bindings: &'a mut HashMap<InternedString, ExprKind>,
-        binding_kind: &'a mut HashMap<InternedString, BindingKind>,
-        expr: &ExprKind,
-    ) -> Self {
-        let mut visitor = Self {
-            bindings,
-            binding_kind,
-            found_length: None,
-            collected: HashSet::new(),
-            error: None,
-        };
-
-        VisitorMutControlFlow::visit(&mut visitor, expr);
-
-        visitor
-    }
-}
-
-impl<'a> VisitorMutControlFlow for EllipsesExpanderVisitor<'a> {
-    fn visit_atom(&mut self, a: &Atom) -> ControlFlow<()> {
-        let expansion = a.ident().and_then(|x| self.bindings.get(x));
-
-        if let Some(expansion) = expansion {
-            if let ExprKind::List(found_list) = expansion {
-                if let Some(BindingKind::Many) = a.ident().and_then(|x| self.binding_kind.get(x)) {
-                    if let Some(previously_seen_length) = self.found_length {
-                        // Check that the length is the same
-                        if previously_seen_length != found_list.len() {
-                            self.error =
-                                Some(format!("Mismatched lengths found in ellipses expansion"));
-                            return ControlFlow::Break(());
-                        }
-
-                        // Found this one, use it
-                        self.collected.insert(*(a.ident().unwrap()));
-                    } else {
-                        self.found_length = Some(found_list.len());
-                        self.collected.insert(*(a.ident().unwrap()));
-                    }
-                }
-            }
-        }
-        ControlFlow::Continue(())
-    }
-}
-
-impl<'a> ReplaceExpressions<'a> {
-    pub fn new(
-        bindings: &'a mut HashMap<InternedString, ExprKind>,
-        binding_kind: &'a mut HashMap<InternedString, BindingKind>,
-        fallback_bindings: &'a mut HashMap<InternedString, ExprKind>,
-    ) -> Self {
-        ReplaceExpressions {
-            bindings,
-            binding_kind,
-            fallback_bindings,
-        }
-    }
-
-    fn expand_atom(&self, expr: Atom) -> ExprKind {
-        // Overwrite the span on any atoms
-        // expr.syn.set_span(self.span);
-
-        if let TokenType::Identifier(s) = &expr.syn.ty {
-            if let Some(body) = self.bindings.get(s) {
-                return body.clone();
-            }
-        }
-
-        ExprKind::Atom(expr)
-    }
-
-    fn expand_ellipses(&mut self, vec_exprs: Vec<ExprKind>) -> Result<Vec<ExprKind>> {
-        if let Some(ellipses_pos) = vec_exprs.iter().position(check_ellipses) {
-            let variable_to_lookup = vec_exprs.get(ellipses_pos - 1).ok_or_else(
-                throw!(BadSyntax => "macro expansion failed, could not find variable when expanding ellipses")
-            )?;
-
-            match variable_to_lookup {
-                ExprKind::Atom(Atom {
-                    syn:
-                        SyntaxObject {
-                            ty: TokenType::Identifier(var),
-                            ..
-                        },
-                }) => {
-                    let rest = self.bindings.get(var).ok_or_else(throw!(BadSyntax => format!("macro expansion failed at finding the variable when expanding ellipses: {var}")))?;
-
-                    let list_of_exprs = if let ExprKind::List(list_of_exprs) = rest {
-                        list_of_exprs
-                    } else {
-                        let res = self.fallback_bindings.get(var).ok_or_else(throw!(BadSyntax => format!("macro expansion failed at finding the variable when expanding ellipses: {var}")))?.list_or_else(
-                        throw!(BadSyntax => "macro expansion failed, expected list of expressions, found: {}, within {}", rest, super::ast::List::new(vec_exprs.clone()))
-                    )?;
-
-                        res
-                    };
-
-                    let mut first_chunk = vec_exprs[0..ellipses_pos - 1].to_vec();
-                    first_chunk.extend_from_slice(list_of_exprs);
-                    first_chunk.extend_from_slice(&vec_exprs[(ellipses_pos + 1)..]);
-                    Ok(first_chunk)
-                }
-
-                ExprKind::List(_) => {
-                    let visitor = EllipsesExpanderVisitor::find_expansion_width_and_collect_ellipses_expanders(self.bindings, self.binding_kind, variable_to_lookup);
-
-                    if let Some(error) = visitor.error {
-                        stop!(BadSyntax => error);
-                    }
-
-                    let width = visitor.found_length.ok_or_else(throw!(BadSyntax => "No pattern variables before ellipses in template: at {} in {}", variable_to_lookup, ExprKind::List(super::ast::List::new(vec_exprs.clone()))))?;
-
-                    let mut original_bindings: HashMap<_, _> = visitor
-                        .collected
-                        .iter()
-                        .flat_map(|x| self.bindings.get(x).map(|value| (*x, value.clone())))
-                        .collect();
-
-                    std::mem::swap(self.fallback_bindings, &mut original_bindings);
-
-                    let mut expanded_expressions = Vec::with_capacity(width);
-
-                    for i in 0..width {
-                        let template = variable_to_lookup.clone();
-
-                        for (key, value) in self.fallback_bindings.iter() {
-                            if let ExprKind::List(expansion) = value {
-                                let new_binding = expansion
-                                    .get(i)
-                                    .ok_or_else(throw!(BadSyntax => "Unreachable"))?;
-
-                                self.bindings.insert(*key, new_binding.clone());
-                            } else {
-                                stop!(BadSyntax => "Unexpected value found in ellipses expansion")
-                            }
-                        }
-
-                        expanded_expressions.push(self.visit(template)?);
-                    }
-
-                    std::mem::swap(self.fallback_bindings, &mut original_bindings);
-
-                    // Move the original bindings back in
-                    for (key, value) in original_bindings {
-                        self.bindings.insert(key, value);
-                    }
-
-                    let mut first_chunk = vec_exprs[0..ellipses_pos - 1].to_vec();
-                    first_chunk.extend_from_slice(&expanded_expressions);
-                    first_chunk.extend_from_slice(&vec_exprs[(ellipses_pos + 1)..]);
-
-                    Ok(first_chunk)
-                }
-
-                _ => {
-                    stop!(BadSyntax => "macro expansion failed at lookup!: {}", variable_to_lookup)
-                }
-            }
-        } else {
-            Ok(vec_exprs)
-        }
-    }
-
-    fn vec_expr_syntax_const_if(&self, vec_exprs: &[ExprKind]) -> Result<Option<ExprKind>> {
-        match vec_exprs.get(0) {
-            Some(ExprKind::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::Identifier(check),
-                        ..
-                    },
-            })) if *check == *SYNTAX_CONST_IF => {
-                if vec_exprs.len() != 4 {
-                    stop!(BadSyntax => "syntax-const-if expects a const test condition, a then and an else case");
-                }
-
-                let test_expr = vec_exprs.get(1).unwrap();
-                let then_expr = vec_exprs.get(2).unwrap();
-                let else_expr = vec_exprs.get(3).unwrap();
-
-                if let ExprKind::Atom(Atom {
-                    syn: SyntaxObject { ty, .. },
-                }) = test_expr
-                {
-                    // TODO -> what happens if reserved tokens are in here
-                    match ty {
-                        TokenType::BooleanLiteral(_)
-                        | TokenType::IntegerLiteral(_)
-                        | TokenType::CharacterLiteral(_)
-                        | TokenType::NumberLiteral(_)
-                        | TokenType::StringLiteral(_) => return Ok(Some(then_expr.clone())),
-                        TokenType::Identifier(s) => {
-                            if let Some(ExprKind::Atom(Atom {
-                                syn: SyntaxObject { ty, .. },
-                            })) = self.bindings.get(s)
-                            {
-                                log::debug!("Syntax const if resolved to: {:?}", ty);
-
-                                if matches!(
-                                    ty,
-                                    TokenType::BooleanLiteral(_)
-                                        | TokenType::IntegerLiteral(_)
-                                        | TokenType::CharacterLiteral(_)
-                                        | TokenType::NumberLiteral(_)
-                                        | TokenType::StringLiteral(_)
-                                ) {
-                                    return Ok(Some(then_expr.clone()));
-                                }
-                            }
-                        }
-                        _ => {}
-                    }
-                }
-
-                Ok(Some(else_expr.clone()))
-            }
-            _ => Ok(None),
-        }
-    }
-
-    fn vec_expr_datum_to_syntax(&self, vec_exprs: &[ExprKind]) -> Result<Option<ExprKind>> {
-        match vec_exprs.get(0) {
-            Some(ExprKind::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::Identifier(check),
-                        ..
-                    },
-            })) if *check == *DATUM_SYNTAX => {
-                let mut buffer = String::new();
-                if let Some((_, rest)) = vec_exprs.split_first() {
-                    for syntax in rest {
-                        let transformer = syntax.atom_identifier_or_else(
-                            throw!(BadSyntax => "datum->syntax requires an identifier"),
-                        )?;
-
-                        let resolved = transformer.resolve();
-
-                        // TODO this is no longer correct
-                        // Should actually just visit the variable in the define name part
-                        // TODO
-                        if resolved.starts_with("##") {
-                            if let Some(body) = self.bindings.get(transformer) {
-                                buffer.push_str(body.to_string().as_str());
-                            } else {
-                                let (_, cdr) = resolved.split_at(2);
-                                buffer.push_str(cdr);
-                            }
-                        } else {
-                            // Try to get the prepended variable
-                            if let Some(body) =
-                                self.bindings.get(&("##".to_string() + resolved).into())
-                            {
-                                // println!("Found datum: {}", transformer);
-                                buffer.push_str(body.to_string().as_str());
-                            } else {
-                                // println!("Unable to find datum: {}", transformer);
-                                buffer.push_str(resolved);
-                            }
-                        }
-                    }
-
-                    Ok(Some(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                        TokenType::Identifier(buffer.into()),
-                    )))))
-                } else {
-                    Ok(None)
-                }
-            }
-            _ => Ok(None),
-        }
-    }
-
-    // TODO: @Matt - Come back here
-    fn vec_syntax_span_object(&self, vec_exprs: &[ExprKind]) -> Result<Option<ExprKind>> {
-        if vec_exprs.len() != 2 {
-            return Ok(None);
-            // stop!(ArityMismatch => "#%syntax-span requires 2 arguments, found: {}", vec_exprs.len());
-        }
-
-        match vec_exprs.get(0) {
-            Some(ExprKind::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::Identifier(check),
-                        ..
-                    },
-            })) if *check == *SYNTAX_SPAN => {
-                let expr_to_extract_span = vec_exprs.get(1).unwrap();
-
-                // dbg!(&expr_to_extract_span);
-
-                let span = crate::parser::span_visitor::get_span(expr_to_extract_span);
-
-                let start = ExprKind::integer_literal(span.start as isize, span);
-                let end = ExprKind::integer_literal(span.end as isize, span);
-
-                let source_id = if let Some(source) = span.source_id() {
-                    ExprKind::integer_literal(source.0 as isize, span)
-                } else {
-                    ExprKind::bool_lit(false)
-                };
-
-                Ok(Some(ExprKind::Quote(Box::new(super::ast::Quote::new(
-                    ExprKind::List(super::ast::List::new(vec![start, end, source_id])),
-                    SyntaxObject::default(TokenType::Quote),
-                )))))
-
-                // Ok(Some(ExprKind::List(List::new(vec![
-
-                // ]))))
-            }
-            _ => Ok(None),
-        }
-    }
-}
-
-fn reserved_token_type_to_ident(token: &mut TokenType<InternedString>) {
-    if *token == TokenType::Define {
-        *token = TokenType::Identifier(*DEFINE);
-    }
-}
-
-// TODO replace spans on all of the nodes and atoms
-impl<'a> ConsumingVisitor for ReplaceExpressions<'a> {
-    type Output = Result<ExprKind>;
-
-    fn visit_if(&mut self, mut f: Box<super::ast::If>) -> Self::Output {
-        f.test_expr = self.visit(f.test_expr)?;
-        f.then_expr = self.visit(f.then_expr)?;
-        f.else_expr = self.visit(f.else_expr)?;
-        Ok(ExprKind::If(f))
-    }
-
-    fn visit_define(&mut self, mut define: Box<super::ast::Define>) -> Self::Output {
-        if let ExprKind::List(l) = &define.name {
-            if let Some(expanded) = self.vec_expr_datum_to_syntax(&l.args)? {
-                define.name = expanded
-            }
-        }
-        define.name = self.visit(define.name)?;
-        define.body = self.visit(define.body)?;
-        Ok(ExprKind::Define(define))
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        mut lambda_function: Box<super::ast::LambdaFunction>,
-    ) -> Self::Output {
-        lambda_function.args = self.expand_ellipses(lambda_function.args)?;
-        lambda_function.args = lambda_function
-            .args
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-        lambda_function.body = self.visit(lambda_function.body)?;
-
-        // TODO: @Matt - 2/28/12 -> clean up this
-        // This mangles the values
-        lambda_function.args.iter_mut().for_each(|x| {
-            if let ExprKind::Atom(Atom {
-                syn: SyntaxObject { ty: t, .. },
-            }) = x
-            {
-                // log::debug!("Checking if expression needs to be rewritten: {:?}", t);
-                reserved_token_type_to_ident(t);
-            }
-
-            // if let ExprKind::Define(d) = x {
-            //     log::debug!("Found a define to be rewritten: {:?}", d);
-            // }
-        });
-
-        Ok(ExprKind::LambdaFunction(lambda_function))
-    }
-
-    fn visit_begin(&mut self, mut begin: super::ast::Begin) -> Self::Output {
-        begin.exprs = self.expand_ellipses(begin.exprs)?;
-        begin.exprs = begin
-            .exprs
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-        Ok(ExprKind::Begin(begin))
-    }
-
-    fn visit_return(&mut self, mut r: Box<super::ast::Return>) -> Self::Output {
-        r.expr = self.visit(r.expr)?;
-        Ok(ExprKind::Return(r))
-    }
-
-    fn visit_quote(&mut self, mut quote: Box<super::ast::Quote>) -> Self::Output {
-        quote.expr = self.visit(quote.expr)?;
-        Ok(ExprKind::Quote(quote))
-    }
-
-    fn visit_macro(&mut self, m: Box<super::ast::Macro>) -> Self::Output {
-        stop!(BadSyntax => format!("unexpected macro definition: {}", m); m.location.span)
-    }
-
-    fn visit_atom(&mut self, a: Atom) -> Self::Output {
-        Ok(self.expand_atom(a))
-    }
-
-    fn visit_list(&mut self, mut l: super::ast::List) -> Self::Output {
-        if let Some(expanded) = self.vec_expr_datum_to_syntax(&l.args)? {
-            return Ok(expanded);
-        }
-
-        if let Some(expanded) = self.vec_expr_syntax_const_if(&l.args)? {
-            return self.visit(expanded);
-        }
-
-        l.args = self.expand_ellipses(l.args)?;
-        l.args = l
-            .args
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-
-        if let Some(expanded) = self.vec_syntax_span_object(&l.args)? {
-            return Ok(expanded);
-        }
-
-        Ok(ExprKind::List(l))
-    }
-
-    fn visit_syntax_rules(&mut self, l: Box<super::ast::SyntaxRules>) -> Self::Output {
-        dbg!(l.to_string());
-
-        stop!(Generic => "unexpected syntax-rules definition"; l.location.span)
-    }
-
-    fn visit_set(&mut self, mut s: Box<super::ast::Set>) -> Self::Output {
-        s.variable = self.visit(s.variable)?;
-        s.expr = self.visit(s.expr)?;
-        Ok(ExprKind::Set(s))
-    }
-
-    fn visit_require(&mut self, mut s: super::ast::Require) -> Self::Output {
-        s.modules = s
-            .modules
-            .into_iter()
-            .map(|x| self.visit(x))
-            .collect::<Result<_>>()?;
-
-        Ok(ExprKind::Require(s))
-
-        // stop!(Generic => "unexpected require statement in replace idents"; s.location.span)
-    }
-
-    fn visit_let(&mut self, mut l: Box<super::ast::Let>) -> Self::Output {
-        let mut visited_bindings = Vec::new();
-
-        let (bindings, exprs): (Vec<_>, Vec<_>) = l.bindings.iter().cloned().unzip();
-
-        let bindings = self.expand_ellipses(bindings)?;
-
-        for (binding, expr) in bindings.into_iter().zip(exprs) {
-            visited_bindings.push((self.visit(binding)?, self.visit(expr)?));
-        }
-
-        l.bindings = visited_bindings;
-        l.body_expr = self.visit(l.body_expr)?;
-
-        Ok(ExprKind::Let(l))
-    }
-}
-
-pub struct RewriteSpan {
-    span: Span,
-}
-
-impl RewriteSpan {
-    pub fn new(span: Span) -> Self {
-        Self { span }
-    }
-}
-
-// TODO replace spans on all of the nodes and atoms
-impl ConsumingVisitor for RewriteSpan {
-    type Output = Result<ExprKind>;
-
-    fn visit_if(&mut self, mut f: Box<super::ast::If>) -> Self::Output {
-        f.test_expr = self.visit(f.test_expr)?;
-        f.then_expr = self.visit(f.then_expr)?;
-        f.else_expr = self.visit(f.else_expr)?;
-        f.location.set_span(self.span);
-        Ok(ExprKind::If(f))
-    }
-
-    fn visit_define(&mut self, mut define: Box<super::ast::Define>) -> Self::Output {
-        define.name = self.visit(define.name)?;
-        define.body = self.visit(define.body)?;
-        define.location.set_span(self.span);
-        Ok(ExprKind::Define(define))
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        mut lambda_function: Box<super::ast::LambdaFunction>,
-    ) -> Self::Output {
-        lambda_function.args = lambda_function
-            .args
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-        lambda_function.body = self.visit(lambda_function.body)?;
-        lambda_function.location.set_span(self.span);
-        Ok(ExprKind::LambdaFunction(lambda_function))
-    }
-
-    fn visit_begin(&mut self, mut begin: super::ast::Begin) -> Self::Output {
-        begin.exprs = begin
-            .exprs
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-        begin.location.set_span(self.span);
-        Ok(ExprKind::Begin(begin))
-    }
-
-    fn visit_return(&mut self, mut r: Box<super::ast::Return>) -> Self::Output {
-        r.expr = self.visit(r.expr)?;
-        r.location.set_span(self.span);
-        Ok(ExprKind::Return(r))
-    }
-
-    fn visit_quote(&mut self, mut quote: Box<super::ast::Quote>) -> Self::Output {
-        quote.expr = self.visit(quote.expr)?;
-        quote.location.set_span(self.span);
-        Ok(ExprKind::Quote(quote))
-    }
-
-    fn visit_macro(&mut self, m: Box<super::ast::Macro>) -> Self::Output {
-        stop!(BadSyntax => format!("unexpected macro definition: {}", m); m.location.span)
-    }
-
-    fn visit_atom(&mut self, mut a: Atom) -> Self::Output {
-        // Overwrite the span on any atoms
-        a.syn.set_span(self.span);
-
-        Ok(ExprKind::Atom(a))
-    }
-
-    fn visit_list(&mut self, mut l: super::ast::List) -> Self::Output {
-        // if let Some(first) = l.first_ident() {
-        //     if *first == *QUASISYNTAX || *first == *SYNTAX_QUOTE {
-        //         return Ok(ExprKind::List(l));
-        //     }
-        // }
-
-        l.args = l
-            .args
-            .into_iter()
-            .map(|e| self.visit(e))
-            .collect::<Result<Vec<_>>>()?;
-        Ok(ExprKind::List(l))
-    }
-
-    fn visit_syntax_rules(&mut self, l: Box<super::ast::SyntaxRules>) -> Self::Output {
-        dbg!(l.to_string());
-
-        stop!(Generic => "unexpected syntax-rules definition"; l.location.span)
-    }
-
-    fn visit_set(&mut self, mut s: Box<super::ast::Set>) -> Self::Output {
-        s.variable = self.visit(s.variable)?;
-        s.expr = self.visit(s.expr)?;
-        Ok(ExprKind::Set(s))
-    }
-
-    fn visit_require(&mut self, mut s: super::ast::Require) -> Self::Output {
-        s.modules = s
-            .modules
-            .into_iter()
-            .map(|x| self.visit(x))
-            .collect::<Result<_>>()?;
-
-        Ok(ExprKind::Require(s))
-
-        // stop!(Generic => "unexpected require statement in replace idents"; s.location.span)
-    }
-
-    fn visit_let(&mut self, mut l: Box<super::ast::Let>) -> Self::Output {
-        let mut visited_bindings = Vec::new();
-
-        for (binding, expr) in l.bindings {
-            visited_bindings.push((self.visit(binding)?, self.visit(expr)?));
-        }
-
-        l.bindings = visited_bindings;
-        l.body_expr = self.visit(l.body_expr)?;
-
-        Ok(ExprKind::Let(l))
-    }
-}
-
-#[cfg(test)]
-mod replace_expressions_tests {
-    use crate::parser::ast::{LambdaFunction, List};
-
-    use super::*;
-
-    macro_rules! map {
-        ($ ( $key:expr => $value:expr ), *,) => {{
-            let mut hm: HashMap<InternedString, ExprKind> = HashMap::new();
-            $ (hm.insert($key.into(), $value); ) *
-            hm
-        }};
-    }
-
-    fn atom_identifier(s: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            s.into(),
-        ))))
-    }
-
-    fn ellipses() -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Ellipses)))
-    }
-
-    // TODO -> move this to ExprKind
-    // fn atom_int(n: isize) -> ExprKind {
-    //     ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::IntegerLiteral(
-    //         n,
-    //     ))))
-    // }
-
-    // TODO replace this test with something that doesn't use transduce
-    // #[test]
-    // fn test_expand_atom() {
-    //     let bindings = map! {
-    //         "apples" => atom_identifier("x"),
-    //         "bananas" => atom_identifier("y"),
-    //         "number" => atom_int(1),
-    //     };
-
-    //     let expr = ExprKind::If(Box::new(If::new(
-    //         atom_identifier("test-condition"),
-    //         ExprKind::Transduce(Box::new(Transduce::new(
-    //             atom_identifier("apples"),
-    //             atom_identifier("bananas"),
-    //             atom_identifier("number"),
-    //             atom_identifier("z"),
-    //             SyntaxObject::default(TokenType::Transduce),
-    //         ))),
-    //         atom_identifier("else-condition"),
-    //         SyntaxObject::default(TokenType::If),
-    //     )));
-
-    //     let post_condition = ExprKind::If(Box::new(If::new(
-    //         atom_identifier("test-condition"),
-    //         ExprKind::Transduce(Box::new(Transduce::new(
-    //             atom_identifier("x"),
-    //             atom_identifier("y"),
-    //             atom_int(1),
-    //             atom_identifier("z"),
-    //             SyntaxObject::default(TokenType::Transduce),
-    //         ))),
-    //         atom_identifier("else-condition"),
-    //         SyntaxObject::default(TokenType::If),
-    //     )));
-
-    //     let output = ReplaceExpressions::new(&bindings).visit(expr).unwrap();
-
-    //     assert_eq!(output, post_condition);
-    // }
-
-    #[test]
-    fn test_expand_datum_syntax() {
-        let mut bindings = map! {
-            "##struct-name" => atom_identifier("apple"),
-        };
-
-        let expr = ExprKind::List(List::new(vec![
-            atom_identifier("datum->syntax"),
-            atom_identifier("struct-name"),
-            atom_identifier("?"),
-        ]));
-
-        let post_condition = atom_identifier("apple?");
-
-        let output =
-            ReplaceExpressions::new(&mut bindings, &mut HashMap::new(), &mut HashMap::new())
-                .visit(expr)
-                .unwrap();
-
-        assert_eq!(output, post_condition);
-    }
-
-    #[test]
-    fn test_expand_ellipses() {
-        let mut bindings = map! {
-            "apple" => atom_identifier("x"),
-            "many" => ExprKind::List(List::new(vec![
-                atom_identifier("first"),
-                atom_identifier("second")
-            ])),
-        };
-
-        let expr = ExprKind::List(List::new(vec![
-            atom_identifier("apple"),
-            atom_identifier("many"),
-            ellipses(),
-        ]));
-
-        let post_condition = ExprKind::List(List::new(vec![
-            atom_identifier("x"),
-            atom_identifier("first"),
-            atom_identifier("second"),
-        ]));
-
-        let output =
-            ReplaceExpressions::new(&mut bindings, &mut HashMap::new(), &mut HashMap::new())
-                .visit(expr)
-                .unwrap();
-
-        assert_eq!(output, post_condition);
-    }
-
-    #[test]
-    fn test_lambda_expression() {
-        let mut bindings = map! {
-            "apple" => atom_identifier("x"),
-            "many" => ExprKind::List(List::new(vec![
-                atom_identifier("first-arg"),
-                atom_identifier("second-arg")
-            ])),
-        };
-
-        let expr: ExprKind = LambdaFunction::new(
-            vec![atom_identifier("many"), ellipses()],
-            atom_identifier("apple"),
-            SyntaxObject::default(TokenType::Lambda),
-        )
-        .into();
-
-        let post_condition = LambdaFunction::new(
-            vec![atom_identifier("first-arg"), atom_identifier("second-arg")],
-            atom_identifier("x"),
-            SyntaxObject::default(TokenType::Lambda),
-        )
-        .into();
-
-        let output =
-            ReplaceExpressions::new(&mut bindings, &mut HashMap::new(), &mut HashMap::new())
-                .visit(expr)
-                .unwrap();
-
-        assert_eq!(output, post_condition);
-    }
-}
diff --git a/crates/steel-core/src/parser/span.rs b/crates/steel-core/src/parser/span.rs
deleted file mode 100644
index 4252624e6..000000000
--- a/crates/steel-core/src/parser/span.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use crate::{list, rvals::FromSteelVal, rvals::IntoSteelVal};
-
-use crate::rvals::SteelVal;
-
-use super::parser::SourceId;
-
-pub use steel_parser::span::Span;
-
-impl IntoSteelVal for Span {
-    fn into_steelval(self) -> crate::rvals::Result<crate::SteelVal> {
-        Ok(list![self.start, self.end, self.source_id])
-    }
-}
-
-impl FromSteelVal for Span {
-    fn from_steelval(val: &crate::SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::ListV(l) = val {
-            if l.len() != 3 {
-                stop!(ConversionError => "cannot convert to a span object: {}", val);
-            }
-
-            Ok(Span {
-                start: usize::from_steelval(l.get(0).unwrap())?,
-                end: usize::from_steelval(l.get(1).unwrap())?,
-                source_id: l
-                    .get(2)
-                    .map(Option::<usize>::from_steelval)
-                    .map(|x| x.transpose())
-                    .flatten()
-                    .transpose()?
-                    .map(SourceId),
-            })
-        } else {
-            stop!(ConversionError => "cannot convert to a span object: {}", val)
-        }
-    }
-}
diff --git a/crates/steel-core/src/parser/span_visitor.rs b/crates/steel-core/src/parser/span_visitor.rs
deleted file mode 100644
index 828dbebe5..000000000
--- a/crates/steel-core/src/parser/span_visitor.rs
+++ /dev/null
@@ -1,80 +0,0 @@
-use crate::parser::ast::ExprKind;
-use crate::parser::span::Span;
-use crate::parser::visitors::Visitor;
-
-use super::ast::Atom;
-
-pub fn get_span(expr: &ExprKind) -> Span {
-    CoalescingSpanVisitor {}.visit(expr)
-}
-
-struct CoalescingSpanVisitor {}
-
-impl Visitor for CoalescingSpanVisitor {
-    type Output = Span;
-
-    fn visit_if(&self, f: &super::ast::If) -> Self::Output {
-        let span1 = Span::merge(f.location.span, self.visit(&f.test_expr));
-        let span2 = Span::merge(span1, self.visit(&f.then_expr));
-        Span::merge(span2, self.visit(&f.else_expr))
-    }
-
-    fn visit_define(&self, define: &super::ast::Define) -> Self::Output {
-        let span1 = Span::merge(define.location.span, self.visit(&define.name));
-        Span::merge(span1, self.visit(&define.body))
-    }
-
-    fn visit_lambda_function(&self, lambda_function: &super::ast::LambdaFunction) -> Self::Output {
-        Span::merge(
-            lambda_function.location.span,
-            self.visit(&lambda_function.body),
-        )
-    }
-
-    fn visit_begin(&self, begin: &super::ast::Begin) -> Self::Output {
-        let last_span = begin.exprs.last().map(|x| self.visit(x));
-
-        if let Some(last_span) = last_span {
-            Span::merge(begin.location.span, last_span)
-        } else {
-            begin.location.span
-        }
-    }
-
-    fn visit_return(&self, r: &super::ast::Return) -> Self::Output {
-        Span::merge(r.location.span, self.visit(&r.expr))
-    }
-
-    fn visit_quote(&self, quote: &super::ast::Quote) -> Self::Output {
-        self.visit(&quote.expr)
-    }
-
-    fn visit_macro(&self, _m: &super::ast::Macro) -> Self::Output {
-        panic!("Unexpected macro found in span visitor");
-    }
-
-    fn visit_atom(&self, a: &Atom) -> Self::Output {
-        a.syn.span
-    }
-
-    fn visit_list(&self, l: &super::ast::List) -> Self::Output {
-        let span_vec = l.args.iter().map(|x| self.visit(x)).collect::<Vec<_>>();
-        Span::coalesce_span(&span_vec)
-    }
-
-    fn visit_syntax_rules(&self, _l: &super::ast::SyntaxRules) -> Self::Output {
-        panic!("Unexpected syntax rules found in span visitor");
-    }
-
-    fn visit_set(&self, s: &super::ast::Set) -> Self::Output {
-        Span::merge(s.location.span, self.visit(&s.expr))
-    }
-
-    fn visit_require(&self, _s: &super::ast::Require) -> Self::Output {
-        panic!("Unexpected require found in span visitor")
-    }
-
-    fn visit_let(&self, l: &super::ast::Let) -> Self::Output {
-        Span::merge(l.location.span, self.visit(&l.body_expr))
-    }
-}
diff --git a/crates/steel-core/src/parser/tokens.rs b/crates/steel-core/src/parser/tokens.rs
deleted file mode 100644
index 4cc17b506..000000000
--- a/crates/steel-core/src/parser/tokens.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub use steel_parser::tokens::{Token, TokenType};
diff --git a/crates/steel-core/src/parser/tryfrom_visitor.rs b/crates/steel-core/src/parser/tryfrom_visitor.rs
deleted file mode 100644
index 4232e4e14..000000000
--- a/crates/steel-core/src/parser/tryfrom_visitor.rs
+++ /dev/null
@@ -1,442 +0,0 @@
-use crate::values::lists::List;
-
-use crate::{parser::ast::ExprKind, rvals::Syntax};
-
-use crate::rerrs::SteelErr;
-use crate::rvals::{Result, SteelVal};
-
-use super::{ast::Atom, span::Span, visitors::ConsumingVisitor};
-
-use std::convert::TryFrom;
-
-pub struct TryFromExprKindForSteelVal {
-    inside_quote: bool,
-}
-
-impl TryFromExprKindForSteelVal {
-    pub fn try_from_expr_kind(e: ExprKind) -> Result<SteelVal> {
-        TryFromExprKindForSteelVal {
-            inside_quote: false,
-        }
-        .visit(e)
-    }
-
-    pub fn try_from_expr_kind_quoted(e: ExprKind) -> Result<SteelVal> {
-        TryFromExprKindForSteelVal { inside_quote: true }.visit(e)
-    }
-}
-
-impl ConsumingVisitor for TryFromExprKindForSteelVal {
-    type Output = Result<SteelVal>;
-
-    fn visit_if(&mut self, f: Box<super::ast::If>) -> Self::Output {
-        let expr = [
-            SteelVal::try_from(f.location)?,
-            self.visit(f.test_expr)?,
-            self.visit(f.then_expr)?,
-            self.visit(f.else_expr)?,
-        ];
-        Ok(SteelVal::ListV(expr.into_iter().collect()))
-    }
-
-    fn visit_define(&mut self, define: Box<super::ast::Define>) -> Self::Output {
-        let expr = [
-            SteelVal::try_from(define.location)?,
-            self.visit(define.name)?,
-            self.visit(define.body)?,
-        ];
-        Ok(SteelVal::ListV(expr.into_iter().collect()))
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        lambda_function: Box<super::ast::LambdaFunction>,
-    ) -> Self::Output {
-        let args = lambda_function
-            .args
-            .into_iter()
-            .map(|x| self.visit(x))
-            .collect::<Result<List<_>>>()?;
-
-        let expr = [
-            SteelVal::try_from(lambda_function.location)?,
-            SteelVal::ListV(args),
-            self.visit(lambda_function.body)?,
-        ];
-
-        Ok(SteelVal::ListV(expr.into_iter().collect()))
-    }
-
-    fn visit_begin(&mut self, begin: super::ast::Begin) -> Self::Output {
-        let mut exprs = vec![SteelVal::try_from(begin.location)?];
-        for expr in begin.exprs {
-            exprs.push(self.visit(expr)?);
-        }
-        Ok(SteelVal::ListV(exprs.into()))
-    }
-
-    fn visit_return(&mut self, r: Box<super::ast::Return>) -> Self::Output {
-        let expr = [SteelVal::try_from(r.location)?, self.visit(r.expr)?];
-        Ok(SteelVal::ListV(expr.into_iter().collect()))
-    }
-
-    // TODO: quotes are handled incorrectly here
-    // Interior values should be handled on their own separately - they should evaluate
-    // like this: '(a b c) => '(a b c)
-    // '(a b 'c) => '(a b 'c) --- currently this ends up as '(a b c)
-    fn visit_quote(&mut self, quote: Box<super::ast::Quote>) -> Self::Output {
-        // dbg!(self.inside_quote);
-
-        if self.inside_quote {
-            // self.visit(quote.expr)
-
-            Ok(SteelVal::ListV(
-                vec![SteelVal::SymbolV("quote".into()), self.visit(quote.expr)?].into(),
-            ))
-        } else {
-            self.inside_quote = true;
-            let res = self.visit(quote.expr);
-            self.inside_quote = false;
-            res
-        }
-    }
-
-    fn visit_macro(&mut self, m: Box<super::ast::Macro>) -> Self::Output {
-        // TODO
-
-        Ok(SteelVal::ListV(
-            vec![
-                SteelVal::SymbolV("define-syntax".into()),
-                self.visit(*m.name)?,
-                self.visit_syntax_rules(m.syntax_rules)?,
-            ]
-            .into(),
-        ))
-
-        // stop!(Generic => "internal compiler error - could not translate macro to steel value")
-    }
-
-    fn visit_atom(&mut self, a: Atom) -> Self::Output {
-        SteelVal::try_from(a.syn)
-    }
-
-    fn visit_list(&mut self, l: super::ast::List) -> Self::Output {
-        let items: std::result::Result<List<_>, SteelErr> =
-            l.args.into_iter().map(|x| self.visit(x)).collect();
-
-        Ok(items?.into())
-    }
-
-    fn visit_syntax_rules(&mut self, s: Box<super::ast::SyntaxRules>) -> Self::Output {
-        Ok(SteelVal::ListV(
-            vec![
-                SteelVal::SymbolV("syntax-rules".into()),
-                SteelVal::ListV(
-                    s.syntax
-                        .into_iter()
-                        .map(|x| self.visit(x))
-                        .collect::<Result<_>>()?,
-                ),
-                SteelVal::ListV(
-                    s.patterns
-                        .into_iter()
-                        .map(|x| {
-                            Ok(SteelVal::ListV(
-                                vec![self.visit(x.pattern)?, self.visit(x.body)?].into(),
-                            ))
-                        })
-                        .collect::<Result<_>>()?,
-                ),
-            ]
-            .into(),
-        ))
-        // TODO
-        // stop!(Generic => "internal compiler error - could not translate syntax-rules to steel value")
-    }
-
-    fn visit_set(&mut self, s: Box<super::ast::Set>) -> Self::Output {
-        let expr = [
-            SteelVal::try_from(s.location)?,
-            self.visit(s.variable)?,
-            self.visit(s.expr)?,
-        ];
-        Ok(SteelVal::ListV(expr.into_iter().collect()))
-    }
-
-    fn visit_require(&mut self, r: super::ast::Require) -> Self::Output {
-        // Just convert it into a list
-
-        // r.modules
-        Ok(SteelVal::ListV(List::cons(
-            SteelVal::SymbolV("require".into()),
-            r.modules
-                .into_iter()
-                .map(|x| self.visit(x))
-                .collect::<Result<_>>()?,
-        )))
-
-        // stop!(Generic => "internal compiler error - could not translate require to steel value")
-    }
-
-    fn visit_let(&mut self, l: Box<super::ast::Let>) -> Self::Output {
-        // todo!()
-
-        let pairs = l
-            .bindings
-            .into_iter()
-            .map(|x| {
-                Ok(SteelVal::ListV(
-                    vec![self.visit(x.0)?, self.visit(x.1)?].into(),
-                ))
-            })
-            .collect::<Result<_>>()?;
-
-        Ok(SteelVal::ListV(
-            vec![
-                SteelVal::SymbolV("%plain-let".into()),
-                SteelVal::ListV(pairs),
-                self.visit(l.body_expr)?,
-            ]
-            .into(),
-        ))
-    }
-}
-
-pub struct SyntaxObjectFromExprKind {
-    _inside_quote: bool,
-}
-
-impl SyntaxObjectFromExprKind {
-    pub fn try_from_expr_kind(e: ExprKind) -> Result<SteelVal> {
-        SyntaxObjectFromExprKind {
-            _inside_quote: false,
-        }
-        .visit(e)
-    }
-}
-
-impl ConsumingVisitor for SyntaxObjectFromExprKind {
-    type Output = Result<SteelVal>;
-
-    fn visit_if(&mut self, f: Box<super::ast::If>) -> Self::Output {
-        let raw = TryFromExprKindForSteelVal::try_from_expr_kind_quoted(ExprKind::If(f.clone()))?;
-
-        let span = f.location.span;
-
-        let expr = [
-            SteelVal::try_from(f.location)?,
-            self.visit(f.test_expr)?,
-            self.visit(f.then_expr)?,
-            self.visit(f.else_expr)?,
-        ];
-        // Ok(Syntax::new_with_source(SteelVal::ListV(expr.into_iter().collect()), span).into())
-
-        Ok(Syntax::proto(raw, SteelVal::ListV(expr.into_iter().collect()), span).into())
-    }
-
-    fn visit_define(&mut self, define: Box<super::ast::Define>) -> Self::Output {
-        let raw: SteelVal = TryFromExprKindForSteelVal::try_from_expr_kind_quoted(
-            ExprKind::Define(define.clone()),
-        )?;
-
-        let span = define.location.span;
-
-        let expr = [
-            SteelVal::try_from(define.location)?,
-            self.visit(define.name)?,
-            self.visit(define.body)?,
-        ];
-        Ok(Syntax::proto(raw, SteelVal::ListV(expr.into_iter().collect()), span).into())
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        lambda_function: Box<super::ast::LambdaFunction>,
-    ) -> Self::Output {
-        let raw = TryFromExprKindForSteelVal::try_from_expr_kind_quoted(ExprKind::LambdaFunction(
-            lambda_function.clone(),
-        ))?;
-
-        let span = lambda_function.location.span;
-
-        let args = lambda_function
-            .args
-            .into_iter()
-            .map(|x| self.visit(x))
-            .collect::<Result<List<_>>>()?;
-
-        let expr = [
-            SteelVal::try_from(lambda_function.location)?,
-            SteelVal::ListV(args),
-            self.visit(lambda_function.body)?,
-        ];
-
-        Ok(Syntax::proto(raw, SteelVal::ListV(expr.into_iter().collect()), span).into())
-    }
-
-    fn visit_begin(&mut self, begin: super::ast::Begin) -> Self::Output {
-        let raw: SteelVal =
-            TryFromExprKindForSteelVal::try_from_expr_kind_quoted(ExprKind::Begin(begin.clone()))?;
-
-        let span = begin.location.span;
-        let mut exprs = vec![SteelVal::try_from(begin.location)?];
-        for expr in begin.exprs {
-            exprs.push(self.visit(expr)?);
-        }
-        Ok(Syntax::proto(raw, SteelVal::ListV(exprs.into()), span).into())
-    }
-
-    fn visit_return(&mut self, r: Box<super::ast::Return>) -> Self::Output {
-        let span = r.location.span;
-        let expr = [SteelVal::try_from(r.location)?, self.visit(r.expr)?];
-        Ok(Syntax::new_with_source(SteelVal::ListV(expr.into_iter().collect()), span).into())
-    }
-
-    // TODO: quotes are handled incorrectly here
-    // Interior values should be handled on their own separately - they should evaluate
-    // like this: '(a b c) => '(a b c)
-    // '(a b 'c) => '(a b 'c) --- currently this ends up as '(a b c)
-    fn visit_quote(&mut self, quote: Box<super::ast::Quote>) -> Self::Output {
-        let span = quote.location.span;
-
-        // if self.inside_quote {
-        let raw =
-            TryFromExprKindForSteelVal::try_from_expr_kind_quoted(ExprKind::Quote(quote.clone()))?;
-        Ok(Syntax::proto(
-            raw,
-            SteelVal::ListV(
-                vec![SteelVal::SymbolV("quote".into()), self.visit(quote.expr)?].into(),
-            ),
-            span,
-        )
-        .into())
-        // } else {
-        // self.inside_quote = true;
-        // let res = self.visit(quote.expr);
-        // self.inside_quote = false;
-        // res
-        // }
-    }
-
-    fn visit_macro(&mut self, _m: Box<super::ast::Macro>) -> Self::Output {
-        // TODO
-        stop!(Generic => "internal compiler error - could not translate macro to steel value")
-    }
-
-    fn visit_atom(&mut self, a: Atom) -> Self::Output {
-        let span = a.syn.span;
-
-        let atom = SteelVal::try_from(a.syn)?;
-
-        Ok(Syntax::proto(atom.clone(), atom, span).into())
-    }
-
-    fn visit_list(&mut self, l: super::ast::List) -> Self::Output {
-        let raw = TryFromExprKindForSteelVal::try_from_expr_kind_quoted(ExprKind::List(l.clone()))?;
-
-        let items: std::result::Result<List<_>, SteelErr> =
-            l.args.into_iter().map(|x| self.visit(x)).collect();
-
-        let items = items?;
-
-        let span_vec = items
-            .iter()
-            .map(|x| {
-                if let SteelVal::SyntaxObject(s) = x {
-                    s.syntax_loc()
-                } else {
-                    unreachable!()
-                }
-            })
-            .collect::<Vec<_>>();
-
-        let span = Span::coalesce_span(&span_vec);
-
-        // TODO: we're currently erasing the source here... This isn't what we want to do but we don't have
-        // a great model to access the source otherwise
-        // log::debug!(
-        //     "Erasing the source information during kernel level expansion for: {:?}",
-        //     raw
-        // );
-        Ok(Syntax::proto(raw, items.into(), span).into())
-    }
-
-    fn visit_syntax_rules(&mut self, _s: Box<super::ast::SyntaxRules>) -> Self::Output {
-        // Ok(SteelVal::ListV(
-        //     vec![
-        //         SteelVal::SymbolV("syntax-rules".into()),
-        //         SteelVal::ListV(
-        //             s.syntax
-        //                 .into_iter()
-        //                 .map(|x| self.visit(x))
-        //                 .collect::<Result<_>>()?,
-        //         ),
-        //         SteelVal::ListV(
-        //             s.patterns
-        //                 .into_iter()
-        //                 .map(|x| {
-        //                     Ok(SteelVal::ListV(
-        //                         vec![self.visit(x.pattern)?, self.visit(x.body)?].into(),
-        //                     ))
-        //                 })
-        //                 .collect::<Result<_>>()?,
-        //         ),
-        //     ]
-        //     .into(),
-        // ))
-
-        // TODO
-        stop!(Generic => "internal compiler error - could not translate syntax-rules to steel value")
-    }
-
-    fn visit_set(&mut self, s: Box<super::ast::Set>) -> Self::Output {
-        let raw: SteelVal =
-            TryFromExprKindForSteelVal::try_from_expr_kind_quoted(ExprKind::Set(s.clone()))?;
-
-        let span = s.location.span;
-        let expr = [
-            SteelVal::try_from(s.location)?,
-            self.visit(s.variable)?,
-            self.visit(s.expr)?,
-        ];
-        Ok(Syntax::proto(raw, SteelVal::ListV(expr.into_iter().collect()), span).into())
-    }
-
-    fn visit_require(&mut self, _s: super::ast::Require) -> Self::Output {
-        stop!(Generic => "internal compiler error - could not translate require to steel value")
-    }
-
-    fn visit_let(&mut self, _l: Box<super::ast::Let>) -> Self::Output {
-        todo!()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::parser::{ast::Quote, parser::SyntaxObject, tokens::TokenType};
-
-    use super::*;
-
-    #[test]
-    fn nested_quotes_handled_correctly() {
-        let expr = ExprKind::Quote(Box::new(Quote::new(
-            ExprKind::List(crate::parser::ast::List::new(vec![
-                ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Define))),
-                ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-                    "applesauce".into(),
-                )))),
-                ExprKind::Quote(Box::new(Quote::new(
-                    ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-                        "bananas".into(),
-                    )))),
-                    SyntaxObject::default(TokenType::Quote),
-                ))),
-            ])),
-            SyntaxObject::default(TokenType::Quote),
-        )));
-
-        let result = TryFromExprKindForSteelVal::try_from_expr_kind(expr);
-
-        println!("{result:?}");
-    }
-}
diff --git a/crates/steel-core/src/parser/visitors.rs b/crates/steel-core/src/parser/visitors.rs
deleted file mode 100644
index 305f4f5df..000000000
--- a/crates/steel-core/src/parser/visitors.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-use crate::parser::ast::*;
-use crate::rvals::Result;
-
-use crate::parser::ast::{
-    Atom, Begin, Define, If, LambdaFunction, Let, List, Macro, Quote, Require, Return, Set,
-    SyntaxRules,
-};
-
-pub trait VisitorMut {
-    type Output;
-
-    fn visit(&mut self, expr: &ExprKind) -> Self::Output {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Let(l) => self.visit_let(l),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-        }
-    }
-
-    fn visit_if(&mut self, f: &If) -> Self::Output;
-    fn visit_define(&mut self, define: &Define) -> Self::Output;
-    fn visit_lambda_function(&mut self, lambda_function: &LambdaFunction) -> Self::Output;
-    fn visit_begin(&mut self, begin: &Begin) -> Self::Output;
-    fn visit_return(&mut self, r: &Return) -> Self::Output;
-    fn visit_quote(&mut self, quote: &Quote) -> Self::Output;
-    fn visit_macro(&mut self, m: &Macro) -> Self::Output;
-    fn visit_atom(&mut self, a: &Atom) -> Self::Output;
-    fn visit_list(&mut self, l: &List) -> Self::Output;
-    fn visit_syntax_rules(&mut self, l: &SyntaxRules) -> Self::Output;
-    fn visit_set(&mut self, s: &Set) -> Self::Output;
-    fn visit_require(&mut self, s: &Require) -> Self::Output;
-    fn visit_let(&mut self, l: &Let) -> Self::Output;
-}
-
-// TODO
-pub trait VisitorMutResult {
-    type Output;
-
-    fn visit(&mut self, expr: &ExprKind) -> Result<Self::Output> {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Let(l) => self.visit_let(l),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-        }
-    }
-
-    fn visit_if(&mut self, f: &If) -> Result<Self::Output>;
-    fn visit_define(&mut self, define: &Define) -> Result<Self::Output>;
-    fn visit_lambda_function(&mut self, lambda_function: &LambdaFunction) -> Result<Self::Output>;
-    fn visit_begin(&mut self, begin: &Begin) -> Result<Self::Output>;
-    fn visit_return(&mut self, r: &Return) -> Result<Self::Output>;
-    fn visit_quote(&mut self, quote: &Quote) -> Result<Self::Output>;
-    fn visit_macro(&mut self, m: &Macro) -> Result<Self::Output>;
-    fn visit_atom(&mut self, e: &Atom) -> Result<Self::Output>;
-    fn visit_list(&mut self, l: &List) -> Result<Self::Output>;
-    fn visit_syntax_rules(&mut self, l: &SyntaxRules) -> Result<Self::Output>;
-    fn visit_set(&mut self, s: &Set) -> Result<Self::Output>;
-    fn visit_require(&mut self, s: &Require) -> Result<Self::Output>;
-    fn visit_let(&mut self, l: &Let) -> Result<Self::Output>;
-}
-
-pub trait Visitor {
-    type Output;
-
-    fn visit(&self, expr: &ExprKind) -> Self::Output {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Let(l) => self.visit_let(l),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-        }
-    }
-
-    fn visit_if(&self, f: &If) -> Self::Output;
-    fn visit_define(&self, define: &Define) -> Self::Output;
-    fn visit_lambda_function(&self, lambda_function: &LambdaFunction) -> Self::Output;
-    fn visit_begin(&self, begin: &Begin) -> Self::Output;
-    fn visit_return(&self, r: &Return) -> Self::Output;
-    fn visit_quote(&self, quote: &Quote) -> Self::Output;
-    fn visit_macro(&self, m: &Macro) -> Self::Output;
-    fn visit_atom(&self, a: &Atom) -> Self::Output;
-    fn visit_list(&self, l: &List) -> Self::Output;
-    fn visit_syntax_rules(&self, l: &SyntaxRules) -> Self::Output;
-    fn visit_set(&self, s: &Set) -> Self::Output;
-    fn visit_require(&self, s: &Require) -> Self::Output;
-    fn visit_let(&self, l: &Let) -> Self::Output;
-}
-
-pub trait ConsumingVisitor {
-    type Output;
-    fn visit(&mut self, expr: ExprKind) -> Self::Output {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Let(l) => self.visit_let(l),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-        }
-    }
-
-    fn visit_if(&mut self, f: Box<If>) -> Self::Output;
-    fn visit_define(&mut self, define: Box<Define>) -> Self::Output;
-    fn visit_lambda_function(&mut self, lambda_function: Box<LambdaFunction>) -> Self::Output;
-    fn visit_begin(&mut self, begin: Begin) -> Self::Output;
-    fn visit_return(&mut self, r: Box<Return>) -> Self::Output;
-    fn visit_quote(&mut self, quote: Box<Quote>) -> Self::Output;
-    fn visit_macro(&mut self, m: Box<Macro>) -> Self::Output;
-    fn visit_atom(&mut self, a: Atom) -> Self::Output;
-    fn visit_list(&mut self, l: List) -> Self::Output;
-    fn visit_syntax_rules(&mut self, l: Box<SyntaxRules>) -> Self::Output;
-    fn visit_set(&mut self, s: Box<Set>) -> Self::Output;
-    fn visit_require(&mut self, s: Require) -> Self::Output;
-    fn visit_let(&mut self, l: Box<Let>) -> Self::Output;
-}
-
-pub trait ConsumingVisitorRef {
-    type Output;
-    fn visit(&self, expr: ExprKind) -> Self::Output {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Let(l) => self.visit_let(l),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-        }
-    }
-
-    fn visit_if(&self, f: Box<If>) -> Self::Output;
-    fn visit_define(&self, define: Box<Define>) -> Self::Output;
-    fn visit_lambda_function(&self, lambda_function: Box<LambdaFunction>) -> Self::Output;
-    fn visit_begin(&self, begin: Begin) -> Self::Output;
-    fn visit_return(&self, r: Box<Return>) -> Self::Output;
-    fn visit_quote(&self, quote: Box<Quote>) -> Self::Output;
-    fn visit_macro(&self, m: Box<Macro>) -> Self::Output;
-    fn visit_atom(&self, a: Atom) -> Self::Output;
-    fn visit_list(&self, l: List) -> Self::Output;
-    fn visit_syntax_rules(&self, l: Box<SyntaxRules>) -> Self::Output;
-    fn visit_set(&self, s: Box<Set>) -> Self::Output;
-    fn visit_require(&self, s: Require) -> Self::Output;
-    fn visit_let(&self, l: Box<Let>) -> Self::Output;
-}
-
-pub trait VisitorMutRef {
-    type Output;
-
-    fn visit(&mut self, expr: &mut ExprKind) -> Self::Output {
-        match expr {
-            ExprKind::If(f) => self.visit_if(f),
-            ExprKind::Define(d) => self.visit_define(d),
-            ExprKind::LambdaFunction(l) => self.visit_lambda_function(l),
-            ExprKind::Begin(b) => self.visit_begin(b),
-            ExprKind::Return(r) => self.visit_return(r),
-            ExprKind::Let(l) => self.visit_let(l),
-            ExprKind::Quote(q) => self.visit_quote(q),
-            ExprKind::Macro(m) => self.visit_macro(m),
-            ExprKind::Atom(a) => self.visit_atom(a),
-            ExprKind::List(l) => self.visit_list(l),
-            ExprKind::SyntaxRules(s) => self.visit_syntax_rules(s),
-            ExprKind::Set(s) => self.visit_set(s),
-            ExprKind::Require(r) => self.visit_require(r),
-        }
-    }
-
-    fn visit_if(&mut self, f: &mut If) -> Self::Output;
-    fn visit_define(&mut self, define: &mut Define) -> Self::Output;
-    fn visit_lambda_function(&mut self, lambda_function: &mut LambdaFunction) -> Self::Output;
-    fn visit_begin(&mut self, begin: &mut Begin) -> Self::Output;
-    fn visit_return(&mut self, r: &mut Return) -> Self::Output;
-    fn visit_quote(&mut self, quote: &mut Quote) -> Self::Output;
-    fn visit_macro(&mut self, m: &mut Macro) -> Self::Output;
-    fn visit_atom(&mut self, a: &mut Atom) -> Self::Output;
-    fn visit_list(&mut self, l: &mut List) -> Self::Output;
-    fn visit_syntax_rules(&mut self, l: &mut SyntaxRules) -> Self::Output;
-    fn visit_set(&mut self, s: &mut Set) -> Self::Output;
-    fn visit_require(&mut self, s: &mut Require) -> Self::Output;
-    fn visit_let(&mut self, l: &mut Let) -> Self::Output;
-}
diff --git a/crates/steel-core/src/primitives.rs b/crates/steel-core/src/primitives.rs
deleted file mode 100644
index e3d082600..000000000
--- a/crates/steel-core/src/primitives.rs
+++ /dev/null
@@ -1,677 +0,0 @@
-pub mod contracts;
-mod control;
-mod fs;
-pub mod hashmaps;
-pub mod hashsets;
-mod io;
-pub mod lists;
-pub mod meta_ops;
-pub mod nums;
-pub mod ports;
-pub mod process;
-pub mod random;
-mod streams;
-pub mod strings;
-mod symbols;
-pub mod time;
-pub mod transducers;
-mod utils;
-mod vectors;
-
-#[cfg(feature = "web")]
-pub mod web;
-
-#[cfg(feature = "sqlite")]
-pub mod sqlite;
-
-pub use lists::UnRecoverableResult;
-
-use crate::values::closed::HeapRef;
-use crate::values::lists::List;
-pub use control::ControlOperations;
-pub use fs::fs_module;
-pub use io::IoFunctions;
-pub use meta_ops::MetaOperations;
-pub use nums::NumOperations;
-pub use ports::port_module;
-pub use streams::StreamOperations;
-pub use symbols::SymbolOperations;
-pub use vectors::VectorOperations;
-
-pub use strings::string_module;
-
-pub use nums::{add_primitive, divide_primitive, multiply_primitive, subtract_primitive};
-
-use crate::rvals::{
-    FunctionSignature, PrimitiveAsRef, SteelHashMap, SteelHashSet, SteelVal, SteelVector,
-};
-use crate::values::port::SteelPort;
-use crate::{
-    rerrs::{ErrorKind, SteelErr},
-    rvals::SteelString,
-};
-use im_rc::Vector;
-
-use std::cell::RefCell;
-use std::convert::TryFrom;
-use std::result;
-
-use crate::rvals::{FromSteelVal, IntoSteelVal};
-
-use crate::gc::Gc;
-
-macro_rules! try_from_impl {
-    ($type:ident => $($body:ty),*) => {
-        $(
-            impl TryFrom<SteelVal> for $body {
-                type Error = SteelErr;
-                fn try_from(value: SteelVal) -> result::Result<Self, Self::Error> {
-                    match value {
-                        SteelVal::$type(x) => Ok(x.clone() as $body),
-                        _ => Err(SteelErr::new(ErrorKind::ConversionError, format!("Expected number, found: {}", value))),
-                    }
-                }
-            }
-
-            impl TryFrom<&SteelVal> for $body {
-                type Error = SteelErr;
-                fn try_from(value: &SteelVal) -> result::Result<Self, Self::Error> {
-                    match value {
-                        SteelVal::$type(x) => Ok(x.clone() as $body),
-                        _ => Err(SteelErr::new(ErrorKind::ConversionError, format!("Expected number, found: {}", value))),
-                    }
-                }
-            }
-
-            impl FromSteelVal for $body {
-                fn from_steelval(value: &SteelVal) -> result::Result<Self, SteelErr> {
-                    match value {
-                        SteelVal::$type(x) => Ok(x.clone() as $body),
-                        _ => Err(SteelErr::new(ErrorKind::ConversionError, format!("Expected number, found: {}", value))),
-                    }
-                }
-            }
-
-        )*
-    };
-}
-
-macro_rules! from_f64 {
-    ($($body:ty),*) => {
-        $(
-            impl From<$body> for SteelVal {
-                fn from(val: $body) -> SteelVal {
-                    SteelVal::NumV(val as f64)
-                }
-            }
-
-            impl IntoSteelVal for $body {
-                fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-                    Ok(SteelVal::NumV(self as f64))
-                }
-            }
-        )*
-    };
-}
-
-macro_rules! from_for_isize {
-    ($($body:ty),*) => {
-        $(
-            impl From<$body> for SteelVal {
-                fn from(val: $body) -> SteelVal {
-                    SteelVal::IntV(val as isize)
-                }
-            }
-
-            impl IntoSteelVal for $body {
-                fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-                    Ok(SteelVal::IntV(self as isize))
-                }
-            }
-        )*
-    };
-}
-
-impl From<i64> for SteelVal {
-    fn from(value: i64) -> Self {
-        if let Ok(converted) = TryInto::<isize>::try_into(value) {
-            SteelVal::IntV(converted)
-        } else {
-            SteelVal::BigNum(Gc::new(value.into()))
-        }
-    }
-}
-
-impl IntoSteelVal for i64 {
-    fn into_steelval(self) -> crate::rvals::Result<SteelVal> {
-        Ok(self.into())
-    }
-}
-
-impl FromSteelVal for i64 {
-    fn from_steelval(val: &SteelVal) -> crate::rvals::Result<Self> {
-        match val {
-            SteelVal::IntV(v) => (*v).try_into().map_err(|_err| {
-                SteelErr::new(
-                    ErrorKind::ConversionError,
-                    format!("Unable to convert i64 to isize: {}", v),
-                )
-            }),
-            SteelVal::BigNum(n) => n.as_ref().try_into().map_err(|_err| {
-                SteelErr::new(
-                    ErrorKind::ConversionError,
-                    format!("Unable to convert bignum to isize: {:?}", n),
-                )
-            }),
-            _ => Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                format!("Unable to convert steelval to isize: {}", val),
-            )),
-        }
-    }
-}
-
-impl From<char> for SteelVal {
-    fn from(val: char) -> SteelVal {
-        SteelVal::CharV(val)
-    }
-}
-
-impl IntoSteelVal for char {
-    fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-        Ok(SteelVal::CharV(self))
-    }
-}
-
-impl FromSteelVal for char {
-    fn from_steelval(val: &SteelVal) -> Result<Self, SteelErr> {
-        if let SteelVal::CharV(c) = val {
-            Ok(*c)
-        } else {
-            Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                "Expected character".to_string(),
-            ))
-        }
-    }
-}
-
-impl<T: Into<SteelVal>> From<Option<T>> for SteelVal {
-    fn from(val: Option<T>) -> SteelVal {
-        if let Some(s) = val {
-            s.into()
-        } else {
-            SteelVal::BoolV(true)
-        }
-    }
-}
-
-impl<T: IntoSteelVal> IntoSteelVal for Option<T> {
-    fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-        if let Some(s) = self {
-            s.into_steelval()
-        } else {
-            Ok(SteelVal::BoolV(false))
-        }
-    }
-}
-
-impl<T: FromSteelVal> FromSteelVal for Option<T> {
-    fn from_steelval(val: &SteelVal) -> Result<Self, SteelErr> {
-        if val.is_truthy() {
-            Ok(Some(T::from_steelval(val)?))
-        } else {
-            Ok(None)
-        }
-    }
-}
-
-impl FromSteelVal for SteelVal {
-    fn from_steelval(val: &SteelVal) -> Result<Self, SteelErr> {
-        Ok(val.clone())
-    }
-}
-
-// TODO make intosteelval return a result type
-// This allows errors to propagate
-// @Matt - TODO: 4/29/22 -> Decide how natively Result and Option types should be integrated
-// Directly into Steel. At the moment we _could_ bail out and just rely entirely on Rust
-// types, but then we may have to more carefully integrate with functions in the std library
-// in order to interact. We also could convert directly into a Steel representation, i.e.
-// (make-struct Ok (x))
-// (make-struct Err (x))
-// This could make it easier to integrate natively, but also opaquely wrapping it allows for
-// perhaps better performance
-// impl<T: IntoSteelVal, E: IntoSteelVal> Custom for Result<T, E> {}
-
-// impl<T: IntoSteelVal, E: std::fmt::Debug> IntoSteelVal for Result<T, E> {
-//     fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-//         match self {
-//             Ok(s) => Ok(create_result_ok_struct(s.into_steelval()?)),
-//             Err(e) => crate::stop!(Generic => format!("{:?}", e)),
-//         }
-//     }
-// }
-
-// impl<T: IntoSteelVal, E: std::fmt::Debug> IntoSteelVal for Result<T, E> {
-//     fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-
-//     }
-// }
-
-// impl<T: FromSteelVal, E: FromSteelVal> FromSteelVal for Result<T, E> {
-//     fn from_steelval(val: &SteelVal) -> Result<Self, SteelErr> {
-//         if val.is_struct() {
-//             if let SteelVal::MutableVector(v) = val {
-//                 let lock = v.borrow();
-//                 // 0 -> magic symbol
-//                 // 1 -> name
-//                 // 2 -> options
-//                 // 3 -> data
-//                 let name = lock.get(1);
-//                 let inner = lock.get(3);
-
-//                 if let Some(SteelVal::SymbolV(name)) = name {
-//                     match name.as_str() {
-//                         "Ok" => Ok(Ok(T::from_steelval(inner.unwrap())?)),
-//                         "Err" => Ok(Err(E::from_steelval(inner.unwrap())?)),
-//                         _ => {
-//                             stop!(ConversionError => format!("Failed converting an instance of a steel struct into a Rust result type: found an instance of a struct with the name: {:?}, expecting either `Ok` or `Err`", name))
-//                         }
-//                     }
-//                 } else {
-//                     stop!(ConversionError => format!("Failed attempting to convert an instance of a steelval into a result type, found an instance of a struct without a name - expected a name and found: {:?}", name))
-//                 }
-//             } else {
-//                 unreachable!()
-//             }
-//         } else {
-//             stop!(ConversionError => format!("Failed attempting to convert an instance of a steelval into a result type: {:?}", val));
-//         }
-//     }
-// }
-
-impl FromSteelVal for () {
-    fn from_steelval(val: &SteelVal) -> Result<Self, SteelErr> {
-        if let SteelVal::Void = val {
-            Ok(())
-        } else {
-            crate::stop!(ConversionError => "could not convert value to unit type")
-        }
-    }
-}
-
-impl IntoSteelVal for () {
-    fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-        Ok(SteelVal::Void)
-    }
-}
-
-impl From<()> for SteelVal {
-    fn from(_: ()) -> SteelVal {
-        SteelVal::Void
-    }
-}
-
-from_f64!(f64, f32);
-from_for_isize!(i32, i16, i8, u8, u16, u32, u64, usize, isize);
-try_from_impl!(NumV => f64, f32);
-try_from_impl!(IntV => i32, i16, i8, u8, u16, u32, u64, usize, isize);
-
-impl TryFrom<SteelVal> for String {
-    type Error = SteelErr;
-    fn try_from(value: SteelVal) -> result::Result<Self, Self::Error> {
-        match value {
-            SteelVal::StringV(ref x) => Ok(x.to_string()),
-            SteelVal::SymbolV(ref x) => Ok(x.to_string()),
-            _ => Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                "Expected string".to_string(),
-            )),
-        }
-    }
-}
-
-impl From<SteelVal> for Gc<SteelVal> {
-    fn from(val: SteelVal) -> Self {
-        Gc::new(val)
-    }
-}
-
-impl From<Gc<SteelVal>> for SteelVal {
-    fn from(val: Gc<SteelVal>) -> Self {
-        (*val).clone()
-    }
-}
-
-impl FromSteelVal for String {
-    fn from_steelval(val: &SteelVal) -> Result<Self, SteelErr> {
-        match val {
-            SteelVal::StringV(s) | SteelVal::SymbolV(s) => Ok(s.to_string()),
-            _ => Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                format!("Expected string, found: {val}"),
-            )),
-        }
-    }
-}
-
-impl TryFrom<&SteelVal> for String {
-    type Error = SteelErr;
-    fn try_from(value: &SteelVal) -> result::Result<Self, Self::Error> {
-        match value {
-            SteelVal::StringV(x) => Ok(x.to_string()),
-            SteelVal::SymbolV(x) => Ok(x.to_string()),
-            _ => Err(SteelErr::new(
-                ErrorKind::ConversionError,
-                "Expected string".to_string(),
-            )),
-        }
-    }
-}
-
-impl From<String> for SteelVal {
-    fn from(val: String) -> SteelVal {
-        SteelVal::StringV(val.into())
-    }
-}
-
-impl IntoSteelVal for &str {
-    #[inline(always)]
-    fn into_steelval(self) -> crate::rvals::Result<SteelVal> {
-        Ok(SteelVal::StringV(self.into()))
-    }
-}
-
-impl FromSteelVal for SteelString {
-    fn from_steelval(val: &SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::StringV(s) = val {
-            Ok(s.clone())
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel string", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a Gc<RefCell<SteelVal>> {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::Boxed(c) = val {
-            Ok(c)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel boxed value", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a HeapRef<SteelVal> {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::HeapAllocated(b) = val {
-            Ok(b)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel box", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a char {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::CharV(c) = val {
-            Ok(c)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel character", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for char {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::CharV(c) = val {
-            Ok(*c)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel character", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for isize {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::IntV(i) = val {
-            Ok(*i)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel int", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a Gc<Vector<SteelVal>> {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::VectorV(p) = val {
-            Ok(&p.0)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel vector", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a SteelVector {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::VectorV(p) = val {
-            Ok(p)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel vector", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a Gc<im_rc::HashSet<SteelVal>> {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::HashSetV(p) = val {
-            Ok(&p.0)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel hashset", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a SteelHashSet {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::HashSetV(p) = val {
-            Ok(p)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel hashset", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a HeapRef<Vec<SteelVal>> {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::MutableVector(p) = val {
-            Ok(p)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel mutable vector", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a SteelPort {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::PortV(p) = val {
-            Ok(p)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel port", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a List<SteelVal> {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::ListV(l) = val {
-            Ok(l)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {} to steel list", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a SteelVal {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        Ok(val)
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a SteelString {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::StringV(s) = val {
-            Ok(s)
-        } else {
-            crate::stop!(TypeMismatch => format!("Cannot convert steel value: {} to steel string", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a Gc<im_rc::HashMap<SteelVal, SteelVal>> {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::HashMapV(hm) = val {
-            Ok(&hm.0)
-        } else {
-            crate::stop!(ConversionError => format!("Canto convert steel value: {} to hashmap", val))
-        }
-    }
-}
-
-impl<'a> PrimitiveAsRef<'a> for &'a SteelHashMap {
-    #[inline(always)]
-    fn primitive_as_ref(val: &'a SteelVal) -> crate::rvals::Result<Self> {
-        if let SteelVal::HashMapV(hm) = val {
-            Ok(hm)
-        } else {
-            crate::stop!(ConversionError => format!("Canto convert steel value: {} to hashmap", val))
-        }
-    }
-}
-
-impl IntoSteelVal for String {
-    fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-        Ok(SteelVal::StringV(self.into()))
-    }
-}
-
-impl IntoSteelVal for SteelString {
-    fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-        Ok(SteelVal::StringV(self))
-    }
-}
-
-impl From<String> for Gc<SteelVal> {
-    fn from(val: String) -> Gc<SteelVal> {
-        Gc::new(val.into())
-    }
-}
-
-impl From<bool> for SteelVal {
-    fn from(val: bool) -> SteelVal {
-        SteelVal::BoolV(val)
-    }
-}
-
-impl FromSteelVal for bool {
-    fn from_steelval(val: &SteelVal) -> crate::rvals::Result<bool> {
-        if let SteelVal::BoolV(b) = val {
-            Ok(*b)
-        } else {
-            crate::stop!(ConversionError => format!("Cannot convert steel value: {val} to boolean"))
-        }
-    }
-}
-
-impl IntoSteelVal for bool {
-    fn into_steelval(self) -> Result<SteelVal, SteelErr> {
-        Ok(SteelVal::BoolV(self))
-    }
-}
-
-impl From<Vector<SteelVal>> for SteelVal {
-    fn from(val: Vector<SteelVal>) -> SteelVal {
-        SteelVal::VectorV(Gc::new(val).into())
-    }
-}
-
-impl From<FunctionSignature> for SteelVal {
-    fn from(val: FunctionSignature) -> SteelVal {
-        SteelVal::FuncV(val)
-    }
-}
-
-#[cfg(test)]
-mod try_from_tests {
-
-    use super::*;
-
-    #[test]
-    fn from_char() {
-        assert_eq!(SteelVal::from('c'), SteelVal::CharV('c'));
-    }
-
-    #[test]
-    fn from_steelval_char() {
-        assert_eq!(char::from_steelval(&SteelVal::CharV('c')).unwrap(), 'c')
-    }
-
-    #[test]
-    fn into_steelval_char() {
-        assert_eq!('c'.into_steelval().unwrap(), SteelVal::CharV('c'))
-    }
-
-    #[test]
-    fn from_steelval_usize() {
-        assert_eq!(usize::from_steelval(&SteelVal::IntV(10)).unwrap(), 10)
-    }
-
-    #[test]
-    fn from_steelval_i32() {
-        assert_eq!(i32::from_steelval(&SteelVal::IntV(32)).unwrap(), 32)
-    }
-
-    #[test]
-    fn into_steelval_i32() {
-        assert_eq!(32.into_steelval().unwrap(), SteelVal::IntV(32))
-    }
-
-    #[test]
-    fn from_bool() {
-        assert_eq!(SteelVal::from(true), SteelVal::BoolV(true));
-    }
-
-    #[test]
-    fn try_from_steelval_string() {
-        let expected = "foo".to_string();
-        let input = SteelVal::StringV("foo".into());
-
-        let res = String::try_from(input);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn try_from_steelval_ref_string() {
-        let expected = "foo".to_string();
-        let input = SteelVal::StringV("foo".into());
-
-        let res = String::try_from(&input);
-        assert_eq!(res.unwrap(), expected);
-    }
-}
diff --git a/crates/steel-core/src/primitives/contracts.rs b/crates/steel-core/src/primitives/contracts.rs
deleted file mode 100644
index 3bc1dcdd7..000000000
--- a/crates/steel-core/src/primitives/contracts.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-// use crate::values::contracts::*;
-// use crate::{builtin_stop, stop};
-// use crate::{
-//     rvals::{Result, SteelVal},
-//     steel_vm::vm::VmCore,
-// };
-
-// pub const MAKE_C: SteelVal = SteelVal::FuncV(make_c);
-// pub const MAKE_DEPENDENT_CONTRACT: SteelVal = SteelVal::FuncV(make_dependent_contract);
-// pub const MAKE_FLAT_CONTRACT: SteelVal = SteelVal::FuncV(make_flat_contract);
-// pub const MAKE_FUNCTION_CONTRACT: SteelVal = SteelVal::FuncV(make_function_contract);
-// pub const BIND_CONTRACT_TO_FUNCTION: SteelVal = SteelVal::BuiltIn(bind_contract_to_function);
-
-// pub fn make_c(args: &[SteelVal]) -> Result<SteelVal> {
-//     if args.is_empty() {
-//         stop!(ArityMismatch => "make/c given no arguments");
-//     }
-
-//     let contract = args[0].clone();
-//     if contract.is_contract() {
-//         return Ok(contract);
-//     }
-
-//     if args.len() == 2 {
-//         let function = args[0].clone();
-//         let name = args[1].clone();
-
-//         if function.is_function() {
-//             return FlatContract::new_from_steelval(function, name.to_string());
-//         }
-//     }
-
-//     if let Some((last, elements)) = args.split_last() {
-//         let last = last.clone();
-//         FunctionContract::new_from_steelval(elements, last)
-//     } else {
-//         stop!(ArityMismatch => "function contract missing range position")
-//     }
-// }
-
-// pub fn make_dependent_contract(args: &[SteelVal]) -> Result<SteelVal> {
-//     if let Some((last, elements)) = args.split_last() {
-//         let last = last.clone();
-//         DependentContract::new_from_steelvals(elements, last)
-//     } else {
-//         stop!(ArityMismatch => "function contract missing range position")
-//     }
-// }
-
-// pub fn make_flat_contract(args: &[SteelVal]) -> Result<SteelVal> {
-//     if args.len() != 2 {
-//         stop!(ArityMismatch => "make/c requires 2 argments, the contract and the name")
-//     }
-
-//     let function = args[0].clone();
-//     let name = args[1].clone();
-
-//     if let SteelVal::SymbolV(s) = name {
-//         FlatContract::new_from_steelval(function, s.to_string())
-//     } else {
-//         stop!(TypeMismatch => "make-flat/c requires a symbol for the name in the second position")
-//     }
-// }
-
-// pub fn make_function_contract(args: &[SteelVal]) -> Result<SteelVal> {
-//     if let Some((last, elements)) = args.split_last() {
-//         let last = last.clone();
-//         FunctionContract::new_from_steelval(elements, last)
-//     } else {
-//         stop!(ArityMismatch => "function contract missing range position")
-//     }
-// }
-
-// pub fn bind_contract_to_function(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-//     if args.len() < 2 || args.len() > 4 {
-//         builtin_stop!(ArityMismatch => "bind/c requires 2 arguments, a contract and a function")
-//     }
-
-//     let contract = args[0].clone();
-//     let function = args[1].clone();
-
-//     if !ctx.thread.runtime_options.contracts_on {
-//         return Some(Ok(function));
-//     }
-
-//     let name = args.get(2).cloned();
-
-//     Some(ContractedFunction::new_from_steelvals(
-//         contract, function, name,
-//     ))
-// }
diff --git a/crates/steel-core/src/primitives/control.rs b/crates/steel-core/src/primitives/control.rs
deleted file mode 100644
index 67616fdd2..000000000
--- a/crates/steel-core/src/primitives/control.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use crate::rvals::{Result, SteelVal};
-use crate::stop;
-
-pub struct ControlOperations {}
-impl ControlOperations {
-    pub fn to_string() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            let mut error_message = String::new();
-
-            for arg in args {
-                let error_val = arg.to_string();
-                error_message.push(' ');
-                error_message.push_str(error_val.trim_matches('\"'));
-            }
-
-            Ok(SteelVal::StringV(error_message.into()))
-        })
-    }
-
-    pub fn error() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            let mut error_message = String::new();
-
-            if !args.is_empty() {
-                for arg in args {
-                    let error_val = arg.to_string();
-                    error_message.push(' ');
-                    error_message.push_str(error_val.trim_matches('\"'));
-                }
-
-                stop!(Generic => error_message);
-            } else {
-                stop!(ArityMismatch => "error takes at least one argument");
-            }
-        })
-    }
-}
diff --git a/crates/steel-core/src/primitives/fs.rs b/crates/steel-core/src/primitives/fs.rs
deleted file mode 100644
index bb5f7840e..000000000
--- a/crates/steel-core/src/primitives/fs.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-use crate::rvals::{Custom, Result, SteelString, SteelVal};
-use crate::steel_vm::builtin::BuiltInModule;
-use crate::stop;
-use std::env::current_dir;
-use std::path::{Path, PathBuf};
-
-use std::fs;
-use std::io;
-
-fn get_extension_from_filename(filename: &str) -> Option<&str> {
-    Path::new(filename)
-        .extension()
-        .and_then(std::ffi::OsStr::to_str)
-}
-
-/// Copy files from source to destination recursively.
-/// from https://nick.groenen.me/notes/recursively-copy-files-in-rust/
-pub fn copy_recursively(source: impl AsRef<Path>, destination: impl AsRef<Path>) -> io::Result<()> {
-    fs::create_dir_all(&destination)?;
-    for entry in fs::read_dir(source)? {
-        let entry = entry?;
-        let filetype = entry.file_type()?;
-        if filetype.is_dir() {
-            copy_recursively(entry.path(), destination.as_ref().join(entry.file_name()))?;
-        } else {
-            fs::copy(entry.path(), destination.as_ref().join(entry.file_name()))?;
-        }
-    }
-    Ok(())
-}
-
-impl Custom for PathBuf {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("#<Path:{:?}>", self)))
-    }
-}
-
-/// # steel/filesystem
-///
-/// Filesystem functions, mostly just thin wrappers around the `std::fs` functions in
-/// the Rust std library.
-#[steel_derive::define_module(name = "steel/filesystem")]
-pub fn fs_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/filesystem");
-    module
-        .register_native_fn_definition(DELETE_DIRECTORY_DEFINITION)
-        .register_native_fn_definition(CREATE_DIRECTORY_DEFINITION)
-        .register_native_fn_definition(COPY_DIRECTORY_RECURSIVELY_DEFINITION)
-        .register_native_fn_definition(IS_DIR_DEFINITION)
-        .register_native_fn_definition(IS_FILE_DEFINITION)
-        .register_native_fn_definition(READ_DIR_DEFINITION)
-        .register_native_fn_definition(PATH_EXISTS_DEFINITION)
-        .register_native_fn_definition(FILE_NAME_DEFINITION)
-        .register_native_fn_definition(CURRENT_DIRECTORY_DEFINITION)
-        .register_native_fn_definition(GET_EXTENSION_DEFINITION);
-    module
-}
-
-/// Deletes the directory
-#[steel_derive::function(name = "delete-directory!")]
-pub fn delete_directory(directory: &SteelString) -> Result<SteelVal> {
-    std::fs::remove_dir_all(directory.as_str())?;
-    Ok(SteelVal::Void)
-}
-
-/// Creates the directory
-#[steel_derive::function(name = "create-directory!")]
-pub fn create_directory(directory: &SteelString) -> Result<SteelVal> {
-    std::fs::create_dir_all(directory.as_str())?;
-
-    Ok(SteelVal::Void)
-}
-
-/// Recursively copies the directory from source to destination
-#[steel_derive::function(name = "copy-directory-recursively!")]
-pub fn copy_directory_recursively(
-    source: &SteelString,
-    destination: &SteelString,
-) -> Result<SteelVal> {
-    copy_recursively(source.as_str(), destination.as_str())?;
-
-    Ok(SteelVal::Void)
-}
-
-/// Checks if a path exists
-#[steel_derive::function(name = "path-exists?")]
-pub fn path_exists(path: &SteelString) -> Result<SteelVal> {
-    Ok(SteelVal::BoolV(Path::new(path.as_ref()).exists()))
-}
-
-/// Checks if a path is a file
-#[steel_derive::function(name = "is-file?")]
-pub fn is_file(path: &SteelString) -> Result<SteelVal> {
-    Ok(SteelVal::BoolV(Path::new(path.as_ref()).is_file()))
-}
-
-/// Checks if a path is a directory
-#[steel_derive::function(name = "is-dir?")]
-pub fn is_dir(path: &SteelString) -> Result<SteelVal> {
-    Ok(SteelVal::BoolV(Path::new(path.as_ref()).is_dir()))
-}
-
-/// Gets the extension from a path
-#[steel_derive::function(name = "path->extension")]
-pub fn get_extension(path: &SteelString) -> Result<SteelVal> {
-    if let Some(ext) = get_extension_from_filename(path) {
-        Ok(SteelVal::StringV(ext.into()))
-    } else {
-        Ok(SteelVal::Void)
-    }
-}
-
-/// Gets the filename for a given path
-#[steel_derive::function(name = "file-name")]
-pub fn file_name(path: &SteelString) -> Result<SteelVal> {
-    Ok(SteelVal::StringV(
-        Path::new(path.as_str())
-            .file_name()
-            .and_then(|x| x.to_str())
-            .unwrap_or("")
-            .into(),
-    ))
-}
-
-/// Returns the contents of the directory as a list
-#[steel_derive::function(name = "read-dir")]
-pub fn read_dir(path: &SteelString) -> Result<SteelVal> {
-    let p = Path::new(path.as_ref());
-    if p.is_dir() {
-        let iter = p.read_dir();
-        match iter {
-            Ok(i) => Ok(SteelVal::ListV(
-                i.into_iter()
-                    .map(|x| match x?.path().to_str() {
-                        Some(s) => Ok(SteelVal::StringV(s.into())),
-                        None => Ok(SteelVal::BoolV(false)),
-                    })
-                    .collect::<Result<_>>()?,
-            )),
-            Err(e) => stop!(Generic => e.to_string()),
-        }
-    } else {
-        stop!(TypeMismatch => "read-dir expected a dir, found a file: {}", path)
-    }
-}
-
-/// Check the current working directory
-#[steel_derive::function(name = "current-directory")]
-pub fn current_directory() -> Result<SteelVal> {
-    let path = current_dir()?;
-    Ok(SteelVal::StringV(path.to_str().unwrap_or("").into()))
-}
diff --git a/crates/steel-core/src/primitives/hashmaps.rs b/crates/steel-core/src/primitives/hashmaps.rs
deleted file mode 100644
index 0bc4136f3..000000000
--- a/crates/steel-core/src/primitives/hashmaps.rs
+++ /dev/null
@@ -1,621 +0,0 @@
-use crate::{core::utils::declare_const_ref_functions, gc::Gc};
-use crate::{
-    rvals::{Result, SteelVal},
-    steel_vm::builtin::BuiltInModule,
-};
-use crate::{steel_vm::builtin::DocTemplate, stop};
-use im_rc::HashMap;
-
-use crate::primitives::VectorOperations;
-
-use steel_derive::function;
-
-declare_const_ref_functions!(
-    HM_CONSTRUCT => hm_construct,
-    HM_INSERT => steel_hash_insert,
-    HM_GET => steel_hash_ref,
-    HM_VALUES_TO_LIST => values_to_list,
-    HM_KEYS_TO_VEC => keys_to_vector,
-    HM_VALUES_TO_VEC => values_to_vector,
-    HM_CLEAR => clear,
-    HM_EMPTY => hm_empty,
-    HM_UNION => hm_union,
-);
-
-pub(crate) fn hashmap_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/hash".to_string());
-    module
-        .register_value_with_doc("hash", HM_CONSTRUCT, HASH_DOC)
-        .register_value("%keyword-hash", SteelVal::FuncV(hm_construct_keywords))
-        .register_native_fn_definition(HASH_INSERT_DEFINITION)
-        .register_native_fn_definition(HASH_REF_DEFINITION)
-        .register_value("hash-get", SteelVal::FuncV(steel_hash_ref))
-        .register_native_fn_definition(HASH_TRY_GET_DEFINITION)
-        .register_native_fn_definition(HASH_LENGTH_DEFINITION)
-        .register_native_fn_definition(HASH_CONTAINS_DEFINITION)
-        .register_native_fn_definition(KEYS_TO_LIST_DEFINITION)
-        .register_value("hash-keys->vector", HM_KEYS_TO_VEC)
-        .register_value_with_doc(
-            "hash-values->list",
-            HM_VALUES_TO_LIST,
-            HASH_VALUES_TO_LIST_DOC,
-        )
-        .register_value("hash-values->vector", HM_VALUES_TO_VEC)
-        .register_value("hash-clear", HM_CLEAR)
-        .register_value("hash-empty?", HM_EMPTY)
-        .register_value("hash-union", HM_UNION);
-    module
-}
-
-const HASH_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(hash key val ...) -> hash?",
-    params: &["key : hashable?", "val : any/c"],
-    description: r#"Creates an immutable hash table with each given `key` mapped to the following `val`; each key must have a val, so the total number of arguments must be even.
-    
-Note, the key must be hashable."#,
-    examples: &[(
-        "> (hash 'a 10 'b 20)",
-        r#"=> #<hashmap {
-        'a: 10,
-        'b: 20,
-    }>"#,
-    )],
-};
-
-pub fn hm_construct(args: &[SteelVal]) -> Result<SteelVal> {
-    let mut hm = HashMap::new();
-
-    let mut arg_iter = args.iter().cloned();
-
-    loop {
-        match (arg_iter.next(), arg_iter.next()) {
-            (Some(key), Some(value)) => {
-                if key.is_hashable() {
-                    hm.insert(key, value);
-                } else {
-                    stop!(TypeMismatch => "hash key not hashable!");
-                }
-            }
-            (None, None) => break,
-            _ => {
-                stop!(ArityMismatch => "hash map must have a value for every key!");
-            }
-        }
-    }
-
-    Ok(SteelVal::HashMapV(Gc::new(hm).into()))
-}
-
-pub fn hm_construct_keywords(args: &[SteelVal]) -> Result<SteelVal> {
-    let mut hm = HashMap::new();
-
-    let mut arg_iter = args.iter().cloned();
-
-    loop {
-        match (arg_iter.next(), arg_iter.next()) {
-            (Some(key), Some(value)) => {
-                if key.is_hashable() {
-                    hm.insert(key, value);
-                } else {
-                    stop!(TypeMismatch => "hash key not hashable!");
-                }
-            }
-            (None, None) => break,
-            _ => {
-                stop!(ArityMismatch => "Missing keyword argument!");
-            }
-        }
-    }
-
-    Ok(SteelVal::HashMapV(Gc::new(hm).into()))
-}
-
-/// Returns a new hashmap with the additional key value pair added. Performs a functional update,
-/// so the old hash map is still accessible.
-///
-/// (hash-insert map key val) -> hash?
-///
-/// * map : hash?
-/// * key : any/c
-/// * val : any/c
-///
-/// # Examples
-/// ```scheme
-/// > (hash-insert (hash 'a 10 'b 20) 'c 30)
-///
-/// => #<hashmap {
-///         'a: 10,
-///         'b: 20,
-///         'c: 30
-///     }>
-/// ```
-#[function(name = "hash-insert")]
-pub fn hash_insert(
-    map: &Gc<HashMap<SteelVal, SteelVal>>,
-    key: SteelVal,
-    value: SteelVal,
-) -> Result<SteelVal> {
-    if key.is_hashable() {
-        Ok(SteelVal::HashMapV(Gc::new(map.update(key, value)).into()))
-    } else {
-        stop!(TypeMismatch => "hash key not hashable: {:?}", key)
-    }
-}
-
-/// Gets the `key` from the given `map`. Raises an error if the key does not exist. `hash-get` is an alias for this.
-///
-/// (hash-ref map key) -> any/c
-///
-/// * map : hash?
-/// * key : any/c
-///
-/// # Examples
-/// ```scheme
-/// > (hash-ref (hash 'a 10 'b 20) 'b) ;; => 20
-/// ```
-#[function(name = "hash-ref")]
-pub fn hash_ref(map: &Gc<HashMap<SteelVal, SteelVal>>, key: &SteelVal) -> Result<SteelVal> {
-    if key.is_hashable() {
-        match map.get(key) {
-            Some(value) => Ok(value.clone()),
-            None => stop!(Generic => "key not found in hash map: {}", key),
-        }
-    } else {
-        stop!(TypeMismatch => "key not hashable: {}", key)
-    }
-}
-
-/// Gets the `key` from the given `map`. Returns #false if the key does not exist.
-///
-/// (hash-try-get map key) -> (or any/c #false)
-///
-/// * map : hash?
-/// * key : any/c
-///
-/// # Examples
-///
-/// ```scheme
-/// > (hash-try-get (hash 'a 10 'b 20) 'b) ;; => 20
-/// > (hash-try-get (hash 'a 10 'b 20) 'does-not-exist) ;; => #false
-/// ```
-#[function(name = "hash-try-get")]
-pub fn hash_try_get(map: &Gc<HashMap<SteelVal, SteelVal>>, key: &SteelVal) -> SteelVal {
-    match map.get(key) {
-        Some(v) => v.clone(),
-        None => SteelVal::BoolV(false),
-    }
-}
-
-/// Returns the number of key value pairs in the map
-///
-/// (hash-length map) -> (and positive? int?)
-///
-/// * map : hash?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (hash-length (hash 'a 10 'b 20)) ;; => 2
-/// ```
-#[function(name = "hash-length")]
-pub fn hash_length(map: &Gc<HashMap<SteelVal, SteelVal>>) -> usize {
-    map.len()
-}
-
-/// Checks whether the given map contains the given key. Key must be hashable.
-///
-/// (hash-contains? map key) -> bool?
-///
-/// * map : hash?
-/// * key : hashable?
-///
-/// # Example
-///
-/// ```scheme
-/// > (hash-contains? (hash 'a 10 'b 20) 'a) ;; => #true
-/// > (hash-contains? (hash 'a 10 'b 20) 'not-there) ;; => #false
-/// ```
-#[function(name = "hash-contains?")]
-pub fn hash_contains(map: &Gc<HashMap<SteelVal, SteelVal>>, key: &SteelVal) -> Result<SteelVal> {
-    if key.is_hashable() {
-        Ok(SteelVal::BoolV(map.contains_key(key)))
-    } else {
-        stop!(TypeMismatch => "hash key not hashable!");
-    }
-}
-
-/// Returns the keys of the given hash map as a list.
-///
-/// ```scheme
-/// (hash-keys->list map) -> (listof hashable?)
-/// ```
-///
-/// * map : hash?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (hash-keys->list? (hash 'a 'b 20)) ;; => '(a b)
-/// ```
-#[function(name = "hash-keys->list")]
-pub fn keys_to_list(hashmap: &Gc<HashMap<SteelVal, SteelVal>>) -> Result<SteelVal> {
-    Ok(SteelVal::ListV(hashmap.keys().cloned().collect()))
-}
-
-const HASH_VALUES_TO_LIST_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(hash-values->list? map) -> (listof any/c)?",
-    params: &["map : hash?"],
-    description: r#"Returns the values of the given hash map as a list"#,
-    examples: &[(
-        "> (hash-values->list? (hash 'a 10 'b 20) 'a)",
-        r#"=> '(10 20)"#,
-    )],
-};
-
-// values as list
-pub fn values_to_list(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hm-values->list takes 1 argument")
-    }
-
-    let hashmap = &args[0];
-
-    if let SteelVal::HashMapV(hm) = hashmap {
-        // let keys = hm.values().cloned().collect::<Vec<SteelVal>>();
-        // ListOperations::built_in_list_func_flat(&keys)
-        Ok(SteelVal::ListV(hm.values().cloned().collect()))
-    } else {
-        stop!(TypeMismatch => "hm-values->list takes a hashmap")
-    }
-}
-
-pub fn keys_to_vector(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hm-keys->vector takes 1 argument")
-    }
-
-    let hashmap = &args[0];
-
-    if let SteelVal::HashMapV(hm) = hashmap {
-        VectorOperations::vec_construct_iter_normal(hm.keys().cloned())
-    } else {
-        stop!(TypeMismatch => "hm-keys->vector takes a hashmap")
-    }
-}
-
-pub fn values_to_vector(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hm-values->vector takes 1 argument")
-    }
-
-    let hashmap = &args[0];
-
-    if let SteelVal::HashMapV(hm) = hashmap {
-        VectorOperations::vec_construct_iter_normal(hm.values().cloned())
-    } else {
-        stop!(TypeMismatch => "hm-values->vector takes a hashmap")
-    }
-}
-
-pub fn clear(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hm-clear takes 1 argument")
-    }
-
-    let hashmap = &args[0];
-
-    if let SteelVal::HashMapV(hm) = hashmap {
-        let mut hm = hm.0.unwrap();
-        hm.clear();
-        Ok(SteelVal::HashMapV(Gc::new(hm).into()))
-    } else {
-        stop!(TypeMismatch => "hm-clear takes a hashmap")
-    }
-}
-
-pub fn hm_empty(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hash-empty? takes 1 argument")
-    }
-
-    let hashmap = &args[0];
-
-    if let SteelVal::HashMapV(hm) = hashmap {
-        Ok(SteelVal::BoolV(hm.is_empty()))
-    } else {
-        stop!(TypeMismatch => "hash-empty? takes a hashmap")
-    }
-}
-
-pub fn hm_union(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 2 {
-        stop!(ArityMismatch => "hash-union takes 2 arguments")
-    }
-
-    let left = &args[0];
-    let right = &args[1];
-
-    if let SteelVal::HashMapV(hml) = left {
-        if let SteelVal::HashMapV(hmr) = right {
-            let hml = hml.0.unwrap();
-            let hmr = hmr.0.unwrap();
-            Ok(SteelVal::HashMapV(Gc::new(hml.union(hmr)).into()))
-        } else {
-            stop!(TypeMismatch => "hash-union takes a hashmap, found {}", right)
-        }
-    } else {
-        stop!(TypeMismatch => "hash-union takes a hashmap, found: {}", left)
-    }
-}
-
-#[cfg(test)]
-mod hashmap_tests {
-    use super::*;
-    use im_rc::hashmap;
-
-    use crate::rvals::{SteelString, SteelVal::*};
-
-    #[test]
-    fn hm_construct_normal() {
-        let args = [
-            StringV("foo".into()),
-            StringV("bar".into()),
-            StringV("foo2".into()),
-            StringV("bar2".into()),
-        ];
-        let res = hm_construct(&args);
-        let expected = SteelVal::HashMapV(
-            Gc::new(hashmap! {
-                StringV("foo".into()) => StringV("bar".into()),
-                StringV("foo2".into()) => StringV("bar2".into())
-            })
-            .into(),
-        );
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hm_construct_with_duplicates() {
-        let args = [
-            StringV("foo".into()),
-            StringV("bar".into()),
-            StringV("foo2".into()),
-            StringV("bar2".into()),
-            StringV("foo".into()),
-            StringV("bar".into()),
-            StringV("foo2".into()),
-            StringV("bar2".into()),
-        ];
-        let res = hm_construct(&args);
-        let expected = SteelVal::HashMapV(
-            Gc::new(hashmap! {
-                StringV("foo".into()) => StringV("bar".into()),
-                StringV("foo2".into()) => StringV("bar2".into())
-            })
-            .into(),
-        );
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hm_insert_from_empty() {
-        let args = [
-            HashMapV(Gc::new(hashmap![]).into()),
-            StringV("foo".into()),
-            StringV("bar".into()),
-        ];
-        let res = steel_hash_insert(&args);
-        let expected = SteelVal::HashMapV(
-            Gc::new(hashmap! {
-                StringV("foo".into()) => StringV("bar".into())
-            })
-            .into(),
-        );
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hm_get_found() {
-        let args = [
-            HashMapV(
-                Gc::new(hashmap! {
-                    StringV("foo".into()) => StringV("bar".into())
-                })
-                .into(),
-            ),
-            StringV("foo".into()),
-        ];
-        let res = steel_hash_ref(&args);
-        let expected = StringV("bar".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hm_get_error() {
-        let args = [
-            HashMapV(
-                Gc::new(hashmap! {
-                    StringV("foo".into()) => StringV("bar".into())
-                })
-                .into(),
-            ),
-            StringV("garbage".into()),
-        ];
-        let res = steel_hash_ref(&args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn hm_try_get_found() {
-        let args = [
-            HashMapV(
-                Gc::new(hashmap! {
-                    StringV("foo".into()) => StringV("bar".into())
-                })
-                .into(),
-            ),
-            StringV("foo".into()),
-        ];
-        let res = steel_hash_try_get(&args);
-        let expected = StringV("bar".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hm_try_get_error() {
-        let args = [
-            HashMapV(
-                Gc::new(hashmap! {
-                    StringV("foo".into()) => StringV("bar".into())
-                })
-                .into(),
-            ),
-            StringV("garbage".into()),
-        ];
-        let res = steel_hash_contains(&args);
-        let expected = SteelVal::BoolV(false);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hm_contains_true() {
-        let args = [
-            HashMapV(
-                Gc::new(hashmap! {
-                    StringV("foo".into()) => StringV("bar".into())
-                })
-                .into(),
-            ),
-            StringV("foo".into()),
-        ];
-        let res = steel_hash_contains(&args);
-        let expected = SteelVal::BoolV(true);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hm_contains_false() {
-        let args = [
-            HashMapV(
-                Gc::new(hashmap! {
-                    StringV("foo".into()) => StringV("bar".into())
-                })
-                .into(),
-            ),
-            StringV("bar".into()),
-        ];
-        let res = steel_hash_contains(&args);
-        let expected = SteelVal::BoolV(false);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hm_keys_to_vector_normal() {
-        let args = vec![HashMapV(
-            Gc::new(hashmap! {
-                StringV("foo".into()) => StringV("bar".into()),
-                StringV("bar".into()) => StringV("baz".into()),
-                StringV("baz".into()) => StringV("quux".into())
-            })
-            .into(),
-        )];
-        let res = keys_to_vector(&args);
-        let expected = im_rc::vector![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("baz".into()),
-        ]
-        .into();
-
-        // pull out the vectors and sort them
-        // let unwrapped_res: SteelVal = (*res.unwrap()).clone();
-        // let unwrapped_expected: SteelVal = (*expected).clone();
-
-        let mut res_vec_string: Vec<SteelString> = if let SteelVal::VectorV(v) = res.unwrap() {
-            v.iter()
-                .map(|x| {
-                    if let SteelVal::StringV(ref s) = x {
-                        s.clone()
-                    } else {
-                        panic!("test failed")
-                    }
-                })
-                .collect()
-        } else {
-            panic!("test failed")
-        };
-
-        let mut expected_vec_string: Vec<SteelString> = if let SteelVal::VectorV(v) = expected {
-            v.iter()
-                .map(|x| {
-                    if let SteelVal::StringV(ref s) = x {
-                        s.clone()
-                    } else {
-                        panic!("test failed")
-                    }
-                })
-                .collect()
-        } else {
-            panic!("test failed")
-        };
-
-        res_vec_string.sort();
-        expected_vec_string.sort();
-
-        assert_eq!(res_vec_string, expected_vec_string);
-    }
-
-    #[test]
-    fn hm_values_to_vector_normal() {
-        let args = vec![HashMapV(
-            Gc::new(hashmap! {
-                StringV("foo".into()) => StringV("bar".into()),
-                StringV("bar".into()) => StringV("baz".into()),
-                StringV("baz".into()) => StringV("quux".into())
-            })
-            .into(),
-        )];
-        let res = values_to_vector(&args);
-        let expected = im_rc::vector![
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("baz".into()),
-            SteelVal::StringV("quux".into()),
-        ]
-        .into();
-
-        // pull out the vectors and sort them
-
-        let mut res_vec_string: Vec<SteelString> = if let SteelVal::VectorV(v) = res.unwrap() {
-            v.iter()
-                .map(|x| {
-                    if let SteelVal::StringV(ref s) = x {
-                        s.clone()
-                    } else {
-                        panic!("test failed")
-                    }
-                })
-                .collect()
-        } else {
-            panic!("test failed")
-        };
-
-        let mut expected_vec_string: Vec<SteelString> = if let SteelVal::VectorV(v) = expected {
-            v.iter()
-                .map(|x| {
-                    if let SteelVal::StringV(ref s) = x {
-                        s.clone()
-                    } else {
-                        panic!("test failed")
-                    }
-                })
-                .collect()
-        } else {
-            panic!("test failed")
-        };
-
-        res_vec_string.sort();
-        expected_vec_string.sort();
-
-        assert_eq!(res_vec_string, expected_vec_string);
-    }
-}
diff --git a/crates/steel-core/src/primitives/hashsets.rs b/crates/steel-core/src/primitives/hashsets.rs
deleted file mode 100644
index 56aff7a44..000000000
--- a/crates/steel-core/src/primitives/hashsets.rs
+++ /dev/null
@@ -1,364 +0,0 @@
-use crate::stop;
-use crate::values::lists::List;
-use crate::{
-    core::utils::declare_const_ref_functions,
-    rvals::{Result, SteelVal},
-};
-use crate::{gc::Gc, steel_vm::builtin::BuiltInModule};
-use im_rc::HashSet;
-
-use crate::primitives::VectorOperations;
-
-declare_const_ref_functions!(
-    HS_CONSTRUCT => hs_construct,
-    HS_LENGTH => hs_length,
-    HS_CONTAINS => hs_contains,
-    HS_INSERT => hs_insert,
-    HS_TO_LIST => keys_to_list,
-    HS_TO_VEC => keys_to_vector,
-    HS_CLEAR => clear,
-    HS_SUBSET => is_subset,
-    LIST_TO_HS => list_to_hashset,
-);
-
-pub(crate) fn hashset_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/sets");
-    module
-        .register_value("hashset", HS_CONSTRUCT)
-        .register_value("hashset-length", HS_LENGTH)
-        .register_value("hashset-contains?", HS_CONTAINS)
-        .register_value("hashset-insert", HS_INSERT)
-        .register_value("hashset->list", HS_TO_LIST)
-        .register_value("hashset->vector", HS_TO_VEC)
-        .register_value("hashset-clear", HS_CLEAR)
-        .register_value("hashset-subset?", HS_SUBSET)
-        .register_value("list->hashset", LIST_TO_HS);
-    module
-}
-
-pub fn hs_construct(args: &[SteelVal]) -> Result<SteelVal> {
-    let mut hs = HashSet::new();
-
-    for key in args {
-        if key.is_hashable() {
-            hs.insert(key.clone());
-        } else {
-            stop!(TypeMismatch => "hash key not hashable!");
-        }
-    }
-
-    Ok(SteelVal::HashSetV(Gc::new(hs).into()))
-}
-
-pub fn hs_length(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hs-length takes 1 argument")
-    }
-
-    let hashmap = &args[0];
-
-    if let SteelVal::HashSetV(hm) = hashmap {
-        Ok(SteelVal::IntV(hm.len() as isize))
-    } else {
-        stop!(TypeMismatch => "hs-length takes a hashmap")
-    }
-}
-
-pub fn hs_insert(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 2 {
-        stop!(ArityMismatch => "set insert takes 2 arguments")
-    }
-
-    let hashset = &args[0];
-    let key = &args[1];
-
-    if let SteelVal::HashSetV(hs) = hashset {
-        let mut hs = hs.0.unwrap();
-        if key.is_hashable() {
-            hs.insert(key.clone());
-        } else {
-            stop!(TypeMismatch => "hash key not hashable!");
-        }
-        Ok(SteelVal::HashSetV(Gc::new(hs).into()))
-    } else {
-        stop!(TypeMismatch => "set insert takes a set")
-    }
-}
-
-pub fn hs_contains(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 2 {
-        stop!(ArityMismatch => "set-contains? get takes 2 arguments")
-    }
-
-    let hashset = &args[0];
-    let key = &args[1];
-
-    if let SteelVal::HashSetV(hm) = hashset {
-        if key.is_hashable() {
-            Ok(SteelVal::BoolV(hm.contains(key)))
-        } else {
-            stop!(TypeMismatch => "hash key not hashable!: {}", key);
-        }
-    } else {
-        stop!(TypeMismatch => "set-contains? takes a hashmap")
-    }
-}
-
-pub fn is_subset(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 2 {
-        stop!(ArityMismatch => "hashset-subset? takes 2 arguments")
-    }
-
-    let left = &args[0];
-    let right = &args[1];
-
-    if let SteelVal::HashSetV(left) = left {
-        if let SteelVal::HashSetV(right) = right {
-            Ok(SteelVal::BoolV(left.is_subset(right.0.as_ref())))
-        } else {
-            stop!(TypeMismatch => "hash-subset? takes a hashset")
-        }
-    } else {
-        stop!(TypeMismatch => "hashset-subset? takes a hashset")
-    }
-}
-
-// keys as list
-pub fn keys_to_list(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hs-keys->list takes 1 argument")
-    }
-
-    let hashset = &args[0];
-
-    if let SteelVal::HashSetV(hs) = hashset {
-        Ok(SteelVal::ListV(
-            hs.iter().cloned().collect::<List<SteelVal>>(),
-        ))
-    } else {
-        stop!(TypeMismatch => "hs-keys->list takes a hashmap")
-    }
-}
-
-// keys as vectors
-pub fn keys_to_vector(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hs-keys->vector takes 1 argument")
-    }
-
-    let hashset = &args[0];
-
-    if let SteelVal::HashSetV(hs) = hashset {
-        VectorOperations::vec_construct_iter_normal(hs.iter().cloned())
-    } else {
-        stop!(TypeMismatch => "hs-keys->vector takes a hashmap")
-    }
-}
-
-pub fn clear(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "hs-clear takes 1 argument")
-    }
-
-    let hashset = &args[0];
-
-    if let SteelVal::HashSetV(hs) = hashset {
-        let mut hs = hs.0.unwrap();
-        hs.clear();
-        Ok(SteelVal::HashSetV(Gc::new(hs).into()))
-    } else {
-        stop!(TypeMismatch => "hs-clear takes a hashmap")
-    }
-}
-
-pub fn list_to_hashset(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "list->hashset takes one argument")
-    }
-    if let SteelVal::ListV(l) = &args[0] {
-        Ok(SteelVal::HashSetV(
-            Gc::new(l.iter().cloned().collect::<im_rc::HashSet<_>>()).into(),
-        ))
-    } else {
-        stop!(TypeMismatch => "list->hashset takes a hashset");
-    }
-}
-
-#[cfg(test)]
-mod hashset_tests {
-    use crate::rvals::SteelString;
-
-    use super::*;
-
-    #[test]
-    fn hs_construct_normal() {
-        let args = [
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("foo2".into()),
-            SteelVal::StringV("bar2".into()),
-        ];
-        let res = hs_construct(&args);
-        let expected = SteelVal::HashSetV(
-            Gc::new(
-                vec![
-                    SteelVal::StringV("foo".into()),
-                    SteelVal::StringV("bar".into()),
-                    SteelVal::StringV("foo2".into()),
-                    SteelVal::StringV("bar2".into()),
-                ]
-                .into_iter()
-                .map(Gc::new)
-                .collect::<im_rc::HashSet<_>>(),
-            )
-            .into(),
-        );
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hs_construct_with_duplicates() {
-        let args = [
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("foo2".into()),
-            SteelVal::StringV("bar2".into()),
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("foo2".into()),
-            SteelVal::StringV("bar2".into()),
-        ];
-        let res = hs_construct(&args);
-        let expected = SteelVal::HashSetV(
-            Gc::new(
-                vec![
-                    SteelVal::StringV("foo".into()),
-                    SteelVal::StringV("bar".into()),
-                    SteelVal::StringV("foo2".into()),
-                    SteelVal::StringV("bar2".into()),
-                ]
-                .into_iter()
-                .map(Gc::new)
-                .collect::<im_rc::HashSet<_>>(),
-            )
-            .into(),
-        );
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hs_insert_from_empty() {
-        let args = [
-            SteelVal::HashSetV(Gc::new(im_rc::HashSet::new()).into()),
-            SteelVal::StringV("foo".into()),
-        ];
-        let res = hs_insert(&args);
-        let expected = SteelVal::HashSetV(
-            Gc::new(
-                vec![SteelVal::StringV("foo".into())]
-                    .into_iter()
-                    .map(Gc::new)
-                    .collect::<im_rc::HashSet<_>>(),
-            )
-            .into(),
-        );
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hs_contains_true() {
-        let args = [
-            SteelVal::HashSetV(
-                Gc::new(
-                    vec![SteelVal::StringV("foo".into())]
-                        .into_iter()
-                        .map(Gc::new)
-                        .collect::<im_rc::HashSet<_>>(),
-                )
-                .into(),
-            ),
-            SteelVal::StringV("foo".into()),
-        ];
-        let res = hs_contains(&args);
-        let expected = SteelVal::BoolV(true);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hs_contains_false() {
-        let args = [
-            SteelVal::HashSetV(
-                Gc::new(
-                    vec![SteelVal::StringV("foo".into())]
-                        .into_iter()
-                        .map(Gc::new)
-                        .collect::<im_rc::HashSet<_>>(),
-                )
-                .into(),
-            ),
-            SteelVal::StringV("bar".into()),
-        ];
-        let res = hs_contains(&args);
-        let expected = SteelVal::BoolV(false);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn hs_keys_to_vector_normal() {
-        let args = [SteelVal::HashSetV(
-            Gc::new(
-                vec![
-                    SteelVal::StringV("foo".into()),
-                    SteelVal::StringV("bar".into()),
-                    SteelVal::StringV("baz".into()),
-                ]
-                .into_iter()
-                .collect::<im_rc::HashSet<_>>(),
-            )
-            .into(),
-        )];
-        let res = keys_to_vector(&args);
-        let expected = im_rc::vector![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("baz".into()),
-        ]
-        .into();
-
-        // pull out the vectors and sort them
-        // let unwrapped_expected: SteelVal = (*expected).clone();
-
-        let mut res_vec_string: Vec<SteelString> = if let SteelVal::VectorV(v) = res.unwrap() {
-            v.iter()
-                .map(|x| {
-                    if let SteelVal::StringV(ref s) = x {
-                        s.clone()
-                    } else {
-                        panic!("test failed")
-                    }
-                })
-                .collect()
-        } else {
-            panic!("test failed")
-        };
-
-        let mut expected_vec_string: Vec<SteelString> = if let SteelVal::VectorV(v) = expected {
-            v.iter()
-                .map(|x| {
-                    if let SteelVal::StringV(ref s) = x {
-                        s.clone()
-                    } else {
-                        panic!("test failed")
-                    }
-                })
-                .collect()
-        } else {
-            panic!("test failed")
-        };
-
-        res_vec_string.sort();
-        expected_vec_string.sort();
-
-        assert_eq!(res_vec_string, expected_vec_string);
-    }
-}
diff --git a/crates/steel-core/src/primitives/io.rs b/crates/steel-core/src/primitives/io.rs
deleted file mode 100644
index 095d81326..000000000
--- a/crates/steel-core/src/primitives/io.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-use crate::rvals::{Result, SteelVal};
-use crate::stop;
-use std::io;
-// use std::io::Write;
-
-// mod primitives;
-
-pub struct IoFunctions {}
-impl IoFunctions {
-    // pub fn sandboxed_display() -> SteelVal {
-    //     SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-    //         if args.len() == 1 {
-    //             let print_val = &args[0];
-
-    //             let output_port = DEFAULT_OUTPUT_PORT.with(|x| x.clone());
-
-    //             match &*output_port.borrow() {
-    //                 crate::values::port::SteelPort::StdOutput(out) => match &print_val {
-    //                     SteelVal::StringV(s) => write!(out.borrow_mut().lock(), "{s}"),
-    //                     _ => write!(out.borrow_mut().lock(), "{print_val}"),
-    //                 },
-    //                 crate::values::port::SteelPort::StringOutput(out) => match &print_val {
-    //                     SteelVal::StringV(s) => write!(out.borrow_mut(), "{s}"),
-    //                     _ => write!(out.borrow_mut(), "{print_val}"),
-    //                 },
-    //                 // crate::values::port::SteelPort::Closed => todo!(),
-    //                 other => stop!(Generic => "Unable to write to port: {:?}", other),
-    //             }?;
-
-    //             Ok(SteelVal::Void)
-    //         } else {
-    //             stop!(ArityMismatch => "display takes one argument");
-    //         }
-    //     })
-    // }
-
-    // pub fn sandboxed_newline() -> SteelVal {
-    //     SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-    //         if args.is_empty() {
-    //             // println!();
-
-    //             let output_port = DEFAULT_OUTPUT_PORT.with(|x| x.clone());
-
-    //             match &*output_port.borrow() {
-    //                 crate::values::port::SteelPort::StdOutput(out) => {
-    //                     writeln!(out.borrow_mut().lock())
-    //                 }
-    //                 crate::values::port::SteelPort::StringOutput(out) => {
-    //                     writeln!(out.borrow_mut())
-    //                 }
-    //                 // crate::values::port::SteelPort::Closed => todo!(),
-    //                 other => stop!(Generic => "Unable to write to port: {:?}", other),
-    //             }?;
-
-    //             Ok(SteelVal::Void)
-    //         } else {
-    //             stop!(ArityMismatch => "newline takes no arguments");
-    //         }
-    //     })
-    // }
-
-    pub fn display() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            for arg in args {
-                match &arg {
-                    SteelVal::StringV(s) => print!("{s}"),
-                    _ => print!("{arg}"),
-                }
-            }
-
-            Ok(SteelVal::Void)
-        })
-    }
-
-    pub fn displayln() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            for arg in args {
-                match &arg {
-                    SteelVal::StringV(s) => {
-                        print!("{s}")
-                    }
-                    _ => print!("{arg}"),
-                }
-            }
-
-            println!();
-
-            Ok(SteelVal::Void)
-        })
-    }
-
-    #[cfg(feature = "colors")]
-    pub fn display_color() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() == 2 {
-                let print_val = &args[0];
-                let color = &args[1];
-
-                match (&print_val, &color) {
-                    (SteelVal::StringV(s), SteelVal::SymbolV(c)) => match c.as_str() {
-                        "green" | "Green" => print!("{}", s.to_string().bright_green()),
-                        "blue" | "Blue" => print!("{}", s.to_string().bright_blue()),
-                        "red" | "Red" => print!("{}", s.to_string().red()),
-                        _ => print!("{s}"),
-                    },
-                    (_, SteelVal::StringV(c)) | (_, SteelVal::SymbolV(c)) => match c.as_str() {
-                        "green" | "Green" => print!("{}", print_val.to_string().bright_green()),
-                        "blue" | "Blue" => print!("{}", print_val.to_string().bright_blue()),
-                        "red" | "Red" => print!("{}", print_val.to_string().red()),
-                        _ => print!("{print_val}"),
-                    },
-                    (_, _) => {
-                        stop!(TypeMismatch => "display-color expected a symbol as the second argument")
-                    }
-                }
-                Ok(SteelVal::Void)
-            } else {
-                stop!(ArityMismatch => "display-color takes two arguments");
-            }
-        })
-    }
-
-    #[cfg(not(feature = "colors"))]
-    pub fn display_color() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() == 2 {
-                let print_val = &args[0];
-                let color = &args[1];
-
-                match (&print_val, &color) {
-                    (SteelVal::StringV(s), SteelVal::SymbolV(c)) => match c.as_str() {
-                        "green" | "Green" => print!("{}", s),
-                        "blue" | "Blue" => print!("{}", s),
-                        "red" | "Red" => print!("{}", s),
-                        _ => print!("{s}"),
-                    },
-                    (_, SteelVal::StringV(c)) | (_, SteelVal::SymbolV(c)) => match c.as_str() {
-                        "green" | "Green" => print!("{}", print_val),
-                        "blue" | "Blue" => print!("{}", print_val),
-                        "red" | "Red" => print!("{}", print_val),
-                        _ => print!("{print_val}"),
-                    },
-                    (_, _) => {
-                        stop!(TypeMismatch => "display-color expected a symbol as the second argument")
-                    }
-                }
-                Ok(SteelVal::Void)
-            } else {
-                stop!(ArityMismatch => "display-color takes two arguments");
-            }
-        })
-    }
-
-    pub fn newline() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.is_empty() {
-                println!();
-                Ok(SteelVal::Void)
-            } else {
-                stop!(ArityMismatch => "newline takes no arguments");
-            }
-        })
-    }
-
-    pub fn read_to_string() -> SteelVal {
-        SteelVal::FuncV(|_args: &[SteelVal]| -> Result<SteelVal> {
-            let mut input_text = String::new();
-            io::stdin().read_line(&mut input_text)?;
-            Ok(SteelVal::StringV(input_text.trim_end().into()))
-        })
-    }
-}
diff --git a/crates/steel-core/src/primitives/lists.rs b/crates/steel-core/src/primitives/lists.rs
deleted file mode 100644
index d6d2e6561..000000000
--- a/crates/steel-core/src/primitives/lists.rs
+++ /dev/null
@@ -1,775 +0,0 @@
-use crate::{
-    gc::Gc,
-    steel_vm::{
-        builtin::{BuiltInModule, DocTemplate},
-        vm::{apply, VmContext, APPLY_DOC},
-    },
-    values::lists::Pair,
-};
-use crate::{
-    rvals::{IntoSteelVal, Result, SteelVal},
-    steel_vm::vm::VmCore,
-};
-use crate::{stop, throw};
-
-use crate::values::lists::List;
-
-use crate::core::utils::{
-    arity_check, declare_const_mut_ref_functions, declare_const_ref_functions,
-};
-
-declare_const_ref_functions! {
-    REVERSE => reverse,
-    LAST => last,
-    TRY_LIST_REF => try_list_ref,
-    LIST_TO_STRING => steel_list_to_string,
-}
-
-declare_const_mut_ref_functions! {
-    CONS => cons,
-    REST => rest,
-    CDR => cdr,
-    APPEND => append,
-    PUSH_BACK => push_back,
-}
-
-// pub(crate) const TEST_MAP: SteelVal = SteelVal::BuiltIn(test_map);
-
-// TODO replace all usages with const
-// const LENGTH: SteelVal = SteelVal::FuncV(length);
-// const NEW: SteelVal = SteelVal::FuncV(new);
-
-pub struct UnRecoverableResult(Result<SteelVal>);
-
-impl IntoSteelVal for UnRecoverableResult {
-    #[inline(always)]
-    fn into_steelval(self) -> Result<SteelVal> {
-        self.into()
-    }
-}
-
-impl From<UnRecoverableResult> for Result<SteelVal> {
-    fn from(value: UnRecoverableResult) -> Self {
-        value.0
-    }
-}
-
-impl From<Result<SteelVal>> for UnRecoverableResult {
-    fn from(value: Result<SteelVal>) -> Self {
-        UnRecoverableResult(value)
-    }
-}
-
-pub(crate) const TEST_APPLY: SteelVal = SteelVal::BuiltIn(apply);
-
-/// # steel/lists
-///     
-/// Lists in Steel have an interface that matches those of classic schemes or lisps.
-/// At face value, they appear to be implemented as cons cells - however, under the hood
-/// they are actually implemented as unrolled linked lists.
-///
-/// This means that for most practical purposes, interaction with lists is the same.
-/// That being said, there are no improper lists, meaning, pairs are actually just lists of two elements.
-///
-/// Indexing into a list also takes O(n/64) - which means you'll get constant time indexing on small lists.
-///
-/// ```scheme
-/// (list 10 20 30 40) ;; => '(10 20 30 40)
-/// ```
-#[steel_derive::define_module(name = "steel/lists")]
-pub fn list_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/lists");
-
-    module
-        .register_native_fn_definition(NEW_DEFINITION)
-        .register_value_with_doc("cons", crate::primitives::lists::CONS, CONS_DOC)
-        .register_native_fn_definition(RANGE_DEFINITION)
-        .register_native_fn_definition(LENGTH_DEFINITION)
-        .register_value_with_doc("last", crate::primitives::lists::LAST, LAST_DOC)
-        .register_native_fn_definition(IS_EMPTY_DEFINITION)
-        .register_native_fn_definition(FIRST_DEFINITION)
-        .register_native_fn_definition(CAR_DEFINITION)
-        .register_value_with_doc("cdr", crate::primitives::lists::CDR, CDR_DOC)
-        .register_value_with_doc("rest", crate::primitives::lists::REST, REST_DOC)
-        .register_value_with_doc("append", crate::primitives::lists::APPEND, APPEND_DOC)
-        .register_value_with_doc("reverse", crate::primitives::lists::REVERSE, REVERSE_DOC)
-        .register_native_fn_definition(LIST_REF_DEFINITION)
-        .register_value("try-list-ref", crate::primitives::lists::TRY_LIST_REF)
-        .register_value("list->string", crate::primitives::lists::LIST_TO_STRING)
-        .register_value("push-back", crate::primitives::lists::PUSH_BACK)
-        .register_native_fn_definition(PAIR_DEFINITION)
-        // TODO move this to somewhere better than here
-        .register_value_with_doc("apply", TEST_APPLY, APPLY_DOC)
-        .register_value("transduce", crate::steel_vm::transducers::TRANSDUCE)
-        .register_native_fn_definition(SECOND_DEFINITION)
-        .register_native_fn_definition(THIRD_DEFINITION)
-        .register_native_fn_definition(TAKE_DEFINITION)
-        .register_native_fn_definition(LIST_TAIL_DEFINITION);
-
-    module
-}
-
-/// Get the second element of the list. Raises an error if the list does not have an element in the second position.
-///
-/// (second l) -> any/c
-///
-/// * l : list?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (second '(1 2 3)) ;; => 2
-/// > (second '())
-/// error[E11]: Generic
-///         ┌─ :1:2
-///         │
-///         1 │ (second '())
-///         │  ^^^^^^ second: index out of bounds - list did not have an element in the second position: []
-#[steel_derive::function(name = "second", constant = true)]
-pub fn second(list: &List<SteelVal>) -> Result<SteelVal> {
-    list.get(1).cloned().ok_or_else(throw!(Generic => "second: index out of bounds - list did not have an element in the second position: {:?}", list))
-}
-
-/// Get the third element of the list. Raises an error if the list does not have an element in the third position.
-///
-/// (third l) -> any/c
-///
-/// * l : list?
-///
-/// # Examples
-/// ```scheme
-/// > (third '(1 2 3)) ;; => 3
-/// > (third '())
-/// error[E11]: Generic
-///        ┌─ :1:2
-///        │
-///        1 │ (third '())
-///        │  ^^^^^^ third: index out of bounds - list did not have an element in the second position: []
-/// ```
-#[steel_derive::function(name = "third", constant = true)]
-pub(crate) fn third(list: &List<SteelVal>) -> Result<SteelVal> {
-    list.get(2).cloned().ok_or_else(throw!(Generic => "third: Index out of bounds - list did not have an element in the second position: {:?}", list))
-}
-
-fn _test_map(ctx: &mut VmCore, args: &[SteelVal]) -> Result<SteelVal> {
-    arity_check!(test_map, args, 2);
-
-    let mut arg_iter = args.iter();
-    let arg1 = arg_iter.next().unwrap();
-    let arg2 = arg_iter.next().unwrap();
-
-    if let SteelVal::ListV(l) = arg2 {
-        if arg1.is_function() {
-            // unimplemented!()
-
-            Ok(SteelVal::ListV(
-                l.into_iter()
-                    .map(|x| ctx.call_function_one_arg(arg1, x.clone()))
-                    .collect::<Result<_>>()?,
-            ))
-
-            // ctx.call_function_one_arg_or_else(function, arg)
-        } else {
-            stop!(TypeMismatch => "test-map expected a function")
-        }
-    } else {
-        stop!(TypeMismatch => "test-map expects a list")
-    }
-}
-
-#[steel_derive::function(name = "list-tail")]
-pub fn list_tail(list_or_pair: &SteelVal, pos: usize) -> Result<SteelVal> {
-    match list_or_pair {
-        SteelVal::ListV(l) => l
-            .tail(pos)
-            .ok_or_else(throw!(Generic => format!("list-tail expects at least {} 
-                    elements in the list, found: {}", pos, l.len())))
-            .map(SteelVal::ListV),
-        SteelVal::Pair(p) => {
-            let mut value = p.cdr();
-            let mut count = 1;
-
-            while count < pos {
-                count += 1;
-                value = value
-                    .pair()
-                    .map(|x| x.cdr())
-                    .ok_or_else(throw!(Generic => format!("list-tail: index reached a 
-                        non-pair: index: {} in {}", count, list_or_pair)))?;
-            }
-
-            Ok(value)
-        }
-
-        _ if pos == 0 => Ok(list_or_pair.clone()),
-
-        _ => {
-            stop!(TypeMismatch => format!("list-tail expects either a list or a pair, found: {}", list_or_pair))
-        }
-    }
-}
-
-/// Returns a newly allocated list containing the vs as its elements.
-///
-/// (list v ...) -> list?
-///
-/// * v : any/c
-///
-/// # Examples
-///
-/// ```scheme
-/// > (list 1 2 3 4 5) ;; => '(1 2 3 4 5)
-/// > (list (list 1 2) (list 3 4)) ;; => '((1 2) (3 4))
-/// ```
-#[steel_derive::native(name = "list", arity = "AtLeast(0)")]
-pub fn new(args: &[SteelVal]) -> Result<SteelVal> {
-    Ok(SteelVal::ListV(args.iter().cloned().collect()))
-}
-
-/// Checks if the list is empty
-///
-/// (empty? lst) -> bool?
-///
-/// * lst: list?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (empty? (list 1 2 3 4 5)) ;; => #false
-/// > (empty? '()) ;; => #true
-/// ```
-#[steel_derive::function(name = "empty?")]
-fn is_empty(list: &SteelVal) -> bool {
-    list.list().map(|x| x.is_empty()).unwrap_or_default()
-}
-
-/// Checks if the given value can be treated as a pair.
-/// Note - there are no improper lists in steel, so any list with at least one element
-/// is considered a pair.
-///
-/// (pair? any/c) -> bool?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (pair? '(10 20)) ;; => #true
-/// > (pair? '(10)) ;; => #true
-/// > (pair? '()) ;; => #false
-/// ```
-#[steel_derive::function(name = "pair?")]
-fn pair(list: &SteelVal) -> bool {
-    match list {
-        SteelVal::ListV(l) => l.iter().next().is_some(),
-        SteelVal::Pair(_) => true,
-        _ => false,
-    }
-}
-
-pub(crate) const CONS_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(cons a d) -> list?",
-    params: &["a : any/c", "d : any/c"],
-    description: r#"Returns a newly allocated list whose first element is a and second element is d.
-Note: In steel, there are only proper lists. Pairs do not exist directly. "#,
-    examples: &[("> (cons 1 2)", "'(1 2)"), ("> (cons 1 '())", "'(1)")],
-};
-
-// Do away with improper lists?
-pub fn cons(args: &mut [SteelVal]) -> Result<SteelVal> {
-    if args.len() != 2 {
-        stop!(ArityMismatch => "cons takes only two arguments")
-    }
-    match (args[0].clone(), &mut args[1]) {
-        (left, SteelVal::ListV(right)) => {
-            right.cons_mut(left);
-
-            // Consider moving in a default value instead of cloning?
-            Ok(SteelVal::ListV(right.clone()))
-        }
-        // Silly, but this then gives us a special "pair" that is different
-        // from a real bonafide list
-        (left, right) => Ok(SteelVal::Pair(Gc::new(Pair::cons(left, right.clone())))),
-        // TODO: Replace with an immutable pair here!
-        // (left, right) => Ok(SteelVal::ListV(vec![left, right.clone()].into())),
-    }
-}
-
-/// Returns a newly allocated list of the elements in the range (n, m]
-///
-/// (range n m) -> (listof int?)
-///
-/// * n : int?
-/// * m : int?
-///
-/// ```scheme
-/// > (range 0 10) ;; => '(0 1 2 3 4 5 6 7 8 9)
-/// ```
-#[steel_derive::function(name = "range")]
-fn range(lower: isize, upper: isize) -> Result<SteelVal> {
-    if lower < 0 {
-        stop!(Generic => "range expects a positive integer");
-    }
-
-    if upper < 0 {
-        stop!(Generic => "range expects a positive integer");
-    }
-
-    Ok(SteelVal::ListV(
-        (lower as usize..upper as usize)
-            .into_iter()
-            .map(|x| SteelVal::IntV(x as isize))
-            .collect(),
-    ))
-}
-
-/// Returns the length of the list.
-///
-/// (length l) -> int?
-///
-/// * l : list?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (length (list 10 20 30)) ;; => 3
-/// ```
-#[steel_derive::function(name = "length")]
-fn length(list: &List<SteelVal>) -> usize {
-    list.len()
-}
-
-pub(crate) const REVERSE_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(reverse l) -> list?",
-    params: &["l : list?"],
-    description: r#"Returns a list that has the same elements as lst, but in reverse order.
-This function takes time proportional to the length of lst."#,
-    examples: &[("> (reverse (list 1 2 3 4))", "=> '(4 3 2 1)")],
-};
-
-fn reverse(args: &[SteelVal]) -> Result<SteelVal> {
-    arity_check!(reverse, args, 1);
-
-    if let SteelVal::ListV(l) = &args[0] {
-        Ok(SteelVal::ListV(l.clone().reverse()))
-    } else {
-        stop!(TypeMismatch => "reverse expects a list")
-    }
-}
-
-pub(crate) const LAST_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(last l) -> any/c",
-    params: &["l : list?"],
-    description: r#"Returns the last element in the list.
-Takes time proportional to the length of the list."#,
-    examples: &[("> (last (list 1 2 3 4))", "=> 4")],
-};
-
-pub fn last(args: &[SteelVal]) -> Result<SteelVal> {
-    arity_check!(last, args, 1);
-
-    if let SteelVal::ListV(l) = &args[0] {
-        l.last()
-            .cloned()
-            .ok_or_else(throw!(Generic => "last resulted in an error - empty list"))
-    } else {
-        stop!(TypeMismatch => "last expects a list")
-    }
-}
-
-/// Returns the first element of the list l.
-///
-/// (first l) -> any/c
-///
-/// * l : list?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (first '(1 2)) ;; => 1
-/// > (first (cons 2 3)) ;; => 2
-/// ```
-#[steel_derive::function(name = "first", constant = true)]
-fn first(list: &List<SteelVal>) -> Result<SteelVal> {
-    list.car()
-        .ok_or_else(throw!(Generic => "first resulted in an error - empty list"))
-}
-
-/// Returns the first element of the list l.
-///
-/// (car l) -> any/c
-///
-/// * l : list?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (car '(1 2)) ;; => 1
-/// > (car (cons 2 3)) ;; => 2
-/// ```
-#[steel_derive::function(name = "car", constant = true)]
-fn car(list: &SteelVal) -> Result<SteelVal> {
-    match list {
-        SteelVal::ListV(l) => l
-            .car()
-            .ok_or_else(throw!(Generic => "car resulted in an error - empty list")),
-
-        SteelVal::Pair(p) => Ok(p.car()),
-
-        _ => stop!(TypeMismatch => "car expected a list or pair, found: {}", list),
-    }
-}
-
-pub(crate) const CDR_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(cdr l) -> list?",
-    params: &["l : list?"],
-    description: r#"Returns the rest of the list. Will raise an error if the list is empty."#,
-    examples: &[
-        ("λ > (cdr (list 10 20 30))", "=> '(20 30)"),
-        ("λ > (cdr (list 10))", "=> '()"),
-        (
-            "λ > (cdr '())",
-            r#"error[E11]: Generic
-    ┌─ :1:2
-    │
-    1 │ (cdr '())
-    │  ^^^ cdr expects a non empty list
-"#,
-        ),
-    ],
-};
-
-fn cdr(args: &mut [SteelVal]) -> Result<SteelVal> {
-    arity_check!(rest, args, 1);
-
-    match &mut args[0] {
-        SteelVal::ListV(l) => {
-            if l.is_empty() {
-                stop!(Generic => "cdr expects a non empty list");
-            }
-
-            match l.rest_mut() {
-                Some(l) => Ok(SteelVal::ListV(l.clone())),
-                None => Ok(SteelVal::ListV(l.clone())),
-            }
-        }
-
-        SteelVal::Pair(p) => Ok(p.cdr()),
-        _ => {
-            stop!(TypeMismatch => format!("cdr expects a list, found: {}", &args[0]))
-        }
-    }
-}
-
-pub(crate) const REST_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(rest l) -> list?",
-    params: &["l : list?"],
-    description: r#"Returns the rest of the list. Will raise an error if the list is empty."#,
-    examples: &[
-        ("λ > (rest (list 10 20 30))", "=> '(20 30)"),
-        ("λ > (rest (list 10))", "=> '()"),
-        (
-            "λ > (rest '())",
-            r#"error[E11]: Generic
-    ┌─ :1:2
-    │
-    1 │ (rest '())
-    │  ^^^^ rest expects a non empty list
-"#,
-        ),
-    ],
-};
-
-fn rest(args: &mut [SteelVal]) -> Result<SteelVal> {
-    arity_check!(rest, args, 1);
-
-    if let SteelVal::ListV(l) = &mut args[0] {
-        if l.is_empty() {
-            stop!(Generic => "rest expects a non empty list");
-        }
-
-        match l.rest_mut() {
-            Some(l) => Ok(SteelVal::ListV(l.clone())),
-            None => Ok(SteelVal::ListV(l.clone())),
-        }
-    } else {
-        stop!(TypeMismatch => "rest expects a list")
-    }
-}
-
-/// Returns the first n elements of the list l as a new list.
-///
-/// (take l n) -> list?
-///
-/// * l : list?
-/// * n : (and/c positive? int?)
-///
-/// # Examples
-///
-/// ```scheme
-/// > (take '(1 2 3 4) 2) ;; => '(0 1)
-/// > (take (range 0 10) 4) ;; => '(0 1 2 3)
-/// ```
-#[steel_derive::function(name = "take", constant = true)]
-fn take(list: &List<SteelVal>, n: isize) -> Result<SteelVal> {
-    if n < 0 {
-        stop!(Generic => "take expects a positive integer")
-    } else {
-        Ok(SteelVal::ListV(list.take(n as usize)))
-    }
-}
-
-pub(crate) const APPEND_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(append l r) -> list?",
-    params: &["l : list?", "r : list?"],
-    description: r#"Returns the rest of the list. Will raise an error if the list is empty."#,
-    examples: &[("λ > (append (list 1 2) (list 3 4))", "=> '(1 2 3 4)")],
-};
-
-fn append(args: &mut [SteelVal]) -> Result<SteelVal> {
-    if let Some((first, rest)) = args.split_first_mut() {
-        let initial = if let SteelVal::ListV(ref mut l) = first {
-            l
-        } else {
-            stop!(TypeMismatch => "append expects a list, found: {}", &args[0]);
-        };
-
-        for value in rest {
-            if let SteelVal::ListV(r) = value {
-                initial.append_mut(r.clone());
-            } else {
-                stop!(TypeMismatch => "append expects a list, found: {}", value);
-            }
-        }
-
-        return Ok(SteelVal::ListV(initial.clone()));
-    } else {
-        return Ok(SteelVal::ListV(List::new()));
-    }
-}
-
-pub fn try_list_ref(args: &[SteelVal]) -> Result<SteelVal> {
-    arity_check!(try_list_ref, args, 2);
-
-    // todo!()
-    if let (SteelVal::ListV(lst), SteelVal::IntV(n)) = (&args[0], &args[1]) {
-        if *n < 0 {
-            stop!(Generic => "list-ref expects a positive integer")
-        } else if let Some(l) = lst.get(*n as usize) {
-            Ok(l.clone())
-        } else {
-            Ok(SteelVal::BoolV(false))
-        }
-    } else {
-        stop!(TypeMismatch => format!("try-list-ref expects a list and an integer, found {} and {}", &args[0], &args[1]))
-    }
-}
-
-/// Returns the value located at the given index. Will raise an error if you try to index out of bounds.
-///
-/// Note: Runs in time proportional to the length of the list, however lists in Steel are implemented in such a fashion that the
-/// time complexity is O(n/64). Meaning, for small lists this can be constant.
-///
-/// (list-ref lst index) -> list?
-///
-/// * lst : list?
-/// * index : (and/c int? positive?)
-///
-/// # Examples
-/// ```scheme
-/// > (list-ref (list 1 2 3 4) 2) ;; => 3
-/// > (list-ref (range 0 100) 42) ;; => 42"
-/// > (list-ref (list 1 2 3 4) 10)
-/// error[E11]: Generic
-///   ┌─ :1:2
-///   │
-/// 1 │ (list-ref (list 1 2 3 4) 10)
-///   │  ^^^^^^^^ out of bounds index in list-ref - list length: 4, index: 10
-/// ```
-#[steel_derive::function(name = "list-ref", constant = true)]
-pub fn list_ref(list: &List<SteelVal>, index: isize) -> Result<SteelVal> {
-    if index < 0 {
-        stop!(Generic => "list-ref expects a positive integer, found: {}", index);
-    }
-
-    list.get(index as usize)
-        .cloned()
-        .ok_or_else(throw!(Generic => format!("out of bounds index in list-ref - list length: {}, index: {}", list.len(), index)))
-}
-
-#[steel_derive::function(name = "list->string", constant = true)]
-fn list_to_string(list: &List<SteelVal>) -> Result<SteelVal> {
-    list.iter()
-        .map(|x| {
-            x.char_or_else(throw!(TypeMismatch => "list->string expected a list of characters"))
-        })
-        .collect::<Result<String>>()
-        .map(|x| x.into())
-        .map(SteelVal::StringV)
-}
-
-// TODO this could be broken using &mut
-// need to think about it more
-fn push_back(args: &mut [SteelVal]) -> Result<SteelVal> {
-    arity_check!(push_back, args, 2);
-
-    let arg = args[1].clone();
-
-    if let SteelVal::ListV(l) = &mut args[0] {
-        l.push_back(arg);
-
-        Ok(args[0].clone())
-    } else {
-        stop!(TypeMismatch => "push-back expects a list")
-    }
-}
-
-impl From<List<SteelVal>> for SteelVal {
-    fn from(l: List<SteelVal>) -> Self {
-        SteelVal::ListV(l)
-    }
-}
-
-#[cfg(test)]
-mod list_operation_tests {
-
-    use super::*;
-    use crate::rerrs::ErrorKind;
-
-    #[test]
-    fn cons_test_normal_input() {
-        let mut args = [SteelVal::IntV(1), SteelVal::IntV(2)];
-        let res = cons(&mut args);
-
-        let expected = SteelVal::Pair(Gc::new(Pair::cons(SteelVal::IntV(1), SteelVal::IntV(2))));
-
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn cons_single_input() {
-        let mut args = [SteelVal::IntV(1)];
-        let res = cons(&mut args);
-        let expected = ErrorKind::ArityMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn cons_no_input() {
-        let res = cons(&mut []);
-        let expected = ErrorKind::ArityMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn cons_with_empty_list() {
-        let mut args = [SteelVal::IntV(1), SteelVal::ListV(List::new())];
-        let res = cons(&mut args);
-
-        let expected = crate::list![1i32];
-
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn cons_with_non_empty_vector() {
-        let mut args = [
-            SteelVal::IntV(1),
-            SteelVal::ListV(vec![SteelVal::IntV(2)].into()),
-        ];
-        let res = cons(&mut args);
-        let expected = crate::list![1i32, 2i32];
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn car_normal_input() {
-        let args = [crate::list![1i32, 2i32]];
-        let res = steel_car(&args);
-        let expected = SteelVal::IntV(1);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn car_bad_input() {
-        let args = [SteelVal::IntV(1)];
-        let res = steel_car(&args);
-        let expected = ErrorKind::TypeMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn car_too_many_args() {
-        let args = [SteelVal::IntV(1), SteelVal::IntV(2)];
-        let res = steel_car(&args);
-        let expected = ErrorKind::ArityMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn cdr_normal_input_2_elements() {
-        let mut args = [crate::list![1i32, 2i32]];
-        let res = cdr(&mut args);
-        let expected = crate::list![2i32];
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn cdr_normal_input_3_elements() {
-        let mut args = [crate::list![1i32, 2i32, 3i32]];
-        let res = cdr(&mut args);
-        let expected = crate::list![2i32, 3i32];
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn cdr_bad_input() {
-        let mut args = [SteelVal::IntV(1)];
-        let res = cdr(&mut args);
-        let expected = ErrorKind::TypeMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn cdr_too_many_args() {
-        let mut args = [SteelVal::NumV(1.0), SteelVal::NumV(2.0)];
-        let res = cdr(&mut args);
-        let expected = ErrorKind::ArityMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn cdr_single_element_list() {
-        let mut args = [SteelVal::ListV(vec![SteelVal::NumV(1.0)].into())];
-        let res = cdr(&mut args);
-        let expected = SteelVal::ListV(List::new());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn range_tests_arity_too_few() {
-        let args = [SteelVal::IntV(1)];
-        let res = steel_range(&args);
-        let expected = ErrorKind::ArityMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn range_test_arity_too_many() {
-        let args = [
-            SteelVal::NumV(1.0),
-            SteelVal::NumV(2.0),
-            SteelVal::NumV(3.0),
-        ];
-        let res = steel_range(&args);
-        let expected = ErrorKind::ArityMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn range_test_normal_input() {
-        let args = [SteelVal::IntV(0), SteelVal::IntV(3)];
-        let res = steel_range(&args);
-        let expected =
-            SteelVal::ListV(vec![SteelVal::IntV(0), SteelVal::IntV(1), SteelVal::IntV(2)].into());
-        assert_eq!(res.unwrap(), expected);
-    }
-}
diff --git a/crates/steel-core/src/primitives/meta_ops.rs b/crates/steel-core/src/primitives/meta_ops.rs
deleted file mode 100644
index 76c585022..000000000
--- a/crates/steel-core/src/primitives/meta_ops.rs
+++ /dev/null
@@ -1,200 +0,0 @@
-use crate::rvals::{poll_future, Result, SteelVal};
-use crate::stop;
-use crate::{
-    gc::{get_object_count, Gc},
-    rvals::FutureResult,
-};
-
-use futures_util::future::join_all;
-
-// use async_compat::Compat;
-
-use futures_util::FutureExt;
-
-pub struct MetaOperations {}
-impl MetaOperations {
-    pub fn inspect_bytecode() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            // let mut error_message = String::new();
-
-            if args.len() == 1 {
-                match &args[0] {
-                    SteelVal::Closure(bytecode_lambda) => {
-                        crate::core::instructions::pretty_print_dense_instructions(
-                            &bytecode_lambda.body_exp(),
-                        );
-                        Ok(SteelVal::Void)
-                    }
-                    // SteelVal::ContractedFunction(c) => {
-                    //     if let SteelVal::Closure(bytecode_lambda) = &c.function {
-                    //         crate::core::instructions::pretty_print_dense_instructions(
-                    //             &bytecode_lambda.body_exp(),
-                    //         );
-                    //         Ok(SteelVal::Void)
-                    //     } else {
-                    //         stop!(TypeMismatch => "inspect-bytecode expects a closure object");
-                    //     }
-                    // }
-                    _ => {
-                        stop!(TypeMismatch => "inspect-bytecode expects a closure object");
-                    }
-                }
-            } else {
-                stop!(ArityMismatch => "inspect-bytecode takes only one argument");
-            }
-        })
-    }
-
-    pub fn active_objects() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if !args.is_empty() {
-                stop!(ArityMismatch => "active-object-count expects only one argument");
-            }
-            Ok(SteelVal::IntV(get_object_count() as isize))
-        })
-    }
-
-    pub fn memory_address() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "memory address takes one address")
-            }
-
-            // let memory_address = format!("{:p}", &args[0].as_ptr());
-
-            Ok(SteelVal::StringV("TODO".into())) // TODO come back here
-        })
-    }
-
-    pub fn assert_truthy() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "assert takes one argument")
-            }
-            if let SteelVal::BoolV(true) = &args[0] {
-                Ok(SteelVal::Void)
-            } else {
-                panic!("Value given not true!")
-            }
-        })
-    }
-
-    // Uses a generic executor w/ the compat struct in order to allow tokio ecosystem functions inside
-    // the interpreter
-    // pub fn exec_async() -> SteelVal {
-    //     SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-    //         let mut executor = LocalPool::new();
-
-    //         let joined_futures: Vec<_> = args
-    //             .into_iter()
-    //             .map(|x| {
-    //                 if let SteelVal::FutureV(f) = x {
-    //                     Ok(f.unwrap().into_shared())
-    //                 } else {
-    //                     stop!(TypeMismatch => "exec-async given non future")
-    //                 }
-    //             })
-    //             .collect::<Result<Vec<_>>>()?;
-
-    //         let futures = join_all(joined_futures);
-
-    //         // spawner.spawn_local_obj(joined_futures);
-
-    //         // let future = LocalFutureObj::new(Box::pin(async {}));
-    //         // spawner.spawn_local_obj(future);
-    //         // executor.run_until(future);
-    //         Ok(SteelVal::VectorV(Gc::new(
-    //             executor
-    //                 .run_until(Compat::new(futures))
-    //                 .into_iter()
-    //                 .collect::<Result<_>>()?,
-    //         )))
-    //     })
-    // }
-
-    pub fn poll_value() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(Generic => "poll! only takes one argument");
-            }
-
-            if let SteelVal::FutureV(fut) = args[0].clone() {
-                let fut = fut.unwrap();
-                let ready = poll_future(fut.into_shared());
-                match ready {
-                    Some(v) => v,
-                    None => Ok(SteelVal::BoolV(false)),
-                }
-            } else {
-                stop!(Generic => "poll! accepts futures only");
-            }
-        })
-    }
-
-    pub fn block_on() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(Generic => "block-on! only takes one argument");
-            }
-
-            if let SteelVal::FutureV(fut) = args[0].clone() {
-                loop {
-                    let fut = fut.unwrap();
-                    let ready = poll_future(fut.into_shared());
-                    if let Some(v) = ready {
-                        return v;
-                    }
-                }
-            } else {
-                stop!(Generic => "block-on! accepts futures only");
-            }
-        })
-    }
-
-    pub fn join_futures() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.is_empty() {
-                stop!(Generic => "join! requires at least one argument");
-            }
-
-            let joined_futures: Vec<_> = args
-                .iter()
-                .map(|x| {
-                    if let SteelVal::FutureV(f) = x {
-                        Ok(f.unwrap().into_shared())
-                    } else {
-                        stop!(TypeMismatch => "join! given non future")
-                    }
-                })
-                .collect::<Result<Vec<_>>>()?;
-
-            let futures = join_all(joined_futures).map(|x| {
-                x.into_iter()
-                    .collect::<Result<im_rc::Vector<_>>>()
-                    .map(|x| SteelVal::VectorV(Gc::new(x).into()))
-            });
-
-            Ok(SteelVal::FutureV(Gc::new(FutureResult::new(Box::pin(
-                futures,
-            )))))
-        })
-    }
-}
-
-// pub(crate) fn steel_box(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-//     if args.len() != 1 {
-//         builtin_stop!(ArityMismatch => "box takes one argument, found: {}", args.len())
-//     }
-
-//     let arg = args[0].clone();
-
-//     // Allocate the variable directly on the heap
-//     let allocated_var = ctx.thread.heap.allocate(
-//         arg,
-//         ctx.thread.stack.iter(),
-//         ctx.thread.stack_frames.iter().map(|x| x.function.as_ref()),
-//         ctx.thread.global_env.roots(),
-//     );
-
-//     Some(Ok(SteelVal::Boxed(allocated_var)))
-// }
diff --git a/crates/steel-core/src/primitives/nums.rs b/crates/steel-core/src/primitives/nums.rs
deleted file mode 100644
index 06665cd12..000000000
--- a/crates/steel-core/src/primitives/nums.rs
+++ /dev/null
@@ -1,546 +0,0 @@
-use num::{Integer, ToPrimitive};
-
-use crate::rvals::{Custom, IntoSteelVal, Result, SteelVal};
-use crate::stop;
-
-pub fn multiply_primitive(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.is_empty() {
-        // stop!(ArityMismatch => "* requires at least one argument")
-
-        return Ok(SteelVal::IntV(1));
-    }
-
-    let mut sum_int = 1;
-    let mut sum_float = 1.0;
-    let mut bignum = num::BigInt::default();
-    let mut found_float = false;
-    let mut found_bignum = false;
-
-    for arg in args {
-        match arg {
-            SteelVal::IntV(n) => {
-                if found_float {
-                    sum_float *= *n as f64;
-                } else if found_bignum {
-                    bignum *= *n;
-                } else if let Some(res) = isize::checked_mul(sum_int, *n) {
-                    sum_int = res
-                } else {
-                    found_bignum = true;
-
-                    bignum += sum_int;
-                    bignum *= *n;
-                }
-            }
-            SteelVal::NumV(n) => {
-                if !found_float {
-                    sum_float = sum_int as f64;
-                    found_float = true
-                }
-                sum_float *= n;
-            }
-            SteelVal::BigNum(n) => {
-                // If we have a float already, just stay in float
-                if found_float {
-                    sum_float *= n.to_f64().unwrap();
-                // If we haven't found a float, but we have promoted to bignum, we can stay
-                // in bignum
-                } else if found_bignum {
-                    bignum *= n.as_ref();
-                } else {
-                    // Promote to bignum
-                    bignum = n.unwrap();
-                    bignum *= sum_int;
-
-                    found_bignum = true;
-                }
-            }
-            _ => stop!(TypeMismatch => "* expected a number"),
-        }
-    }
-
-    if found_float {
-        Ok(SteelVal::NumV(sum_float))
-    } else if found_bignum {
-        bignum.into_steelval()
-    } else {
-        Ok(SteelVal::IntV(sum_int))
-    }
-}
-
-pub fn quotient(l: isize, r: isize) -> isize {
-    l / r
-}
-
-pub fn divide_primitive(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.is_empty() {
-        stop!(ArityMismatch => "/ requires at least one argument")
-    }
-
-    if args.len() == 1 {
-        match &args[0] {
-            SteelVal::IntV(n) => return Ok(SteelVal::NumV((1 / n) as f64)),
-            SteelVal::NumV(n) => return Ok(SteelVal::NumV((1.0 / n) as f64)),
-            unexpected => {
-                stop!(TypeMismatch => "division expects a number, found: {:?}", unexpected)
-            }
-        }
-    }
-
-    let mut no_floats = true;
-
-    let floats: Result<Vec<f64>> = args
-        .iter()
-        .map(|x| match x {
-            SteelVal::IntV(n) => Ok(*n as f64),
-            SteelVal::NumV(n) => {
-                no_floats = false;
-                Ok(*n)
-            }
-            _ => stop!(TypeMismatch => "division expects a number"),
-        })
-        .collect();
-
-    let mut floats = floats?.into_iter();
-
-    if let Some(first) = floats.next() {
-        let result = floats.fold(first, |acc, x| acc / x);
-
-        if no_floats && result.fract() == 0.0 {
-            Ok(SteelVal::IntV(result as isize))
-        } else {
-            Ok(SteelVal::NumV(result))
-        }
-    } else {
-        stop!(ArityMismatch => "division requires at least one argument")
-    }
-}
-
-#[inline(always)]
-pub fn subtract_primitive(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.is_empty() {
-        stop!(ArityMismatch => "- requires at least one argument")
-    }
-
-    if args.len() == 1 {
-        match &args[0] {
-            SteelVal::IntV(n) => {
-                if let Some(res) = 0isize.checked_sub(*n) {
-                    return Ok(SteelVal::IntV(res));
-                } else {
-                    let mut zero = num::BigInt::from(0);
-
-                    zero -= *n;
-
-                    return zero.into_steelval();
-                }
-            }
-            SteelVal::NumV(n) => {
-                return Ok(SteelVal::NumV(0.0 - n));
-            }
-            SteelVal::BigNum(n) => {
-                return (0isize - n.as_ref()).into_steelval();
-            }
-            _ => {
-                stop!(TypeMismatch => format!("'-' expected a number type, found: {}", &args[0]))
-            }
-        }
-    }
-
-    let mut sum_int = 0;
-    let mut sum_float = 0.0;
-    let mut found_float = false;
-
-    let mut args = args.iter();
-
-    if let Some(first) = args.next() {
-        match first {
-            SteelVal::IntV(n) => {
-                sum_int = *n;
-
-                // sum_float = *n as f64;
-            }
-            SteelVal::NumV(n) => {
-                found_float = true;
-                sum_float = *n;
-            }
-            _ => {
-                stop!(TypeMismatch => format!("'-' expected a number type, found: {first}"))
-            }
-        }
-    }
-
-    for arg in args {
-        match arg {
-            SteelVal::IntV(n) => {
-                if found_float {
-                    sum_float -= *n as f64;
-                } else if let Some(res) = isize::checked_sub(sum_int, *n) {
-                    sum_int = res
-                } else {
-                    found_float = true;
-                    sum_float -= *n as f64;
-                }
-            }
-            SteelVal::NumV(n) => {
-                if !found_float {
-                    sum_float = sum_int as f64;
-                    found_float = true
-                }
-                sum_float -= n;
-            }
-            _ => {
-                stop!(TypeMismatch => "- expected a number")
-            }
-        }
-    }
-
-    if found_float {
-        Ok(SteelVal::NumV(sum_float))
-    } else {
-        Ok(SteelVal::IntV(sum_int))
-    }
-}
-
-pub fn add_primitive_faster(args: &[SteelVal]) -> Result<SteelVal> {
-    let mut sum_int = 0;
-    let mut sum_float = 0.0;
-    let mut found_float = false;
-
-    for arg in args {
-        match arg {
-            SteelVal::IntV(n) => {
-                sum_int += n;
-            }
-            SteelVal::NumV(n) => {
-                sum_float += n;
-                found_float = true;
-            }
-            _ => {
-                crate::steel_vm::vm::cold();
-                let e = format!("+ expected a number, found {arg:?}");
-                stop!(TypeMismatch => e);
-            }
-        }
-    }
-
-    if found_float {
-        Ok(SteelVal::NumV(sum_float + sum_int as f64))
-    } else {
-        Ok(SteelVal::IntV(sum_int))
-    }
-}
-
-pub fn add_primitive(args: &[SteelVal]) -> Result<SteelVal> {
-    let mut sum_int = 0;
-    let mut sum_float = 0.0;
-    let mut found_float = false;
-
-    for arg in args {
-        match arg {
-            SteelVal::IntV(n) => {
-                if found_float {
-                    sum_float += *n as f64;
-                } else if let Some(res) = isize::checked_add(sum_int, *n) {
-                    sum_int = res
-                } else {
-                    found_float = true;
-                    sum_float += *n as f64;
-                }
-            }
-            SteelVal::NumV(n) => {
-                if !found_float {
-                    sum_float = sum_int as f64;
-                    found_float = true
-                }
-                sum_float += n;
-            }
-            _ => {
-                let e = format!("+ expected a number, found {arg:?}, all args: {args:?}");
-                stop!(TypeMismatch => e);
-            }
-        }
-    }
-
-    if found_float {
-        Ok(SteelVal::NumV(sum_float))
-    } else {
-        Ok(SteelVal::IntV(sum_int))
-    }
-}
-
-pub struct NumOperations {}
-impl NumOperations {
-    pub fn arithmetic_shift() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "arithmetic-shift takes 2 arguments")
-            }
-            let n = args[0].clone();
-            let m = args[1].clone();
-
-            match (n, m) {
-                (SteelVal::IntV(n), SteelVal::IntV(m)) => {
-                    if m >= 0 {
-                        Ok(SteelVal::IntV(n << m))
-                    } else {
-                        Ok(SteelVal::IntV(n >> -m))
-                    }
-                }
-                _ => stop!(TypeMismatch => "arithmetic-shift expected 2 integers"),
-            }
-        })
-    }
-
-    pub fn even() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "even? takes one argument")
-            }
-
-            match &args[0] {
-                SteelVal::IntV(n) => Ok(SteelVal::BoolV(n & 1 == 0)),
-                SteelVal::BigNum(n) => Ok(SteelVal::BoolV(n.is_even())),
-                _ => {
-                    stop!(TypeMismatch => format!("even? requires an integer, found: {:?}", &args[0]))
-                }
-            }
-        })
-    }
-
-    pub fn odd() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "odd? takes one argument")
-            }
-
-            match &args[0] {
-                SteelVal::IntV(n) => Ok(SteelVal::BoolV(n & 1 == 1)),
-                SteelVal::BigNum(n) => Ok(SteelVal::BoolV(n.is_odd())),
-                _ => {
-                    stop!(TypeMismatch => format!("odd? requires an integer, found: {:?}", &args[0]))
-                }
-            }
-        })
-    }
-
-    pub fn integer_add() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.is_empty() {
-                stop!(ArityMismatch => "+ requires at least one argument")
-            }
-
-            let mut sum = 0;
-
-            for arg in args {
-                if let SteelVal::IntV(n) = arg {
-                    sum += n;
-                } else {
-                    stop!(TypeMismatch => "+ expected a number, found {:?}", arg);
-                }
-            }
-
-            Ok(SteelVal::IntV(sum))
-        })
-    }
-
-    pub fn integer_sub() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.is_empty() {
-                stop!(ArityMismatch => "+ requires at least one argument")
-            }
-
-            let mut sum = if let SteelVal::IntV(n) = &args[0] {
-                *n
-            } else {
-                stop!(TypeMismatch => "- expected a number, found {:?}", &args[0])
-            };
-
-            for arg in &args[1..] {
-                if let SteelVal::IntV(n) = arg {
-                    sum -= n;
-                } else {
-                    stop!(TypeMismatch => "+ expected a number, found {:?}", arg);
-                }
-            }
-
-            Ok(SteelVal::IntV(sum))
-        })
-    }
-
-    pub fn float_add() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.is_empty() {
-                stop!(ArityMismatch => "+ requires at least one argument")
-            }
-
-            let mut sum = 0.0;
-
-            for arg in args {
-                if let SteelVal::NumV(n) = arg {
-                    sum += n;
-                } else {
-                    stop!(TypeMismatch => "+ expected a number, found {:?}", arg);
-                }
-            }
-
-            Ok(SteelVal::NumV(sum))
-        })
-    }
-
-    pub fn adder() -> SteelVal {
-        // SteelVal::FuncV(add_primitive_faster)
-        SteelVal::FuncV(special_add)
-    }
-
-    pub fn multiply() -> SteelVal {
-        SteelVal::FuncV(multiply_primitive)
-    }
-
-    // TODO implement the full numerical tower
-    // For now, only support division into floats
-    pub fn divide() -> SteelVal {
-        SteelVal::FuncV(divide_primitive)
-    }
-
-    pub fn subtract() -> SteelVal {
-        SteelVal::FuncV(subtract_primitive)
-    }
-}
-
-impl Custom for num::BigRational {}
-
-impl IntoSteelVal for num::BigInt {
-    fn into_steelval(self) -> Result<SteelVal> {
-        Ok(SteelVal::BigNum(crate::gc::Gc::new(self)))
-    }
-}
-
-#[steel_derive::native(name = "+", constant = true, arity = "AtLeast(0)")]
-pub fn special_add(args: &[SteelVal]) -> Result<SteelVal> {
-    let mut sum_int: isize = 0;
-    let mut sum_float = 0.0;
-    let mut found_float = false;
-
-    // Hoping this does not allocate
-    let mut big_int_sum = num::BigInt::default();
-    let mut found_big_int = false;
-
-    for arg in args {
-        match arg {
-            SteelVal::IntV(n) => {
-                // sum_int += n;
-
-                if let Some(right_side) = sum_int.checked_add(*n) {
-                    sum_int = right_side;
-                } else {
-                    // If we overflowed, just promote to big int
-                    big_int_sum += *n;
-                    found_big_int = true;
-                }
-            }
-            SteelVal::NumV(n) => {
-                sum_float += n;
-                found_float = true;
-            }
-
-            SteelVal::BigNum(b) => {
-                big_int_sum += b.as_ref();
-                found_big_int = true;
-            }
-
-            _ => {
-                crate::steel_vm::vm::cold();
-                let e = format!("+ expected a number, found {arg:?}");
-                stop!(TypeMismatch => e);
-            }
-        }
-    }
-
-    if found_float {
-        Ok(SteelVal::NumV(
-            sum_float + sum_int as f64 + big_int_sum.to_f64().unwrap(),
-        ))
-    } else if found_big_int {
-        big_int_sum += sum_int;
-        big_int_sum.into_steelval()
-    } else {
-        Ok(SteelVal::IntV(sum_int))
-    }
-}
-
-#[cfg(test)]
-mod num_op_tests {
-
-    use super::*;
-    use crate::rvals::SteelVal::*;
-    use crate::throw;
-
-    fn apply_function(func: SteelVal, args: Vec<SteelVal>) -> Result<SteelVal> {
-        func.func_or_else(throw!(BadSyntax => "num op tests"))
-            .unwrap()(&args)
-    }
-
-    #[test]
-    fn division_test() {
-        let args = vec![IntV(10), IntV(2)];
-
-        let output = apply_function(NumOperations::divide(), args).unwrap();
-        let expected = IntV(5);
-        assert_eq!(output.to_string(), expected.to_string());
-    }
-
-    #[test]
-    fn multiplication_test() {
-        let args = vec![IntV(10), IntV(2)];
-
-        let output = apply_function(NumOperations::multiply(), args).unwrap();
-        let expected = IntV(20);
-        assert_eq!(output, expected);
-    }
-
-    #[test]
-    fn multiplication_different_types() {
-        let args = vec![IntV(10), NumV(2.0)];
-
-        let output = apply_function(NumOperations::multiply(), args).unwrap();
-        let expected = NumV(20.0);
-        assert_eq!(output.to_string(), expected.to_string());
-    }
-
-    #[test]
-    fn addition_different_types() {
-        let args = vec![IntV(10), NumV(2.0)];
-
-        let output = apply_function(NumOperations::adder(), args).unwrap();
-        let expected = NumV(12.0);
-        assert_eq!(output.to_string(), expected.to_string());
-    }
-
-    #[test]
-    fn subtraction_different_types() {
-        let args = vec![IntV(10), NumV(2.0)];
-
-        let output = apply_function(NumOperations::subtract(), args).unwrap();
-        let expected = NumV(8.0);
-        assert_eq!(output.to_string(), expected.to_string());
-    }
-
-    #[test]
-    fn test_integer_add() {
-        let args = vec![IntV(10), IntV(2)];
-
-        let output = apply_function(NumOperations::integer_add(), args).unwrap();
-        let expected = IntV(12);
-        assert_eq!(output, expected);
-    }
-
-    #[test]
-    fn test_integer_sub() {
-        let args = vec![IntV(10), IntV(2)];
-
-        let output = apply_function(NumOperations::integer_sub(), args).unwrap();
-        let expected = IntV(8);
-        assert_eq!(output, expected);
-    }
-}
diff --git a/crates/steel-core/src/primitives/ports.rs b/crates/steel-core/src/primitives/ports.rs
deleted file mode 100644
index 6f9c2f3c0..000000000
--- a/crates/steel-core/src/primitives/ports.rs
+++ /dev/null
@@ -1,237 +0,0 @@
-use crate::rvals::{Result, SteelString, SteelVal};
-use crate::steel_vm::builtin::BuiltInModule;
-use crate::stop;
-use crate::values::port::new_rc_ref_cell;
-use crate::values::port::{SteelPort, SteelPortRepr};
-
-use steel_derive::function;
-
-thread_local! {
-    pub static EOF_OBJECT: SteelString = "eof".into();
-}
-
-pub fn port_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/ports");
-    module
-        .register_native_fn_definition(OPEN_STDIN_DEFINITION)
-        .register_native_fn_definition(OPEN_STDOUT_DEFINITION)
-        .register_native_fn_definition(OPEN_INPUT_FILE_DEFINITION)
-        .register_native_fn_definition(OPEN_OUTPUT_FILE_DEFINITION)
-        .register_native_fn_definition(OPEN_OUTPUT_STRING_DEFINITION)
-        .register_native_fn_definition(WRITE_LINE_DEFINITION)
-        .register_native_fn_definition(WRITE_STRING_DEFINITION)
-        .register_native_fn_definition(WRITE_DEFINITION)
-        .register_native_fn_definition(WRITE_CHAR_DEFINITION)
-        .register_native_fn_definition(FLUSH_OUTPUT_PORT_DEFINITION)
-        .register_native_fn_definition(READ_PORT_TO_STRING_DEFINITION)
-        .register_native_fn_definition(READ_LINE_TO_STRING_DEFINITION)
-        .register_native_fn_definition(GET_OUTPUT_STRING_DEFINITION)
-        .register_native_fn_definition(IS_INPUT_DEFINITION)
-        .register_native_fn_definition(IS_OUTPUT_DEFINITION)
-        .register_native_fn_definition(DEFAULT_INPUT_PORT_DEFINITION)
-        .register_native_fn_definition(DEFAULT_OUTPUT_PORT_DEFINITION);
-    module
-}
-
-/// Gets the port handle to stdin
-///
-/// (stdin) -> input-port?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (stdin) ;; => #<port>
-/// ```
-#[function(name = "stdin")]
-pub fn open_stdin() -> SteelVal {
-    SteelVal::PortV(SteelPort {
-        port: new_rc_ref_cell(SteelPortRepr::StdInput(std::io::stdin())),
-    })
-}
-
-#[function(name = "stdout")]
-pub fn open_stdout() -> SteelVal {
-    SteelVal::PortV(SteelPort {
-        port: new_rc_ref_cell(SteelPortRepr::StdOutput(std::io::stdout())),
-    })
-}
-
-/// Takes a filename `path` referring to an existing file and returns an input port. Raises an error
-/// if the file does not exist
-///
-/// (open-input-file string?) -> input-port?
-///
-/// # Examples
-/// ```scheme
-/// > (open-input-file "foo-bar.txt") ;; => #<port>
-/// > (open-input-file "file-does-not-exist.txt")
-/// error[E08]: Io
-///   ┌─ :1:2
-///   │
-/// 1 │ (open-input-file "foo-bar.txt")
-///   │  ^^^^^^^^^^^^^^^ No such file or directory (os error 2)
-/// ```
-#[function(name = "open-input-file")]
-pub fn open_input_file(path: &SteelString) -> Result<SteelVal> {
-    SteelPort::new_textual_file_input(path).map(SteelVal::PortV)
-}
-
-/// Takes a filename `path` referring to a file to be created and returns an output port.
-///
-/// (open-output-file string?) -> output-port?
-///
-/// # Examples
-/// ```scheme
-/// > (open-output-file "foo-bar.txt") ;; => #<port>
-/// ```
-#[function(name = "open-output-file")]
-pub fn open_output_file(path: &SteelString) -> Result<SteelVal> {
-    SteelPort::new_textual_file_output(path).map(SteelVal::PortV)
-}
-
-#[function(name = "open-output-string")]
-pub fn open_output_string() -> SteelVal {
-    SteelVal::PortV(SteelPort::new_output_port())
-}
-
-/// Takes a port and reads the entire content into a string
-///
-/// (read-port-to-string port) -> string?
-///
-/// * port : input-port?
-#[function(name = "read-port-to-string")]
-pub fn read_port_to_string(port: &SteelPort) -> Result<SteelVal> {
-    let (_, result) = port.read_all_str()?;
-    Ok(SteelVal::StringV(result.into()))
-}
-
-/// Checks if a given value is an input port
-///
-/// (input-port? any/c) -> bool?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (input-port? (stdin)) ;; => #true
-/// > (input-port? "foo") ;; => #false
-/// ```
-#[function(name = "input-port?")]
-pub fn is_input(maybe_port: &SteelVal) -> bool {
-    if let SteelVal::PortV(port) = maybe_port {
-        port.is_input()
-    } else {
-        false
-    }
-}
-
-/// Checks if a given value is an output port
-///
-/// (output-port? any/c) -> bool?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (define output (open-output-file "foo.txt"))
-/// > (output-port? output) ;; => #true
-/// ```
-#[function(name = "output-port?")]
-pub fn is_output(maybe_port: &SteelVal) -> bool {
-    if let SteelVal::PortV(port) = maybe_port {
-        port.is_output()
-    } else {
-        false
-    }
-}
-
-#[function(name = "read-line-from-port")]
-pub fn read_line_to_string(port: &SteelPort) -> Result<SteelVal> {
-    let res = port.read_line();
-
-    if let Ok((size, result)) = res {
-        if size == 0 {
-            Ok(SteelVal::SymbolV(EOF_OBJECT.with(|x| x.clone())))
-        } else {
-            Ok(SteelVal::StringV(result.into()))
-        }
-    } else {
-        // bit of a hack for now we'll see
-        res.map(|_| unreachable!())
-    }
-}
-
-#[function(name = "write-line!")]
-pub fn write_line(port: &SteelPort, line: &SteelVal) -> Result<SteelVal> {
-    let line = line.to_string();
-    let res = port.write_string_line(line.as_str());
-
-    if res.is_ok() {
-        Ok(SteelVal::Void)
-    } else {
-        stop!(Generic => "unable to write string to file");
-    }
-}
-
-#[function(name = "raw-write")]
-pub fn write(port: &SteelPort, line: &SteelVal) -> Result<SteelVal> {
-    let line = line.to_string();
-    let res = port.write_string(line.as_str());
-
-    if res.is_ok() {
-        Ok(SteelVal::Void)
-    } else {
-        stop!(Generic => "unable to write string to port");
-    }
-}
-
-#[function(name = "raw-write-char")]
-pub fn write_char(port: &SteelPort, character: char) -> Result<SteelVal> {
-    let res = port.write_char(character);
-
-    if res.is_ok() {
-        Ok(SteelVal::Void)
-    } else {
-        stop!(Generic => "unable to write string to port");
-    }
-}
-
-#[function(name = "raw-write-string")]
-pub fn write_string(port: &SteelPort, line: &SteelVal) -> Result<SteelVal> {
-    let res = if let SteelVal::StringV(s) = line {
-        port.write_string(s.as_str())
-    } else {
-        port.write_string(line.to_string().as_str())
-    };
-
-    if res.is_ok() {
-        Ok(SteelVal::Void)
-    } else {
-        stop!(Generic => "unable to write string to port");
-    }
-}
-
-#[function(name = "get-output-string")]
-pub fn get_output_string(port: &SteelPort) -> Result<SteelVal> {
-    port.get_output_string().map(SteelVal::from)
-}
-
-#[function(name = "flush-output-port")]
-pub fn flush_output_port(port: &SteelPort) -> Result<SteelVal> {
-    port.flush().map(|_| SteelVal::Void)
-}
-
-#[function(name = "#%default-input-port")]
-pub fn default_input_port() -> SteelVal {
-    SteelVal::PortV(SteelPort::default_current_input_port())
-}
-
-#[function(name = "#%default-output-port")]
-pub fn default_output_port() -> SteelVal {
-    SteelVal::PortV(SteelPort::default_current_output_port())
-}
-
-// TODO: In order for this to work, ports have to get refactored - the mutability needs to be
-// on the outside, rather than the inside.
-#[function(name = "close-output-port")]
-pub fn close_output_port(port: &SteelPort) -> Result<SteelVal> {
-    port.close_output_port().map(|_| SteelVal::Void)
-}
diff --git a/crates/steel-core/src/primitives/process.rs b/crates/steel-core/src/primitives/process.rs
deleted file mode 100644
index a7c3310b6..000000000
--- a/crates/steel-core/src/primitives/process.rs
+++ /dev/null
@@ -1,159 +0,0 @@
-use std::cell::RefCell;
-use std::io::{BufReader, BufWriter};
-use std::process::{Child, Command, ExitStatus, Stdio};
-use std::rc::Rc;
-
-use im_lists::list::List;
-
-use crate::values::port::{SteelPort, SteelPortRepr};
-use crate::values::structs::SteelResult;
-use crate::SteelVal;
-use crate::{rvals::Custom, steel_vm::builtin::BuiltInModule};
-use crate::{steel_vm::register_fn::RegisterFn, SteelErr};
-
-pub fn process_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/process".to_string());
-
-    module
-        .register_fn("command", CommandBuilder::new)
-        .register_fn("set-current-dir!", CommandBuilder::current_dir)
-        .register_fn("set-piped-stdout!", CommandBuilder::stdout_piped)
-        .register_fn("spawn-process", CommandBuilder::spawn_process)
-        .register_fn("wait", ChildProcess::wait)
-        .register_fn("wait->stdout", ChildProcess::wait_with_stdout)
-        .register_fn("which", binary_exists_on_path)
-        .register_fn("child-stdout", ChildProcess::stdout)
-        .register_fn("child-stdin", ChildProcess::stdin);
-
-    module
-}
-
-#[derive(Debug)]
-struct CommandBuilder {
-    command: Command,
-}
-
-#[derive(Debug)]
-struct ChildProcess {
-    child: Option<Child>,
-}
-
-#[derive(Debug)]
-struct ProcessExitStatus {
-    _exit_status: ExitStatus,
-}
-
-fn binary_exists_on_path(binary: String) -> Option<String> {
-    match which::which(binary) {
-        Ok(v) => Some(v.into_os_string().into_string().unwrap()),
-        Err(_) => None,
-    }
-}
-
-impl ProcessExitStatus {
-    pub fn new(_exit_status: ExitStatus) -> Self {
-        Self { _exit_status }
-    }
-}
-
-impl ChildProcess {
-    pub fn new(child: Child) -> Self {
-        Self { child: Some(child) }
-    }
-
-    pub fn stdout(&mut self) -> Option<SteelVal> {
-        let stdout = self
-            .child
-            .as_mut()
-            .and_then(|x| x.stdout.take())
-            .and_then(|x| {
-                Some(SteelVal::PortV(SteelPort {
-                    port: Rc::new(RefCell::new(SteelPortRepr::ChildStdOutput(BufReader::new(
-                        x,
-                    )))),
-                }))
-            });
-
-        stdout
-
-        //     todo!()
-    }
-
-    pub fn stdin(&mut self) -> Option<SteelVal> {
-        let stdout = self
-            .child
-            .as_mut()
-            .and_then(|x| x.stdin.take())
-            .and_then(|x| {
-                Some(SteelVal::PortV(SteelPort {
-                    port: Rc::new(RefCell::new(SteelPortRepr::ChildStdInput(BufWriter::new(
-                        x,
-                    )))),
-                }))
-            });
-
-        stdout
-
-        //     todo!()
-    }
-    fn wait_impl(&mut self) -> Result<ProcessExitStatus, SteelErr> {
-        self.child
-            .take()
-            .ok_or_else(crate::throw!(Generic => "Child already awaited!"))?
-            .wait()
-            .map(ProcessExitStatus::new)
-            .map_err(|x| x.into())
-    }
-
-    pub fn wait(&mut self) -> SteelResult<ProcessExitStatus, SteelErr> {
-        self.wait_impl().into()
-    }
-
-    fn wait_with_stdout_impl(&mut self) -> Result<String, SteelErr> {
-        let stdout = self
-            .child
-            .take()
-            .ok_or_else(crate::throw!(Generic => "Child already awaited!"))?
-            .wait_with_output()?
-            .stdout;
-
-        String::from_utf8(stdout)
-            .map_err(|e| SteelErr::new(crate::rerrs::ErrorKind::ConversionError, e.to_string()))
-    }
-
-    pub fn wait_with_stdout(&mut self) -> SteelResult<String, SteelErr> {
-        self.wait_with_stdout_impl().into()
-    }
-}
-
-impl CommandBuilder {
-    pub fn new(command: String, args: List<String>) -> CommandBuilder {
-        let mut command = Command::new(command);
-
-        command.args(&args);
-
-        Self { command }
-    }
-
-    pub fn current_dir(&mut self, directory: String) {
-        self.command.current_dir(directory);
-    }
-
-    pub fn stdout_piped(&mut self) {
-        self.command.stdout(Stdio::piped());
-        self.command.stderr(Stdio::piped());
-        self.command.stdin(Stdio::piped());
-    }
-
-    pub fn spawn_process(&mut self) -> SteelResult<ChildProcess, SteelErr> {
-        self.command
-            .spawn()
-            .map(ChildProcess::new)
-            .map_err(|x| x.into())
-            .into()
-    }
-}
-
-impl Custom for CommandBuilder {}
-impl Custom for ChildProcess {}
-impl Custom for ProcessExitStatus {}
diff --git a/crates/steel-core/src/primitives/random.rs b/crates/steel-core/src/primitives/random.rs
deleted file mode 100644
index fef8fa9b9..000000000
--- a/crates/steel-core/src/primitives/random.rs
+++ /dev/null
@@ -1,38 +0,0 @@
-use rand::prelude::*;
-
-use crate::steel_vm::builtin::DocTemplate;
-use crate::steel_vm::register_fn::RegisterFn;
-use crate::{rvals::Custom, steel_vm::builtin::BuiltInModule};
-
-impl Custom for ThreadRng {}
-
-pub(crate) const THREAD_RNG_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(thread-rng!) -> ThreadRng?",
-    params: &[],
-    description: r#"Constructs a `ThreadRng` object"#,
-    examples: &[],
-};
-
-pub(crate) const RNG_GEN_USIZE: DocTemplate<'static> = DocTemplate {
-    signature: "(rng->gen-usize rng) -> int?",
-    params: &["rng: ThreadRng?"],
-    description: r#"Generates a random unsigned integer"#,
-    examples: &[],
-};
-
-/// Constructs the random module
-pub fn random_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/random");
-
-    module
-        .register_fn("thread-rng!", thread_rng)
-        .register_doc("thread-rng!", THREAD_RNG_DOC)
-        .register_fn("rng->gen-usize", ThreadRng::gen::<usize>)
-        .register_doc("rng->gen-usize", RNG_GEN_USIZE)
-        .register_fn(
-            "rng->gen-range",
-            |rng: &mut ThreadRng, x: isize, y: isize| ThreadRng::gen_range(rng, x..y),
-        );
-
-    module
-}
diff --git a/crates/steel-core/src/primitives/sqlite/mod.rs b/crates/steel-core/src/primitives/sqlite/mod.rs
deleted file mode 100644
index a76839f68..000000000
--- a/crates/steel-core/src/primitives/sqlite/mod.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use im_lists::list::List;
-use rusqlite::{
-    params_from_iter,
-    types::{FromSql, ToSqlOutput, Value},
-    Connection, Result, Statement, ToSql,
-};
-
-use crate::{
-    rvals::{Custom, SteelString},
-    steel_vm::{builtin::BuiltInModule, register_fn::RegisterFn},
-    SteelVal,
-};
-
-impl Custom for Connection {}
-impl Custom for rusqlite::Error {}
-
-impl Custom for Statement<'static> {}
-
-impl ToSql for SteelVal {
-    fn to_sql(&self) -> Result<ToSqlOutput<'_>> {
-        match self {
-            Self::IntV(b) => Ok(ToSqlOutput::Owned(Value::Integer((*b).try_into().unwrap()))),
-            Self::StringV(s) => Ok(ToSqlOutput::Owned(Value::Text(s.to_string()))),
-            Self::NumV(n) => Ok(ToSqlOutput::Owned(Value::Real(*n))),
-            Self::Void => Ok(ToSqlOutput::Owned(Value::Null)),
-            _ => {
-                todo!("Implement serialization for other types: {:?}", self)
-            }
-        }
-    }
-}
-
-impl FromSql for SteelVal {
-    fn column_result(value: rusqlite::types::ValueRef<'_>) -> rusqlite::types::FromSqlResult<Self> {
-        match value {
-            rusqlite::types::ValueRef::Null => Ok(SteelVal::Void),
-            rusqlite::types::ValueRef::Integer(i) => Ok(SteelVal::IntV(i as isize)),
-            rusqlite::types::ValueRef::Real(f) => Ok(SteelVal::NumV(f)),
-            rusqlite::types::ValueRef::Text(t) => Ok(SteelVal::StringV(
-                std::str::from_utf8(t)
-                    .expect("Unable to decode text from sqlite")
-                    .into(),
-            )),
-            rusqlite::types::ValueRef::Blob(_) => {
-                todo!("Implement deserialization for other types")
-            }
-        }
-    }
-}
-
-fn prepare_and_execute(
-    connection: &Connection,
-    sql: SteelString,
-    params: List<im_lists::list::List<SteelVal>>,
-) -> Result<usize> {
-    let mut statement = connection.prepare(sql.as_str())?;
-
-    let mut count = 0;
-
-    for group in params {
-        count += statement.execute(params_from_iter(group))?;
-    }
-
-    Ok(count)
-}
-
-// Consider returning a struct directly...
-fn prepare_and_query(
-    connection: &Connection,
-    sql: SteelString,
-    params: List<SteelVal>,
-) -> Result<List<List<SteelVal>>> {
-    let mut statement = connection.prepare(sql.as_str())?;
-
-    let mut rows = statement.query(params_from_iter(params))?;
-
-    let mut results = Vec::new();
-
-    let mut width: Option<usize> = None;
-
-    while let Some(row) = rows.next()? {
-        if let Some(width) = width {
-            // TODO: Save the row length for the next iteration, so that we can pre allocate
-            // the row width
-            let mut computed_row: Vec<SteelVal> = Vec::with_capacity(width);
-
-            for i in 0..width {
-                computed_row.push(row.get(i).unwrap())
-            }
-
-            results.push(List::from(computed_row));
-        } else {
-            // TODO: Save the row length for the next iteration, so that we can pre allocate
-            // the row width
-            let mut computed_row: Vec<SteelVal> = Vec::new();
-            let mut i = 0;
-
-            while let Ok(value) = row.get(i) {
-                computed_row.push(value);
-                i += 1;
-            }
-
-            width = Some(i);
-
-            results.push(List::from(computed_row));
-        }
-    }
-
-    // todo!()
-
-    Ok(List::from(results))
-}
-
-// Consider returning a struct directly...
-fn _query_to_struct_list(
-    _connection: &Connection,
-    _sql: SteelString,
-    _params: List<SteelVal>,
-    _struct_descriptor: SteelVal,
-) -> Result<List<List<SteelVal>>> {
-    todo!("Add pushing a struct constructor directly on to the values returned for one less allocation")
-}
-
-fn connection_wrapper(
-    connection: &Connection,
-    sql: SteelString,
-    params: List<SteelVal>,
-) -> Result<usize> {
-    connection.execute(&sql, params_from_iter(params))
-}
-
-pub fn sqlite_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/sqlite".to_string());
-
-    module
-        .register_fn("connection/open-in-memory", Connection::open_in_memory)
-        .register_fn("connection/execute!", connection_wrapper)
-        .register_fn("connection/prepare-and-execute!", prepare_and_execute)
-        .register_fn("connection/prepare-and-query!", prepare_and_query);
-
-    module
-}
diff --git a/crates/steel-core/src/primitives/streams.rs b/crates/steel-core/src/primitives/streams.rs
deleted file mode 100644
index fdbfdd0cb..000000000
--- a/crates/steel-core/src/primitives/streams.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use crate::gc::Gc;
-use crate::rvals::{Result, SteelVal};
-use crate::stop;
-
-use crate::values::lazy_stream::LazyStream;
-
-pub struct StreamOperations {}
-impl StreamOperations {
-    pub fn stream_cons() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "stream-cons requires 2 argments")
-            }
-
-            if let SteelVal::Closure(_) = &args[1] {
-                let initial_value = args[0].clone();
-                let stream_thunk = args[1].clone();
-                Ok(SteelVal::StreamV(Gc::new(LazyStream::new(
-                    initial_value,
-                    stream_thunk,
-                ))))
-            } else {
-                stop!(TypeMismatch => "stream-cons takes a function in the second position")
-            }
-        })
-    }
-
-    #[inline(always)]
-    pub fn empty_stream() -> SteelVal {
-        SteelVal::StreamV(Gc::new(LazyStream::new_empty_stream()))
-    }
-
-    pub fn stream_empty_huh() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "stream-empty takes 1 argument")
-            }
-            if let SteelVal::StreamV(s) = &args[0] {
-                Ok(s.empty_stream())
-            } else {
-                stop!(TypeMismatch => "stream-empty? takes a stream")
-            }
-        })
-    }
-
-    pub fn stream_car() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "stream-car takes 1 argument")
-            }
-            if let SteelVal::StreamV(s) = &args[0] {
-                Ok(s.stream_first())
-            } else {
-                stop!(TypeMismatch => "stream-car takes a stream")
-            }
-        })
-    }
-
-    pub fn stream_cdr() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "stream-cdr takes 1 argument")
-            }
-            if let SteelVal::StreamV(s) = &args[0] {
-                Ok(s.stream_thunk())
-            } else {
-                stop!(TypeMismatch => format!("stream-cdr takes a stream, found: {}", &args[0]))
-            }
-        })
-    }
-}
diff --git a/crates/steel-core/src/primitives/strings.rs b/crates/steel-core/src/primitives/strings.rs
deleted file mode 100644
index 316a05437..000000000
--- a/crates/steel-core/src/primitives/strings.rs
+++ /dev/null
@@ -1,781 +0,0 @@
-use crate::values::lists::List;
-
-use crate::rvals::{RestArgsIter, Result, SteelString, SteelVal};
-use crate::steel_vm::builtin::BuiltInModule;
-use crate::steel_vm::register_fn::RegisterFn;
-use crate::stop;
-
-use steel_derive::{function, native};
-
-fn char_upcase(c: char) -> char {
-    c.to_ascii_uppercase()
-}
-
-/// # steel/strings
-///
-/// Strings in Steel are immutable, fixed length arrays of characters. They are heap allocated,
-/// and are implemented under the hood as referenced counted rust `Strings`.
-#[steel_derive::define_module(name = "steel/strings")]
-pub fn string_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/strings");
-    module
-        .register_native_fn_definition(STRING_APPEND_DEFINITION)
-        .register_native_fn_definition(TO_STRING_DEFINITION)
-        .register_native_fn_definition(STRING_TO_LIST_DEFINITION)
-        .register_native_fn_definition(STRING_TO_UPPER_DEFINITION)
-        .register_native_fn_definition(STRING_TO_LOWER_DEFINITION)
-        .register_native_fn_definition(STRING_LENGTH_DEFINITION)
-        .register_native_fn_definition(TRIM_DEFINITION)
-        .register_native_fn_definition(TRIM_START_DEFINITION)
-        .register_native_fn_definition(TRIM_END_DEFINITION)
-        .register_native_fn_definition(SPLIT_WHITESPACE_DEFINITION)
-        .register_native_fn_definition(SPLIT_ONCE_DEFINITION)
-        .register_native_fn_definition(SPLIT_MANY_DEFINITION)
-        .register_native_fn_definition(STRING_TO_INT_DEFINITION)
-        .register_native_fn_definition(INT_TO_STRING_DEFINITION)
-        .register_native_fn_definition(STRING_TO_SYMBOL_DEFINITION)
-        .register_native_fn_definition(STARTS_WITH_DEFINITION)
-        .register_native_fn_definition(ENDS_WITH_DEFINITION)
-        .register_native_fn_definition(TRIM_END_MATCHES_DEFINITION)
-        .register_native_fn_definition(TRIM_START_MATCHES_DEFINITION)
-        .register_native_fn_definition(STRING_REF_DEFINITION)
-        .register_native_fn_definition(SUBSTRING_DEFINITION)
-        .register_native_fn_definition(MAKE_STRING_DEFINITION)
-        .register_native_fn_definition(STRING_EQUALS_DEFINITION)
-        .register_native_fn_definition(STRING_CI_EQUALS_DEFINITION)
-        .register_native_fn_definition(STRING_LESS_THAN_DEFINITION)
-        .register_native_fn_definition(STRING_CI_LESS_THAN_DEFINITION)
-        .register_native_fn_definition(STRING_LESS_THAN_EQUAL_TO_DEFINITION)
-        .register_native_fn_definition(STRING_CI_LESS_THAN_EQUAL_TO_DEFINITION)
-        .register_native_fn_definition(STRING_GREATER_THAN_DEFINITION)
-        .register_native_fn_definition(STRING_CI_GREATER_THAN_DEFINITION)
-        .register_native_fn_definition(STRING_GREATER_THAN_EQUAL_TO_DEFINITION)
-        .register_native_fn_definition(STRING_CI_GREATER_THAN_EQUAL_TO_DEFINITION)
-        .register_native_fn_definition(STRING_CONSTRUCTOR_DEFINITION)
-        .register_native_fn_definition(STRING_TO_NUMBER_DEFINITION)
-        .register_native_fn_definition(NUMBER_TO_STRING_DEFINITION)
-        .register_fn("char-upcase", char_upcase)
-        .register_fn("char-whitespace?", char::is_whitespace)
-        .register_fn("char-digit?", |c: char| char::is_digit(c, 10))
-        .register_fn("char->number", |c: char| char::to_digit(c, 10))
-        .register_native_fn_definition(CHAR_EQUALS_DEFINITION);
-    module
-}
-
-#[function(name = "char=?", constant = true)]
-pub fn char_equals(left: char, right: char) -> bool {
-    left == right
-}
-
-fn number_to_string_impl(value: &SteelVal, radix: Option<u32>) -> Result<SteelVal> {
-    match value {
-        SteelVal::IntV(v) => {
-            if let Some(radix) = radix {
-                Ok(SteelVal::StringV(
-                    radix_fmt::radix(*v, radix as u8).to_string().into(),
-                ))
-            } else {
-                Ok(SteelVal::StringV(v.to_string().into()))
-            }
-        }
-        SteelVal::NumV(n) => Ok(SteelVal::StringV(n.to_string().into())),
-        SteelVal::BigNum(n) => Ok(SteelVal::StringV(n.to_string().into())),
-        _ => stop!(TypeMismatch => "number->string expects a number type, found: {}", value),
-    }
-}
-
-#[function(name = "number->string", constant = true)]
-pub fn number_to_string(value: &SteelVal, mut rest: RestArgsIter<'_, isize>) -> Result<SteelVal> {
-    let radix = rest.next();
-
-    let radix = if let Some(radix) = radix {
-        let radix = radix?;
-
-        if radix < 2 || radix > 16 {
-            stop!(ContractViolation => "radix value given to string->number must be between 2 and 16, found: {}", radix);
-        }
-
-        Some(radix as u32)
-    } else {
-        None
-    };
-
-    number_to_string_impl(value, radix)
-}
-
-fn string_to_number_impl(value: &str, radix: Option<u32>) -> Result<SteelVal> {
-    let expr = crate::parser::parser::Parser::parse(value)?;
-
-    if expr.len() != 1 {
-        // stop!(Generic => "")
-        return Ok(SteelVal::BoolV(false));
-    }
-
-    let number = expr.into_iter().next().unwrap();
-
-    let svalue = SteelVal::try_from(number)?;
-
-    match &svalue {
-        SteelVal::IntV(v) => {
-            if let Some(radix) = radix {
-                match isize::from_str_radix(value, radix) {
-                    Ok(parsed) => Ok(SteelVal::IntV(parsed)),
-                    Err(_) => Ok(SteelVal::BoolV(false)),
-                }
-            } else {
-                Ok(SteelVal::IntV(*v))
-            }
-        }
-        SteelVal::NumV(_) | SteelVal::BigNum(_) => Ok(svalue),
-        _ => Ok(SteelVal::BoolV(false)),
-    }
-}
-
-#[function(name = "string->number", constant = true)]
-pub fn string_to_number(
-    value: &SteelString,
-    mut rest: RestArgsIter<'_, isize>,
-) -> Result<SteelVal> {
-    let radix = rest.next();
-
-    let radix = if let Some(radix) = radix {
-        let radix = radix?;
-
-        if radix < 2 || radix > 16 {
-            stop!(ContractViolation => "radix value given to string->number must be between 2 and 16, found: {}", radix);
-        }
-
-        Some(radix as u32)
-    } else {
-        None
-    };
-    match string_to_number_impl(value.as_str(), radix) {
-        Ok(v) => Ok(v),
-        Err(_) => Ok(SteelVal::BoolV(false)),
-    }
-}
-
-#[function(name = "string")]
-pub fn string_constructor(rest: RestArgsIter<'_, char>) -> Result<SteelVal> {
-    rest.collect::<Result<String>>().map(|x| x.into())
-}
-
-#[function(name = "string<=?", constant = true)]
-pub fn string_less_than_equal_to(left: &SteelString, right: &SteelString) -> bool {
-    left <= right
-}
-
-#[function(name = "string-ci<=?", constant = true)]
-pub fn string_ci_less_than_equal_to(left: &SteelString, right: &SteelString) -> bool {
-    left.to_lowercase() <= right.to_lowercase()
-}
-
-#[function(name = "string<?", constant = true)]
-pub fn string_less_than(left: &SteelString, right: &SteelString) -> bool {
-    left < right
-}
-
-#[function(name = "string-ci<?", constant = true)]
-pub fn string_ci_less_than(left: &SteelString, right: &SteelString) -> bool {
-    left.to_lowercase() < right.to_lowercase()
-}
-
-#[function(name = "string>=?", constant = true)]
-pub fn string_greater_than_equal_to(left: &SteelString, right: &SteelString) -> bool {
-    left >= right
-}
-
-#[function(name = "string-ci>=?", constant = true)]
-pub fn string_ci_greater_than_equal_to(left: &SteelString, right: &SteelString) -> bool {
-    left.to_lowercase() >= right.to_lowercase()
-}
-
-#[function(name = "string>?", constant = true)]
-pub fn string_greater_than(left: &SteelString, right: &SteelString) -> bool {
-    left > right
-}
-
-#[function(name = "string-ci>?", constant = true)]
-pub fn string_ci_greater_than(left: &SteelString, right: &SteelString) -> bool {
-    left.to_lowercase() > right.to_lowercase()
-}
-
-#[function(name = "string=?", constant = true)]
-pub fn string_equals(left: &SteelString, right: &SteelString) -> bool {
-    left == right
-}
-
-#[function(name = "string-ci=?", constant = true)]
-pub fn string_ci_equals(left: &SteelString, right: &SteelString) -> bool {
-    left.to_lowercase() == right.to_lowercase()
-}
-
-#[function(name = "string-ref", constant = true)]
-pub fn string_ref(value: &SteelString, index: usize) -> Result<SteelVal> {
-    if index >= value.len() {
-        stop!(Generic => "string-ref: index out of bounds: index: {}, string length: {}", index, value);
-    }
-
-    Ok(SteelVal::CharV(value.as_str().chars().nth(index).unwrap()))
-}
-
-#[function(name = "substring", constant = true)]
-pub fn substring(value: &SteelString, i: usize, j: usize) -> Result<SteelVal> {
-    if i >= value.len() {
-        stop!(Generic => "substring: index out of bounds: left bound: {}, string length: {}", i, value.len());
-    }
-
-    if i > j {
-        stop!(Generic => "substring: left bound must be less than or equal to the right bound: left: {}, right: {}", i, j);
-    }
-
-    Ok(SteelVal::StringV(value[i..j].into()))
-}
-
-#[function(name = "make-string")]
-pub fn make_string(k: usize, mut c: RestArgsIter<'_, char>) -> Result<SteelVal> {
-    // If the char is there, we want to take it
-    let char = c.next();
-
-    // We want the iterator to be exhaused
-    if let Some(next) = c.next() {
-        stop!(ArityMismatch => format!("make-string expected 1 or 2 arguments, got an additional argument {}", next?))
-    }
-
-    let c = char.unwrap_or(Ok('\0'))?;
-    Ok((0..k).into_iter().map(|_| c).collect::<String>().into())
-}
-
-/// Concatenatives all of the inputs to their string representation, separated by spaces.
-///
-/// (to-string xs ...)
-///
-/// * xs : any/c
-///
-/// # Examples
-/// ```scheme
-/// > (to-string 10) ;; => "10"
-/// > (to-string "hello" "world") ;; => "hello world"
-/// ```
-#[native(name = "to-string", arity = "AtLeast(0)")]
-pub fn to_string(args: &[SteelVal]) -> Result<SteelVal> {
-    let mut error_message = String::new();
-
-    if let Some((first, rest)) = args.split_first() {
-        error_message.push_str(first.to_string().trim_matches('\"'));
-
-        for arg in rest {
-            let error_val = arg.to_string();
-            error_message.push(' ');
-            error_message.push_str(error_val.trim_matches('\"'));
-        }
-    }
-
-    Ok(SteelVal::StringV(error_message.into()))
-}
-
-/// Converts a string into a symbol.
-///
-/// (string->symbol string?) -> symbol?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (string->symbol "FooBar") ;; => 'FooBar
-/// ```
-#[function(name = "string->symbol", constant = true)]
-pub fn string_to_symbol(value: SteelString) -> SteelVal {
-    SteelVal::SymbolV(value)
-}
-
-/// Converts an integer into a string.
-///
-/// (int->string int?) -> string?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (int->string 10) ;; => "10"
-/// ```
-#[function(name = "int->string")]
-pub fn int_to_string(value: isize) -> String {
-    format!("{value}")
-}
-
-/// Converts a string into an int. Raises an error if the string cannot be converted to an integer.
-///
-/// (string->int string?) -> int?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (string->int "100") ;; => 10
-/// > (string->int "not-an-int") ;; error
-/// ```
-#[function(name = "string->int")]
-pub fn string_to_int(value: &SteelString) -> Result<SteelVal> {
-    let parsed_int = value.parse::<isize>();
-    match parsed_int {
-        Ok(n) => Ok(SteelVal::IntV(n)),
-        Err(_) => {
-            stop!(TypeMismatch => "could not convert number to integer");
-        }
-    }
-}
-
-/// Converts a string into a list of characters.
-///
-/// (string->list string?) -> (listof char?)
-///
-/// # Examples
-///
-/// ```scheme
-/// > (string->list "hello") ;; => '(#\h #\e #\l #\l #\o)
-/// ```
-#[function(name = "string->list")]
-pub fn string_to_list(value: &SteelString) -> SteelVal {
-    value
-        .chars()
-        .map(SteelVal::CharV)
-        .collect::<List<_>>()
-        .into()
-}
-
-/// Creates a new uppercased version of the input string
-///
-/// (string->upper string?) -> string?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (string->upper "lower") ;; => "LOWER"
-/// ```
-#[function(name = "string->upper")]
-pub fn string_to_upper(value: &SteelString) -> String {
-    value.to_uppercase()
-}
-
-/// Creates a new lowercased version of the input string
-///
-/// (string->lower string?) -> string?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (string->lower "sPonGeBoB tExT") ;; => "spongebob text"
-/// ```
-#[function(name = "string->lower")]
-pub fn string_to_lower(value: &SteelString) -> String {
-    value.to_lowercase()
-}
-
-/// Returns a new string with the leading and trailing whitespace removed.
-///
-/// (trim string?) -> string?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (trim "   foo     ") ;; => "foo"
-/// ```
-#[function(name = "trim")]
-pub fn trim(value: &SteelString) -> String {
-    value.trim().into()
-}
-
-/// Returns a new string with the leading whitespace removed.
-///
-/// (trim string?) -> string?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (trim "   foo     ") ;; => "foo     "
-/// ```
-#[function(name = "trim-start")]
-pub fn trim_start(value: &SteelString) -> String {
-    value.trim_start().into()
-}
-
-/// Returns a new string with the trailing whitespace removed.
-///
-/// (trim string?) -> string?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (trim "   foo     ") ;; => "   foo"
-/// ```
-#[function(name = "trim-end")]
-pub fn trim_end(value: &SteelString) -> String {
-    value.trim_end().into()
-}
-
-/// Returns a new string with the given `pat` repeatedly removed from the end
-/// of the string
-///
-/// ```scheme
-/// (trim-end-matches string? string?) -> string?
-/// ```
-///
-/// # Examples
-/// ```scheme
-/// > (trim-end-matches "123foo1bar123123" "123") ;; => "123foo1bar"
-/// ```
-#[function(name = "trim-end-matches")]
-pub fn trim_end_matches(value: &SteelString, pat: &SteelString) -> String {
-    value.trim_end_matches(pat.as_str()).into()
-}
-
-/// Returns a new string with the given `pat` repeatedly removed from the start
-/// of the string
-///
-/// ```scheme
-/// (trim-start-matches string? string?) -> string?
-/// ```
-///
-/// # Examples
-/// ```scheme
-/// > (trim-start-matches "123foo1bar123123" "123") ;; => "foo1bar123123"
-/// ```
-#[function(name = "trim-start-matches")]
-pub fn trim_start_matches(value: &SteelString, pat: &SteelString) -> String {
-    value.trim_start_matches(pat.as_str()).into()
-}
-
-/// Returns a list of strings from the original string split on the whitespace
-///
-/// (split-whitespace string?) -> (listof string?)
-///
-/// # Examples
-///
-/// ```scheme
-/// (split-whitespace "apples bananas fruits veggies") ;; '("apples" "bananas" "fruits" "veggies")
-/// ```
-#[function(name = "split-whitespace")]
-pub fn split_whitespace(value: &SteelString) -> SteelVal {
-    let split: List<SteelVal> = value
-        .split_whitespace()
-        .map(|x| SteelVal::StringV(x.into()))
-        .collect();
-    split.into()
-}
-
-#[function(name = "split-once")]
-pub fn split_once(value: &SteelString, pat: &SteelString) -> SteelVal {
-    let split: Option<List<SteelVal>> = value
-        .split_once(pat.as_str())
-        .map(|(x, y)| vec![SteelVal::StringV(x.into()), SteelVal::StringV(y.into())].into());
-    split.into()
-}
-
-#[function(name = "split-many")]
-pub fn split_many(value: &SteelString, pat: &SteelString) -> SteelVal {
-    let split: List<SteelVal> = value
-        .split(pat.as_str())
-        .map(|x| SteelVal::StringV(x.into()))
-        .collect();
-    split.into()
-}
-
-/// Checks if the input string starts with a prefix
-///
-/// (starts-with? input pattern) -> bool?
-///
-///    input : string?
-///    pattern: string?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (starts-with? "foobar" "foo") ;; => #true
-/// > (starts-with? "foobar" "bar") ;; => #false
-/// ```
-#[function(name = "starts-with?")]
-pub fn starts_with(value: &SteelString, prefix: &SteelString) -> bool {
-    value.starts_with(prefix.as_str())
-}
-
-/// Checks if the input string ends with a given suffix
-///
-/// (ends-with? input pattern) -> bool?
-///
-///    input : string?
-///    pattern: string?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (ends-with? "foobar" "foo") ;; => #false
-/// > (ends-with? "foobar" "bar") ;; => #true
-/// ```
-#[function(name = "ends-with?")]
-pub fn ends_with(value: &SteelString, suffix: &SteelString) -> bool {
-    value.ends_with(suffix.as_str())
-}
-
-/// Get the length of the given string
-///
-/// (string-length string?) -> int?
-///
-/// # Examples
-///
-/// ```scheme
-/// > (string-length "apples") ;; => 6
-/// ```
-#[function(name = "string-length")]
-pub fn string_length(value: &SteelString) -> usize {
-    value.len()
-}
-
-/// Concatenates all of the given strings into one
-///
-/// (string-append strs...) -> string?
-///
-/// * strs ... : string?
-///
-/// # Examples
-/// ```scheme
-/// > (string-append) ;; => ""
-/// > (string-append "foo" "bar") ;; => "foobar"
-// ```
-#[function(name = "string-append")]
-pub fn string_append(mut rest: RestArgsIter<'_, &SteelString>) -> Result<SteelVal> {
-    rest.0
-        .try_fold("".to_string(), |accum, next| Ok(accum + next?.as_str()))
-        .map(|x| SteelVal::StringV(x.into()))
-}
-
-#[cfg(test)]
-mod string_operation_tests {
-    use super::*;
-    use crate::rerrs::ErrorKind;
-
-    // TODO combine these 3 macros into one
-    macro_rules! apply_tests_arity_too_many {
-        ($(($name:expr, $symbol:ident, $func:expr)),* $(,)?) => {
-            $(
-                #[test]
-                pub fn $symbol() {
-                    let args = vec![
-                        SteelVal::StringV("FOO".into()),
-                        SteelVal::StringV("BAR".into()),
-                    ];
-                    let res = $func(&args);
-                    let expected = ErrorKind::ArityMismatch;
-                    assert_eq!(res.unwrap_err().kind(), expected);
-                }
-            )*
-        };
-    }
-
-    macro_rules! apply_tests_arity_too_few {
-        ($(($name:expr, $symbol:ident, $func:expr)),* $(,)?) => {
-            $(
-                #[test]
-                pub fn $symbol() {
-                    let args = vec![];
-                    let res = $func(&args);
-                    let expected = ErrorKind::ArityMismatch;
-                    assert_eq!(res.unwrap_err().kind(), expected);
-                }
-            )*
-        };
-    }
-
-    macro_rules! apply_tests_bad_arg {
-        ($(($name:expr, $symbol:ident, $func:expr)),* $(,)?) => {
-            $(
-                #[test]
-                pub fn $symbol() {
-                    let args = vec![SteelVal::NumV(10.0)];
-                    let res = $func(&args);
-                    let expected = ErrorKind::TypeMismatch;
-                    assert_eq!(res.unwrap_err().kind(), expected);
-                }
-            )*
-        };
-    }
-
-    apply_tests_arity_too_many! {
-        ("string-upcase", string_upper_arity_too_many, steel_string_to_upper),
-        ("string-lowercase", string_lower_arity_too_many, steel_string_to_lower),
-        ("trim", trim_arity_too_many, steel_trim),
-        ("trim-start", trim_start_arity_too_many, steel_trim_start),
-        ("trim-end", trim_end_arity_too_many, steel_trim_end),
-        ("string->list", string_to_list_arity_too_many, steel_string_to_list),
-        ("split-whitespace", split_whitespace_arity_too_many, steel_split_whitespace),
-    }
-
-    apply_tests_arity_too_few! {
-        ("string-upcase", string_upper_arity_too_few, steel_string_to_upper),
-        ("string-lowercase", string_lower_arity_too_few, steel_string_to_lower),
-        ("trim", trim_arity_too_few, steel_trim),
-        ("trim-start", trim_start_arity_too_few, steel_trim_start),
-        ("trim-end", trim_end_arity_too_few, steel_trim_end),
-        ("string->list", string_to_list_arity_too_few, steel_string_to_list),
-        ("split-whitespace", split_whitespace_arity_too_few, steel_split_whitespace)
-    }
-
-    apply_tests_bad_arg! {
-        ("string-upcase", string_upper_arity_takes_string, steel_string_to_upper),
-        ("string-lowercase", string_lower_arity_takes_string, steel_string_to_lower),
-        ("trim", trim_arity_takes_string, steel_trim),
-        ("trim-start", trim_start_arity_takes_string, steel_trim_start),
-        ("trim-end", trim_end_arity_takes_string, steel_trim_end),
-        ("string->list", string_to_list_takes_string, steel_string_to_list),
-        ("split-whitespace", split_whitespace_arity_takes_string, steel_split_whitespace)
-    }
-
-    #[test]
-    fn string_append_test_normal() {
-        let args = vec![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-        ];
-        let res = steel_string_append(&args);
-        let expected = SteelVal::StringV("foobar".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn string_append_test_takes_string() {
-        let args = vec![SteelVal::CharV('a'), SteelVal::CharV('b')];
-        let res = steel_string_append(&args);
-        let expected = ErrorKind::TypeMismatch;
-        assert_eq!(res.unwrap_err().kind(), expected);
-    }
-
-    #[test]
-    fn string_to_upper_normal() {
-        let args = vec![SteelVal::StringV("foobarbaz".into())];
-        let res = steel_string_to_upper(&args);
-        let expected = SteelVal::StringV("FOOBARBAZ".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn string_to_upper_spaces() {
-        let args = vec![SteelVal::StringV("foo bar baz qux".into())];
-        let res = steel_string_to_upper(&args);
-        let expected = SteelVal::StringV("FOO BAR BAZ QUX".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn string_to_lower_normal() {
-        let args = vec![SteelVal::StringV("FOOBARBAZ".into())];
-        let res = steel_string_to_lower(&args);
-        let expected = SteelVal::StringV("foobarbaz".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn string_to_lower_spaces() {
-        let args = vec![SteelVal::StringV("FOO BAR BAZ QUX".into())];
-        let res = steel_string_to_lower(&args);
-        let expected = SteelVal::StringV("foo bar baz qux".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    // TODO investigate this, assert_eq! fails without converting to string
-    #[test]
-    fn string_to_list_normal() {
-        let args = vec![SteelVal::StringV("foo".into())];
-        let res = steel_string_to_list(&args);
-
-        let expected = SteelVal::ListV(
-            vec![
-                SteelVal::CharV('f'),
-                SteelVal::CharV('o'),
-                SteelVal::CharV('o'),
-            ]
-            .into(),
-        );
-
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn string_to_list_empty() {
-        let args = vec![SteelVal::StringV("".into())];
-        let res = steel_string_to_list(&args);
-        let expected = SteelVal::ListV(List::new());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn trim_normal_no_changes() {
-        let args = vec![SteelVal::StringV("foo".into())];
-        let res = steel_trim(&args);
-        let expected = SteelVal::StringV("foo".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn trim_normal_trims_both_sides() {
-        let args = vec![SteelVal::StringV("      foo  ".into())];
-        let res = steel_trim(&args);
-        let expected = SteelVal::StringV("foo".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn trim_start_no_changes() {
-        let args = vec![SteelVal::StringV("foo".into())];
-        let res = steel_trim_start(&args);
-        let expected = SteelVal::StringV("foo".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn trim_end_no_changes() {
-        let args = vec![SteelVal::StringV("foo".into())];
-        let res = steel_trim_end(&args);
-        let expected = SteelVal::StringV("foo".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn trim_start_normal_trims_left_side() {
-        let args = vec![SteelVal::StringV("      foo  ".into())];
-        let res = steel_trim_start(&args);
-        let expected = SteelVal::StringV("foo  ".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn trim_end_normal_trims_right_side() {
-        let args = vec![SteelVal::StringV("      foo  ".into())];
-        let res = steel_trim_end(&args);
-        let expected = SteelVal::StringV("      foo".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    // TODO investigate this one
-    #[test]
-    fn split_whitespace_no_whitespace() {
-        let args = vec![SteelVal::StringV("foo".into())];
-        let res = steel_split_whitespace(&args);
-
-        let expected = SteelVal::ListV(vec![SteelVal::StringV("foo".into())].into());
-
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn split_whitespace_some_whitespace() {
-        let args = vec![SteelVal::StringV("foo bar baz".into())];
-        let res = steel_split_whitespace(&args);
-
-        let expected = SteelVal::ListV(
-            vec![
-                SteelVal::StringV("foo".into()),
-                SteelVal::StringV("bar".into()),
-                SteelVal::StringV("baz".into()),
-            ]
-            .into(),
-        );
-        assert_eq!(res.unwrap(), expected);
-    }
-}
diff --git a/crates/steel-core/src/primitives/symbols.rs b/crates/steel-core/src/primitives/symbols.rs
deleted file mode 100644
index 66133a1f2..000000000
--- a/crates/steel-core/src/primitives/symbols.rs
+++ /dev/null
@@ -1,76 +0,0 @@
-use crate::rvals::{Result, SteelVal};
-use crate::stop;
-
-pub struct SymbolOperations {}
-impl SymbolOperations {
-    pub fn concat_symbols() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            let mut new_symbol = String::new();
-
-            for arg in args {
-                if let SteelVal::SymbolV(quoted_value) = arg {
-                    new_symbol.push_str(quoted_value.as_ref());
-                } else {
-                    let error_message =
-                        format!("concat-symbol expected only symbols, found {args:?}");
-                    stop!(TypeMismatch => error_message);
-                }
-            }
-
-            Ok(SteelVal::SymbolV(new_symbol.into()))
-        })
-    }
-
-    pub fn symbol_to_string() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() == 1 {
-                match &args[0] {
-                    SteelVal::SymbolV(quoted_value) => Ok(SteelVal::StringV(quoted_value.clone())),
-                    SteelVal::ListV(_) => Ok(SteelVal::StringV(
-                        format!("{:?}", &args[0]).trim_start_matches('\'').into(),
-                    )),
-                    _ => {
-                        let error_message =
-                            format!("symbol->string expected a symbol, found {}", &args[0]);
-                        stop!(TypeMismatch => error_message)
-                    }
-                }
-            } else {
-                stop!(ArityMismatch => "symbol->string expects only one argument")
-            }
-        })
-    }
-}
-
-#[cfg(test)]
-mod symbol_tests {
-    use super::*;
-    use crate::throw;
-
-    use crate::rvals::SteelVal::*;
-
-    fn apply_function(func: SteelVal, args: Vec<SteelVal>) -> Result<SteelVal> {
-        func.func_or_else(throw!(BadSyntax => "hash tests"))
-            .unwrap()(&args)
-    }
-
-    #[test]
-    fn concat_symbols_normal() {
-        let args = vec![
-            SymbolV("foo".into()),
-            SymbolV("bar".into()),
-            SymbolV("baz".into()),
-        ];
-        let result = apply_function(SymbolOperations::concat_symbols(), args);
-        let expected = SymbolV("foobarbaz".into());
-        assert_eq!(result.unwrap(), expected);
-    }
-
-    #[test]
-    fn symbol_to_string_normal() {
-        let args = vec![SymbolV("foo".into())];
-        let result = apply_function(SymbolOperations::symbol_to_string(), args);
-        let expected = StringV("foo".into());
-        assert_eq!(result.unwrap(), expected);
-    }
-}
diff --git a/crates/steel-core/src/primitives/time.rs b/crates/steel-core/src/primitives/time.rs
deleted file mode 100644
index 9771f85c1..000000000
--- a/crates/steel-core/src/primitives/time.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use crate::gc::Gc;
-use crate::SteelVal;
-use crate::{rvals::Custom, steel_vm::builtin::MarkdownDoc};
-use chrono::Local;
-use std::{time::Duration, time::Instant};
-use steel_derive::function;
-
-use crate::steel_vm::builtin::BuiltInModule;
-use crate::steel_vm::register_fn::RegisterFn;
-
-pub(crate) const TIME_MODULE_DOC: MarkdownDoc<'static> = MarkdownDoc(
-    r#"
-
-# steel/time
-    
-Contains direct wrappers around the Rust `std::time::Instant` and `std::time::Duration` modules. 
-For example, to measure the time something takes:
-
-```scheme
-(define t (instant/now))
-(displayln "Hello world")
-(displayln (instant/elapsed t))
-```
-
-"#,
-);
-
-fn duration_to_string(duration: Duration) -> String {
-    format!("{duration:?}")
-}
-
-fn current_time_formatted(format_string: String) -> String {
-    Local::now().format(&format_string).to_string()
-}
-
-fn sleep_millis(millis: usize) {
-    std::thread::sleep(Duration::from_millis(millis.try_into().unwrap()))
-}
-
-#[function(name = "current-milliseconds")]
-fn current_milliseconds() -> SteelVal {
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    match SystemTime::now().duration_since(UNIX_EPOCH) {
-        Ok(n) => {
-            let ms = n.as_millis();
-            match isize::try_from(ms) {
-                Ok(inner) => SteelVal::IntV(inner),
-                _ => SteelVal::BigNum(Gc::new(num::BigInt::from(ms))),
-            }
-        }
-        Err(_) => panic!("SystemTime before UNIX EPOCH!"),
-    }
-}
-
-#[function(name = "current-second")]
-fn current_seconds() -> SteelVal {
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    match SystemTime::now().duration_since(UNIX_EPOCH) {
-        Ok(n) => {
-            let ms = n.as_millis();
-            match isize::try_from(ms) {
-                Ok(inner) => SteelVal::IntV(inner),
-                _ => SteelVal::BigNum(Gc::new(num::BigInt::from(ms))),
-            }
-        }
-        Err(_) => panic!("SystemTime before UNIX EPOCH!"),
-    }
-}
-
-#[function(name = "current-inexact-milliseconds")]
-fn current_inexact_milliseconds() -> f64 {
-    use std::time::{SystemTime, UNIX_EPOCH};
-
-    match SystemTime::now().duration_since(UNIX_EPOCH) {
-        Ok(n) => n.as_secs_f64() * 1000.0,
-        Err(_) => panic!("SystemTime before UNIX EPOCH!"),
-    }
-}
-
-pub fn time_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/time".to_string());
-
-    module.register_doc("steel/time", TIME_MODULE_DOC);
-
-    module
-        .register_fn("instant/now", Instant::now)
-        .register_fn("instant/elapsed", Instant::elapsed)
-        .register_fn("duration-since", Instant::duration_since)
-        .register_fn("duration->string", duration_to_string)
-        .register_fn("duration->seconds", Duration::as_secs)
-        .register_fn("local-time/now!", current_time_formatted)
-        .register_fn("time/sleep-ms", sleep_millis)
-        .register_native_fn_definition(CURRENT_MILLISECONDS_DEFINITION)
-        .register_native_fn_definition(CURRENT_SECONDS_DEFINITION)
-        .register_native_fn_definition(CURRENT_INEXACT_MILLISECONDS_DEFINITION);
-
-    module
-}
-
-impl Custom for Instant {}
-impl Custom for Duration {}
diff --git a/crates/steel-core/src/primitives/transducers.rs b/crates/steel-core/src/primitives/transducers.rs
deleted file mode 100644
index e0f59a5b6..000000000
--- a/crates/steel-core/src/primitives/transducers.rs
+++ /dev/null
@@ -1,196 +0,0 @@
-use crate::gc::Gc;
-use crate::rvals::SteelVal::*;
-use crate::rvals::{Result, SteelVal};
-use crate::stop;
-
-use crate::values::transducers::Transducer;
-use crate::values::transducers::Transducers;
-
-// declare_const_ref_functions!(
-//     COMPOSE => compose,
-//     ENUMERATING => enumerating,
-//     ZIPPING => zipping,
-//     INTERLEAVING => interleaving,
-//     MAPPING => map,
-//     EXTENDING => extending,
-//     FLAT_MAPPING => flat_map,
-//     FLATTENING => flatten,
-//     FILTERING => filter,
-//     TAKING => take,
-//     DROPPING => dropping,
-// );
-
-pub fn compose(args: &[SteelVal]) -> Result<SteelVal> {
-    let mut transformers = Transducer::new();
-    for transducer in args {
-        if let IterV(t) = transducer {
-            transformers.append(t.unwrap());
-        } else {
-            stop!(TypeMismatch => "compose only accepts transducers")
-        }
-    }
-
-    Ok(SteelVal::IterV(Gc::new(transformers)))
-}
-
-pub fn enumerating(args: &[SteelVal]) -> Result<SteelVal> {
-    if !args.is_empty() {
-        stop!(ArityMismatch => "enumerating takes no arguments");
-    }
-
-    let mut transducer = Transducer::new();
-    transducer.push(Transducers::Enumerating);
-    Ok(SteelVal::IterV(Gc::new(transducer)))
-}
-
-pub fn zipping(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => format!("zipping takes one argument, found: {}", args.len()));
-    }
-
-    match &args[0] {
-        VectorV(_) | StreamV(_) | StringV(_) | ListV(_) | HashSetV(_) | HashMapV(_) => {
-            let mut transducer = Transducer::new();
-            transducer.push(Transducers::Zipping(args[0].clone()));
-            Ok(SteelVal::IterV(Gc::new(transducer)))
-        }
-        v => {
-            stop!(TypeMismatch => format!("zipping expects an iterable, found: {v:?}"))
-        }
-    }
-}
-
-pub fn interleaving(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "interleaving takes one argument");
-    }
-
-    match &args[0] {
-        VectorV(_) | StreamV(_) | StringV(_) | ListV(_) | HashSetV(_) | HashMapV(_) => {
-            let mut transducer = Transducer::new();
-            transducer.push(Transducers::Interleaving(args[0].clone()));
-            Ok(SteelVal::IterV(Gc::new(transducer)))
-        }
-        v => {
-            stop!(TypeMismatch => format!("interleaving expects an iterable, found: {v:?}"))
-        }
-    }
-}
-
-pub fn map(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "mapping takes one argument");
-    }
-
-    match &args[0] {
-        Closure(_)
-        | FuncV(_)
-        | BoxedFunction(_)
-        // | ContractedFunction(_)
-        | BuiltIn(_)
-        | MutFunc(_) => {
-            let mut transducer = Transducer::new();
-            transducer.push(Transducers::Map(args[0].clone()));
-            Ok(SteelVal::IterV(Gc::new(transducer)))
-        }
-        v => stop!(TypeMismatch => format!("mapping expects a function, found: {v:?}")),
-    }
-}
-
-pub fn extending(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "extending takes one argument");
-    }
-
-    match &args[0] {
-        VectorV(_) | StreamV(_) | StringV(_) | ListV(_) | HashSetV(_) | HashMapV(_) => {
-            let mut transducer = Transducer::new();
-            transducer.push(Transducers::Extend(args[0].clone()));
-            Ok(SteelVal::IterV(Gc::new(transducer)))
-        }
-        v => {
-            stop!(TypeMismatch => format!("extending expects an iterable, found: {v:?}"))
-        }
-    }
-}
-
-pub fn flat_map(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "mapping takes one argument");
-    }
-
-    match &args[0] {
-        Closure(_)
-        | FuncV(_)
-        | BoxedFunction(_)
-        // | ContractedFunction(_)
-        | BuiltIn(_)
-        | MutFunc(_) => {
-            let mut transducer = Transducer::new();
-            transducer.push(Transducers::FlatMap(args[0].clone()));
-            Ok(SteelVal::IterV(Gc::new(transducer)))
-        }
-        v => {
-            stop!(TypeMismatch => format!("flat-mapping expects a function, found: {v:?}"))
-        }
-    }
-}
-
-pub fn flatten(args: &[SteelVal]) -> Result<SteelVal> {
-    if !args.is_empty() {
-        stop!(ArityMismatch => "flattening takes no arguments");
-    }
-
-    let mut transducer = Transducer::new();
-    transducer.push(Transducers::Flatten);
-    Ok(SteelVal::IterV(Gc::new(transducer)))
-}
-
-pub fn filter(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "filtering takes one argument");
-    }
-
-    match &args[0] {
-        Closure(_)
-        | FuncV(_)
-        | BoxedFunction(_)
-        // | ContractedFunction(_)
-        | BuiltIn(_)
-        | MutFunc(_) => {
-            let mut transducer = Transducer::new();
-            transducer.push(Transducers::Filter(args[0].clone()));
-            Ok(SteelVal::IterV(Gc::new(transducer)))
-        }
-        _ => stop!(TypeMismatch => "filtering expects a function"),
-    }
-}
-
-pub fn take(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "taking takes one argument");
-    }
-
-    if let IntV(_) = &args[0] {
-        let mut transducer = Transducer::new();
-        transducer.push(Transducers::Take(args[0].clone()));
-        Ok(SteelVal::IterV(Gc::new(transducer)))
-    } else {
-        stop!(TypeMismatch => "taking expects an integer")
-    }
-}
-
-pub fn dropping(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "dropping takes one argument");
-    }
-
-    if let IntV(_) = &args[0] {
-        let mut transducer = Transducer::new();
-        transducer.push(Transducers::Drop(args[0].clone()));
-        Ok(SteelVal::IterV(Gc::new(transducer)))
-    } else {
-        stop!(TypeMismatch => "dropping expects an integer")
-    }
-}
-// }
diff --git a/crates/steel-core/src/primitives/utils.rs b/crates/steel-core/src/primitives/utils.rs
deleted file mode 100644
index 8e89e4ff0..000000000
--- a/crates/steel-core/src/primitives/utils.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-pub trait SliceExt<T> {
-    fn get_clone(&self, idx: usize) -> T;
-}
-
-impl<T: Clone> SliceExt<T> for &[T] {
-    fn get_clone(&self, idx: usize) -> T {
-        self[idx].clone()
-    }
-}
diff --git a/crates/steel-core/src/primitives/vectors.rs b/crates/steel-core/src/primitives/vectors.rs
deleted file mode 100644
index 2ec194d2d..000000000
--- a/crates/steel-core/src/primitives/vectors.rs
+++ /dev/null
@@ -1,744 +0,0 @@
-use crate::gc::Gc;
-use crate::rvals::SteelVal::*;
-use crate::rvals::{Result, SteelVal};
-use crate::steel_vm::vm::VmCore;
-use crate::stop;
-use im_rc::Vector;
-
-pub struct VectorOperations {}
-impl VectorOperations {
-    pub fn vec_construct() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            Ok(SteelVal::VectorV(
-                Gc::new(args.iter().cloned().collect::<Vector<_>>()).into(),
-            ))
-        })
-    }
-
-    // TODO
-    pub fn mut_vec_construct() -> SteelVal {
-        SteelVal::BuiltIn(
-            |ctx: &mut VmCore, args: &[SteelVal]| -> Option<Result<SteelVal>> {
-                Some(Ok(ctx.make_mutable_vector(args.to_vec())))
-            },
-        )
-    }
-
-    pub fn make_vector() -> SteelVal {
-        fn make_vector_impl(ctx: &mut VmCore, args: &[SteelVal]) -> Result<SteelVal> {
-            match &args {
-                &[SteelVal::IntV(i)] if *i >= 0 => {
-                    Ok(ctx.make_mutable_vector(vec![SteelVal::IntV(0); *i as usize]))
-                }
-                &[SteelVal::IntV(i), initial_value] if *i >= 0 => {
-                    Ok(ctx.make_mutable_vector(vec![initial_value.clone(); *i as usize]))
-                }
-                _ => {
-                    stop!(TypeMismatch => "make-vector expects a positive integer, and optionally a value to initialize the vector with, found: {:?}", args)
-                }
-            }
-        }
-
-        SteelVal::BuiltIn(
-            |ctx: &mut VmCore, args: &[SteelVal]| -> Option<Result<SteelVal>> {
-                Some(make_vector_impl(ctx, args))
-            },
-        )
-    }
-
-    pub fn mut_vec_to_list() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "mutable-vector->list takes one argument, found: {:?}", args.len())
-            }
-
-            let vec = &args[0];
-
-            if let SteelVal::MutableVector(v) = vec {
-                let ptr = v.strong_ptr();
-                let guard = &mut ptr.borrow_mut().value;
-
-                // let new = std::mem::replace(guard, Vec::new());
-
-                Ok(SteelVal::ListV(guard.iter().collect()))
-
-                // let inner = std::mem::take(guard);
-
-                // Ok(SteelVal::ListV(inner.into()))
-            } else {
-                stop!(TypeMismatch => "mutable-vector->list expects a vector, found: {:?}", vec);
-            }
-        })
-    }
-
-    pub fn vec_length() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "vector-length expects one argument found: {:?}", args.len());
-            }
-
-            let vec = args[0].clone();
-
-            if let SteelVal::VectorV(v) = vec {
-                Ok(SteelVal::IntV(v.len() as isize))
-            } else {
-                stop!(TypeMismatch => "vector-length expects a mutable vector, found: {:?}", vec);
-            }
-        })
-    }
-
-    pub fn mut_vec_length() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "mut-vec-length expects one argument found: {:?}", args.len());
-            }
-
-            let vec = args[0].clone();
-
-            if let SteelVal::MutableVector(v) = vec {
-                Ok(SteelVal::IntV(v.get().len() as isize))
-            } else {
-                stop!(TypeMismatch => "mut-vec-length expects a mutable vector, found: {:?}", vec);
-            }
-        })
-    }
-
-    // (vector-set! vec pos value)
-    pub fn mut_vec_set() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 3 {
-                stop!(ArityMismatch => "vector-set! takes three arguments, found: {:?}", args.len())
-            }
-
-            let vec = args[0].clone();
-            let pos = args[1].clone();
-
-            if let SteelVal::MutableVector(v) = &vec {
-                if let SteelVal::IntV(i) = pos {
-                    if i < 0 {
-                        stop!(Generic => "vector-set! expects a positive integer, found: {:?}", vec);
-                    }
-
-                    let ptr = v.strong_ptr();
-
-                    let guard = &mut ptr.borrow_mut().value;
-
-                    if i as usize > guard.len() {
-                        stop!(Generic => "index out of bounds, index given: {:?}, length of vector: {:?}", i, guard.len());
-                    }
-
-                    // TODO: disallow cyclical references on construction
-
-                    // Update the vector position
-                    guard[i as usize] = args[2].clone();
-
-                    Ok(SteelVal::Void)
-                } else {
-                    stop!(TypeMismatch => "vector-set! expects an integer, found: {:?}", pos);
-                }
-            } else {
-                stop!(TypeMismatch => "vector-set! expects a vector, found: {:?}", vec);
-            }
-        })
-    }
-
-    pub fn mut_vec_get() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "mut-vector-ref takes two arguments, found: {:?}", args.len())
-            }
-
-            let vec = args[0].clone();
-            let pos = args[1].clone();
-
-            if let SteelVal::MutableVector(v) = &vec {
-                if let SteelVal::IntV(i) = pos {
-                    if i < 0 {
-                        stop!(Generic => "mut-vector-ref expects a positive integer, found: {:?}", vec);
-                    }
-
-                    let ptr = v.strong_ptr();
-
-                    let guard = &mut ptr.borrow_mut().value;
-
-                    if i as usize >= guard.len() {
-                        stop!(Generic => "index out of bounds, index given: {:?}, length of vector: {:?}", i, guard.len());
-                    }
-
-                    // Grab the value out of the vector
-                    Ok(guard[i as usize].clone())
-                } else {
-                    stop!(TypeMismatch => "mut-vector-ref expects an integer, found: {:?}", pos);
-                }
-            } else {
-                stop!(TypeMismatch => "mut-vector-ref expects a vector, found: {:?}", vec);
-            }
-        })
-    }
-
-    // TODO: This _should_ increase the size count on the maybe_memory_size on the heap
-    // since it is a growable structure, we'll need to know to rerun the GC when that size
-    // increases past a certain amount
-    pub fn mut_vec_push() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "vector-push! takes two arguments, found: {:?}", args.len())
-            }
-
-            let vec = &args[0];
-
-            if let SteelVal::MutableVector(v) = vec {
-                // TODO -> make sure this is the correct thing
-                // if vec.other_contains_self(&args[1]) {
-                //     stop!(Generic => "vector push would create a cyclical reference, which would cause a memory leak")
-                // }
-
-                // TODO: disallow cyclical references on construction
-                v.strong_ptr().borrow_mut().value.push(args[1].clone());
-                Ok(SteelVal::Void)
-            } else {
-                stop!(TypeMismatch => "vector-push! expects a vector, found: {:?}", vec);
-            }
-        })
-    }
-
-    pub fn mut_vec_append() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "vector-append! takes two arguments, found: {:?}", args.len())
-            }
-
-            let vec = args[0].clone();
-            let other_vec = args[1].clone();
-
-            if let SteelVal::MutableVector(left) = vec {
-                if let SteelVal::MutableVector(right) = other_vec {
-                    left.strong_ptr()
-                        .borrow_mut()
-                        .value
-                        .append(&mut right.strong_ptr().borrow_mut().value);
-                    Ok(SteelVal::Void)
-                } else {
-                    stop!(TypeMismatch => "vetor-append! expects a vector in the second position, found: {:?}", other_vec);
-                }
-            } else {
-                stop!(TypeMismatch => "vector-append! expects a vector in the first position, found: {:?}", vec);
-            }
-        })
-    }
-
-    pub fn vec_construct_iter<I: Iterator<Item = Result<SteelVal>>>(arg: I) -> Result<SteelVal> {
-        let res: Result<Vector<SteelVal>> = arg.collect();
-        Ok(SteelVal::VectorV(Gc::new(res?).into()))
-    }
-
-    pub fn vec_construct_iter_normal<I: Iterator<Item = SteelVal>>(arg: I) -> Result<SteelVal> {
-        Ok(SteelVal::VectorV(
-            Gc::new(arg.collect::<Vector<SteelVal>>()).into(),
-        ))
-    }
-
-    pub fn vec_append() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            let lsts: Vector<SteelVal> = unwrap_list_of_lists(args.to_vec())?
-                .into_iter()
-                .flatten()
-                .collect();
-            Ok(SteelVal::VectorV(Gc::new(lsts).into()))
-        })
-    }
-
-    pub fn vec_ref() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "vector-ref takes two arguments");
-            }
-            let mut args = args.iter();
-            match (args.next(), args.next()) {
-                (Some(vec), Some(idx)) => {
-                    if let (VectorV(vec), IntV(idx)) = (vec, idx) {
-                        if idx < &0 {
-                            stop!(TypeMismatch => "vector-ref expected a positive integer");
-                        }
-
-                        let idx: usize = *idx as usize;
-
-                        if idx < vec.len() {
-                            Ok(vec[idx].clone())
-                        } else {
-                            let e = format!("Index out of bounds - attempted to access index: {} with length: {}", idx, vec.len());
-                            stop!(Generic => e);
-                        }
-                    } else {
-                        stop!(TypeMismatch => format!("vector-ref expected a vector and a number, found: {vec} and {idx}"))
-                    }
-                }
-                _ => stop!(ArityMismatch => "vector-ref takes two arguments"),
-            }
-        })
-    }
-
-    pub fn vec_range() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "range takes two arguments");
-            }
-            let mut args = args.iter();
-            match (args.next(), args.next()) {
-                (Some(elem), Some(lst)) => {
-                    if let (IntV(lower), IntV(upper)) = (elem, lst) {
-                        Ok(SteelVal::VectorV(
-                            Gc::new(
-                                (*lower as usize..*upper as usize)
-                                    .into_iter()
-                                    .map(|x| SteelVal::IntV(x as isize))
-                                    .collect::<Vector<_>>(),
-                            )
-                            .into(),
-                        ))
-                    } else {
-                        stop!(TypeMismatch => "range expected number")
-                    }
-                }
-                _ => stop!(ArityMismatch => "range takes two arguments"),
-            }
-        })
-    }
-
-    pub fn vec_push() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "push takes two arguments");
-            }
-            let mut args = args.iter();
-            match (args.next(), args.next()) {
-                (Some(elem), Some(lst)) => {
-                    if let SteelVal::VectorV(l) = lst {
-                        let mut l = l.0.unwrap();
-                        l.push_back(elem.clone());
-                        Ok(SteelVal::VectorV(Gc::new(l).into()))
-                    } else {
-                        let mut new = Vector::new();
-                        new.push_front(elem.clone());
-                        new.push_front(lst.clone());
-                        Ok(SteelVal::VectorV(Gc::new(new).into()))
-                    }
-                }
-                _ => stop!(ArityMismatch => "push takes two arguments"),
-            }
-        })
-    }
-
-    pub fn vec_cons() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => "cons takes two arguments")
-            }
-            let mut args = args.iter();
-            match (args.next(), args.next()) {
-                (Some(elem), Some(lst)) => {
-                    if let SteelVal::VectorV(l) = lst {
-                        let mut l = l.0.unwrap();
-                        l.push_front(elem.clone());
-                        Ok(SteelVal::VectorV(Gc::new(l).into()))
-                    } else {
-                        let mut new = Vector::new();
-                        new.push_front(lst.clone());
-                        new.push_front(elem.clone());
-                        Ok(SteelVal::VectorV(Gc::new(new).into()))
-                    }
-                }
-                _ => stop!(ArityMismatch => "cons takes two arguments"),
-            }
-        })
-    }
-
-    pub fn vec_car() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "car takes one argument");
-            }
-            if let Some(first) = args.iter().next() {
-                match first {
-                    SteelVal::VectorV(e) => {
-                        let mut e = e.0.unwrap();
-                        match e.pop_front() {
-                            Some(e) => Ok(e),
-                            None => stop!(ContractViolation => "car expects a non empty list"),
-                        }
-                    }
-                    e => {
-                        stop!(TypeMismatch => "car takes a list, given: {}", e);
-                    }
-                }
-            } else {
-                stop!(ArityMismatch => "car takes one argument");
-            }
-        })
-    }
-
-    pub fn vec_cdr() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "cdr takes one argument");
-            }
-            if let Some(first) = args.iter().next() {
-                match first {
-                    SteelVal::VectorV(e) => {
-                        let mut e = e.0.unwrap();
-                        if !e.is_empty() {
-                            e.pop_front();
-                            Ok(SteelVal::VectorV(Gc::new(e).into()))
-                        } else {
-                            stop!(ContractViolation => "cdr expects a non empty list")
-                        }
-                    }
-                    e => {
-                        stop!(TypeMismatch => "cdr takes a list, given: {}", e);
-                    }
-                }
-            } else {
-                stop!(ArityMismatch => "cdr takes one argument");
-            }
-        })
-    }
-
-    pub fn list_vec_null() -> SteelVal {
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() == 1 {
-                match &args[0] {
-                    SteelVal::ListV(l) => Ok(l.is_empty().into()),
-                    SteelVal::VectorV(v) => Ok(v.is_empty().into()),
-                    _ => Ok(SteelVal::BoolV(false)),
-                }
-            } else {
-                stop!(ArityMismatch => "null? takes one argument");
-            }
-        })
-    }
-}
-
-fn unwrap_list_of_lists(args: Vec<SteelVal>) -> Result<Vec<Vector<SteelVal>>> {
-    args.iter().map(unwrap_single_list).collect()
-}
-
-fn unwrap_single_list(exp: &SteelVal) -> Result<Vector<SteelVal>> {
-    match exp {
-        SteelVal::VectorV(lst) => Ok(lst.0.unwrap()),
-        _ => stop!(TypeMismatch => "expected a list"),
-    }
-}
-
-#[cfg(test)]
-mod vector_prim_tests {
-    use super::*;
-    use crate::throw;
-    use im_rc::vector;
-
-    fn apply_function(func: SteelVal, args: Vec<SteelVal>) -> Result<SteelVal> {
-        func.func_or_else(throw!(BadSyntax => "string tests"))
-            .unwrap()(&args)
-    }
-
-    #[test]
-    fn vec_construct_test() {
-        let args = vec![SteelVal::IntV(1), SteelVal::IntV(2), SteelVal::IntV(3)];
-        let res = apply_function(VectorOperations::vec_construct(), args);
-        let expected = vector![SteelVal::IntV(1), SteelVal::IntV(2), SteelVal::IntV(3)].into();
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_append_test_good_inputs() {
-        let args = vec![
-            vector![SteelVal::IntV(1), SteelVal::IntV(2), SteelVal::IntV(3)].into(),
-            vector![SteelVal::IntV(1), SteelVal::IntV(2), SteelVal::IntV(3)].into(),
-            vector![SteelVal::IntV(1), SteelVal::IntV(2), SteelVal::IntV(3)].into(),
-        ];
-
-        let res = apply_function(VectorOperations::vec_append(), args);
-        let expected = vector![
-            SteelVal::IntV(1),
-            SteelVal::IntV(2),
-            SteelVal::IntV(3),
-            SteelVal::IntV(1),
-            SteelVal::IntV(2),
-            SteelVal::IntV(3),
-            SteelVal::IntV(1),
-            SteelVal::IntV(2),
-            SteelVal::IntV(3)
-        ]
-        .into();
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_append_test_bad_inputs() {
-        let args = vec![
-            vector![SteelVal::IntV(1), SteelVal::IntV(2), SteelVal::IntV(3)].into(),
-            SteelVal::StringV("foo".into()),
-            vector![SteelVal::IntV(1), SteelVal::IntV(2), SteelVal::IntV(3)].into(),
-        ];
-        let res = apply_function(VectorOperations::vec_append(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_range_test_arity_too_few() {
-        let args = vec![SteelVal::NumV(1.0)];
-
-        let res = apply_function(VectorOperations::vec_range(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_range_test_arity_too_many() {
-        let args = vec![SteelVal::IntV(1), SteelVal::IntV(1), SteelVal::IntV(1)];
-
-        let res = apply_function(VectorOperations::vec_range(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_range_test_bad_input() {
-        let args = vec![SteelVal::StringV("1".into()), SteelVal::NumV(1.0)];
-
-        let res = apply_function(VectorOperations::vec_range(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_range_test_normal() {
-        let args = vec![SteelVal::IntV(0), SteelVal::IntV(4)];
-
-        let res = apply_function(VectorOperations::vec_range(), args);
-        let expected = vector![
-            SteelVal::IntV(0),
-            SteelVal::IntV(1),
-            SteelVal::IntV(2),
-            SteelVal::IntV(3)
-        ]
-        .into();
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_push_arity_too_few() {
-        let args = vec![SteelVal::StringV("foo".into())];
-        let res = apply_function(VectorOperations::vec_push(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_push_arity_too_many() {
-        let args = vec![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("foo".into()),
-        ];
-        let res = apply_function(VectorOperations::vec_push(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_push_test_good_input_pair() {
-        let args = vec![
-            SteelVal::StringV("baz".into()),
-            SteelVal::StringV("bar".into()),
-        ];
-        let res = apply_function(VectorOperations::vec_push(), args);
-        let expected = vector![
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("baz".into()),
-        ]
-        .into();
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_push_test_good_input() {
-        let args = vec![
-            SteelVal::StringV("baz".into()),
-            vector![
-                SteelVal::StringV("foo".into()),
-                SteelVal::StringV("bar".into())
-            ]
-            .into(),
-        ];
-        let res = apply_function(VectorOperations::vec_push(), args);
-        let expected = vector![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("baz".into())
-        ]
-        .into();
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_cons_test_arity_too_few() {
-        let args = vec![];
-        let res = apply_function(VectorOperations::vec_cons(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_cons_test_arity_too_many() {
-        let args = vec![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("foo".into()),
-        ];
-        let res = apply_function(VectorOperations::vec_cons(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_cons_pair() {
-        let args = vec![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-        ];
-        let res = apply_function(VectorOperations::vec_cons(), args);
-        let expected = vector![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into())
-        ]
-        .into();
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_cons_elem_vector() {
-        let args = vec![
-            SteelVal::StringV("foo".into()),
-            vector![
-                SteelVal::StringV("bar".into()),
-                SteelVal::StringV("baz".into())
-            ]
-            .into(),
-        ];
-        let res = apply_function(VectorOperations::vec_cons(), args);
-        let expected = vector![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-            SteelVal::StringV("baz".into())
-        ]
-        .into();
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_car_arity_too_few() {
-        let args = vec![];
-        let res = apply_function(VectorOperations::vec_car(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_car_arity_too_many() {
-        let args = vec![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-        ];
-        let res = apply_function(VectorOperations::vec_car(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_car_bad_input() {
-        let args = vec![SteelVal::StringV("foo".into())];
-        let res = apply_function(VectorOperations::vec_car(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_car_normal_input() {
-        let args = vec![vector![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into())
-        ]
-        .into()];
-        let res = apply_function(VectorOperations::vec_car(), args);
-        let expected = SteelVal::StringV("foo".into());
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_cdr_arity_too_few() {
-        let args = vec![];
-        let res = apply_function(VectorOperations::vec_cdr(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_cdr_arity_too_many() {
-        let args = vec![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into()),
-        ];
-        let res = apply_function(VectorOperations::vec_cdr(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_cdr_bad_input() {
-        let args = vec![SteelVal::NumV(1.0)];
-        let res = apply_function(VectorOperations::vec_cdr(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn vec_cdr_normal_input() {
-        let args = vec![vector![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into())
-        ]
-        .into()];
-        let res = apply_function(VectorOperations::vec_cdr(), args);
-        let expected = vector![SteelVal::StringV("bar".into())].into();
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn vec_cdr_empty_list() {
-        let args = vec![Vector::new().into()];
-        let res = apply_function(VectorOperations::vec_cdr(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn list_vec_arity() {
-        let args = vec![];
-        let res = apply_function(VectorOperations::list_vec_null(), args);
-        assert!(res.is_err());
-    }
-
-    #[test]
-    fn list_vec_anything_but_null() {
-        let args = vec![SteelVal::StringV("foo".into())];
-        let res = apply_function(VectorOperations::list_vec_null(), args);
-        let expected = SteelVal::BoolV(false);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn list_vec_non_empty_vec() {
-        let args = vec![vector![
-            SteelVal::StringV("foo".into()),
-            SteelVal::StringV("bar".into())
-        ]
-        .into()];
-        let res = apply_function(VectorOperations::list_vec_null(), args);
-        let expected = SteelVal::BoolV(false);
-        assert_eq!(res.unwrap(), expected);
-    }
-
-    #[test]
-    fn list_vec_empty_vec() {
-        let args = vec![Vector::new().into()];
-        let res = apply_function(VectorOperations::list_vec_null(), args);
-        let expected = SteelVal::BoolV(true);
-        assert_eq!(res.unwrap(), expected);
-    }
-}
diff --git a/crates/steel-core/src/primitives/web/mod.rs b/crates/steel-core/src/primitives/web/mod.rs
deleted file mode 100644
index 0ad326568..000000000
--- a/crates/steel-core/src/primitives/web/mod.rs
+++ /dev/null
@@ -1 +0,0 @@
-pub mod requests;
diff --git a/crates/steel-core/src/primitives/web/requests.rs b/crates/steel-core/src/primitives/web/requests.rs
deleted file mode 100644
index 1b61e1e93..000000000
--- a/crates/steel-core/src/primitives/web/requests.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-use reqwest::{
-    blocking::{get, Client, RequestBuilder, Response},
-    StatusCode,
-};
-
-use crate::{
-    rvals::Custom,
-    steel_vm::{builtin::BuiltInModule, register_fn::RegisterFn},
-};
-
-use serde_json::Value;
-
-impl Custom for Client {}
-
-impl Custom for SteelRequestBuilder {}
-
-impl Custom for StatusCode {}
-
-impl Custom for reqwest::Error {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("{:?}", self)))
-    }
-}
-
-#[derive(Debug)]
-struct SteelRequestBuilder {
-    builder: RequestBuilder,
-}
-
-impl SteelRequestBuilder {
-    fn new(builder: RequestBuilder) -> Self {
-        Self { builder }
-    }
-
-    fn json(self, value: Value) -> Self {
-        self.builder.json(&value).into()
-    }
-
-    fn query(self, value: Value) -> Self {
-        self.builder.query(&value).into()
-    }
-
-    fn send(self) -> reqwest::Result<SteelResponse> {
-        self.builder.send().map(SteelResponse::from)
-    }
-
-    fn header(self, key: String, value: String) -> Self {
-        self.builder.header(key, value).into()
-    }
-
-    fn basic_auth(self, username: String, password: Option<String>) -> Self {
-        self.builder.basic_auth(username, password).into()
-    }
-
-    fn bearer_auth(self, token: String) -> Self {
-        self.builder.bearer_auth(token).into()
-    }
-}
-
-impl From<RequestBuilder> for SteelRequestBuilder {
-    fn from(value: RequestBuilder) -> Self {
-        Self::new(value)
-    }
-}
-
-impl Clone for SteelRequestBuilder {
-    fn clone(&self) -> Self {
-        Self {
-            builder: self.builder.try_clone().expect("Internal steel error: it should not be possible to pass a stream as a body, which is the only way for this clone operation to fail")
-        }
-    }
-}
-
-fn post_wrapper(client: &Client, url: String) -> SteelRequestBuilder {
-    client.post(url).into()
-}
-
-fn get_wrapper(client: &Client, url: String) -> SteelRequestBuilder {
-    client.get(url).into()
-}
-
-fn basic_get_wrapper(url: String) -> reqwest::Result<SteelResponse> {
-    get(url).map(|x| x.into())
-}
-
-fn status_code_to_int(status_code: &StatusCode) -> usize {
-    status_code.as_u16() as usize
-}
-
-struct SteelResponse {
-    response: Option<Response>,
-}
-
-impl From<Response> for SteelResponse {
-    fn from(value: Response) -> Self {
-        SteelResponse {
-            response: Some(value),
-        }
-    }
-}
-
-impl SteelResponse {
-    fn status(&self) -> Option<StatusCode> {
-        self.response.as_ref().map(|x| x.status())
-    }
-
-    fn identity(&self) -> bool {
-        true
-    }
-
-    fn json(&mut self) -> Option<reqwest::Result<Value>> {
-        self.response.take().map(|x| x.json::<Value>())
-    }
-
-    fn text(&mut self) -> Option<reqwest::Result<String>> {
-        self.response.take().map(|x| x.text())
-    }
-}
-
-impl Custom for SteelResponse {}
-
-pub fn requests_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/web/requests".to_string());
-
-    module
-        .register_fn("request/client", Client::new)
-        .register_fn("get", basic_get_wrapper)
-        .register_fn("client/post", post_wrapper)
-        .register_fn("client/get", get_wrapper)
-        .register_fn("request/json", SteelRequestBuilder::json)
-        .register_fn("request/query", SteelRequestBuilder::query)
-        .register_fn("request/send", SteelRequestBuilder::send)
-        .register_fn("request/header", SteelRequestBuilder::header)
-        .register_fn("request/basic-auth", SteelRequestBuilder::basic_auth)
-        .register_fn("request/bearer-auth", SteelRequestBuilder::bearer_auth)
-        .register_fn("response/status", SteelResponse::status)
-        .register_fn("status-code->int", status_code_to_int)
-        .register_fn("status-code/success?", StatusCode::is_success)
-        .register_fn("status-code/redirect?", StatusCode::is_redirection)
-        .register_fn("status-code/client-error?", StatusCode::is_client_error)
-        .register_fn("status-code/server-error?", StatusCode::is_server_error)
-        .register_type::<SteelRequestBuilder>("request/builder?")
-        .register_type::<StatusCode>("status-code?")
-        .register_type::<Client>("request/client?")
-        .register_fn("response?", SteelResponse::identity)
-        .register_fn("response->json", SteelResponse::json)
-        .register_fn("response->text", SteelResponse::text);
-
-    module
-}
diff --git a/crates/steel-core/src/rerrs.rs b/crates/steel-core/src/rerrs.rs
deleted file mode 100644
index 06aa43ffa..000000000
--- a/crates/steel-core/src/rerrs.rs
+++ /dev/null
@@ -1,439 +0,0 @@
-use crate::steel_vm::vm::DehydratedCallContext;
-use crate::{parser::parser::ParseError, rvals::Custom, steel_vm::vm::DehydratedStackTrace};
-use std::{convert::Infallible, fmt::Formatter};
-// use thiserror::Error;
-
-use codespan_reporting::diagnostic::{Diagnostic, Label};
-use codespan_reporting::files::SimpleFile;
-use codespan_reporting::term;
-use codespan_reporting::term::termcolor::{ColorChoice, NoColor, StandardStream};
-
-use crate::parser::span::Span;
-
-use std::fmt;
-
-#[derive(Clone, Debug, PartialEq)]
-#[repr(C)]
-struct Repr {
-    pub kind: ErrorKind,
-    pub message: String,
-    pub span: Option<Span>,
-    // pub source: Option<Rc<PathBuf>>,
-    pub stack_trace: Option<DehydratedStackTrace>,
-}
-
-impl Repr {
-    pub fn set_span(&mut self, span: Span) {
-        self.span = Some(span);
-    }
-}
-
-impl fmt::Display for Repr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "Error: {:?}: {}", self.kind, self.message)
-    }
-}
-
-impl Custom for Repr {}
-
-#[derive(Clone, Debug, PartialEq, Copy)]
-pub enum ErrorKind {
-    ArityMismatch,
-    FreeIdentifier,
-    TypeMismatch,
-    UnexpectedToken,
-    ContractViolation,
-    BadSyntax,
-    ConversionError,
-    Io,
-    Parse,
-    Infallible,
-    Generic,
-}
-
-impl ErrorKind {
-    pub fn to_error_code(&self) -> &str {
-        use ErrorKind::*;
-        match self {
-            ArityMismatch => "E01",
-            FreeIdentifier => "E02",
-            TypeMismatch => "E03",
-            UnexpectedToken => "E04",
-            ContractViolation => "E05",
-            BadSyntax => "E06",
-            ConversionError => "E07",
-            Io => "E08",
-            Parse => "E09",
-            Infallible => "E10",
-            Generic => "E11",
-        }
-    }
-}
-
-impl From<std::io::Error> for SteelErr {
-    fn from(v: std::io::Error) -> Self {
-        SteelErr::_new(v.into())
-    }
-}
-
-impl From<std::io::Error> for Repr {
-    fn from(v: std::io::Error) -> Self {
-        Repr {
-            kind: ErrorKind::Io,
-            message: v.to_string(),
-            span: None,
-            // source: None,
-            stack_trace: None,
-        }
-    }
-}
-
-impl From<Infallible> for SteelErr {
-    fn from(v: Infallible) -> Self {
-        SteelErr::_new(v.into())
-    }
-}
-
-impl From<ParseError> for SteelErr {
-    fn from(v: ParseError) -> Self {
-        SteelErr::_new(v.into())
-    }
-}
-
-impl From<Infallible> for Repr {
-    fn from(v: Infallible) -> Self {
-        Repr {
-            kind: ErrorKind::Infallible,
-            message: v.to_string(),
-            span: None,
-            // source: None,
-            stack_trace: None,
-        }
-    }
-}
-
-impl fmt::Display for ErrorKind {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{self:?}")
-    }
-}
-
-impl From<ParseError> for Repr {
-    fn from(v: ParseError) -> Self {
-        // unimplemented!()
-        let (span, _source) = match &v {
-            ParseError::Unexpected(_, source) | ParseError::UnexpectedEOF(source) => (None, source),
-            ParseError::UnexpectedChar(_, s, source) => (Some(*s), source),
-            ParseError::IncompleteString(_, s, source) => (Some(*s), source),
-            ParseError::SyntaxError(_, s, source) => (Some(*s), source),
-            ParseError::ArityMismatch(_, s, source) => (Some(*s), source),
-        };
-
-        Repr {
-            kind: ErrorKind::Parse,
-            message: v.to_string(),
-            span,
-            // source: source.clone(),
-            stack_trace: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-#[repr(C)]
-pub struct SteelErr {
-    repr: Box<Repr>,
-}
-
-impl std::error::Error for SteelErr {}
-
-impl fmt::Display for SteelErr {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.repr)
-    }
-}
-
-impl Custom for SteelErr {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("{}", self)))
-    }
-}
-
-impl SteelErr {
-    fn _new(repr: Repr) -> Self {
-        SteelErr {
-            repr: Box::new(repr),
-        }
-    }
-
-    pub fn kind(&self) -> ErrorKind {
-        self.repr.kind
-    }
-
-    pub fn set_kind(&mut self, kind: ErrorKind) {
-        self.repr.kind = kind;
-    }
-
-    pub fn prepend_message(&mut self, message: &str) {
-        self.repr.message.insert_str(0, &message)
-    }
-
-    pub fn new(kind: ErrorKind, message: String) -> Self {
-        SteelErr {
-            repr: Box::new(Repr {
-                kind,
-                message,
-                span: None,
-                // source: None,
-                stack_trace: None,
-            }),
-        }
-    }
-
-    pub fn span(&self) -> Option<Span> {
-        self.repr.span
-    }
-
-    pub fn has_span(&self) -> bool {
-        self.repr.span.is_some()
-    }
-
-    pub fn set_span(mut self, span: Span) -> Self {
-        self.repr.set_span(span);
-        self
-    }
-
-    pub fn set_span_if_none(mut self, span: Span) -> Self {
-        if self.repr.span.is_none() {
-            self.repr.set_span(span);
-        }
-
-        self
-    }
-
-    pub fn with_span(mut self, span: Span) -> Self {
-        self.repr.span = Some(span);
-        self
-    }
-
-    // pub fn with_source(mut self, source: Option<Rc<PathBuf>>) -> Self {
-    //     self.repr.source = source;
-    //     self
-    // }
-
-    pub fn with_stack_trace(mut self, stack_trace: DehydratedStackTrace) -> Self {
-        self.repr.stack_trace = Some(stack_trace);
-        self
-    }
-
-    pub fn stack_trace(&self) -> &Option<DehydratedStackTrace> {
-        &self.repr.stack_trace
-    }
-
-    pub fn push_span_context_to_stack_trace_if_trace_exists(&mut self, span: Span) {
-        if let Some(stacktrace) = &mut self.repr.stack_trace {
-            stacktrace.push(DehydratedCallContext::new(Some(span)))
-        }
-    }
-
-    pub fn emit_result(&self, file_name: &str, file_content: &str) {
-        // let opts = Opts::();
-        // let config = codespan_reporting::term::Config::default();
-        let writer = StandardStream::stderr(ColorChoice::Always);
-        let config = codespan_reporting::term::Config::default();
-
-        let file = SimpleFile::new(file_name, file_content);
-
-        let report = self.report();
-
-        term::emit(&mut writer.lock(), &config, &file, &report).unwrap(); // TODO come back
-
-        // for diagnostic in errors.iter().map(Error::report) {
-        //     term::emit(&mut writer.lock(), &config, &file, &diagnostic)?;
-        // }
-    }
-
-    pub fn emit_result_to_string(&self, file_name: &str, file_content: &str) -> String {
-        // let writer = StandardStream::from(String::new());
-        // let mut writer = String::new();
-        let mut writer = NoColor::new(Vec::<u8>::new());
-        let config = codespan_reporting::term::Config::default();
-
-        let file = SimpleFile::new(file_name, file_content);
-
-        let report = self.report();
-        term::emit(&mut writer, &config, &file, &report).unwrap(); // TODO come back
-        let output = writer.into_inner();
-        std::str::from_utf8(&output).unwrap().to_string()
-    }
-
-    fn report(&self) -> Diagnostic<()> {
-        Diagnostic::error()
-            .with_code(self.repr.kind.to_error_code())
-            .with_message(self.repr.kind.to_string())
-            .with_labels(vec![Label::primary(
-                (),
-                self.repr.span.unwrap_or(Span::new(0, 0, None)),
-            )
-            .with_message(&self.repr.message)])
-    }
-}
-
-pub fn report_warning(
-    error_code: &str,
-    file_name: &str,
-    file_content: &str,
-    message: String,
-    span: Span,
-) {
-    let writer = StandardStream::stderr(ColorChoice::Always);
-    let config = codespan_reporting::term::Config::default();
-
-    let file = SimpleFile::new(file_name, file_content);
-
-    let report = Diagnostic::warning()
-        .with_code(error_code)
-        .with_labels(vec![Label::primary((), span).with_message(message)]);
-
-    term::emit(&mut writer.lock(), &config, &file, &report).unwrap(); // TODO come back
-}
-
-pub fn report_error(
-    error_code: &str,
-    file_name: &str,
-    file_content: &str,
-    message: String,
-    span: Span,
-) {
-    let writer = StandardStream::stderr(ColorChoice::Always);
-    let config = codespan_reporting::term::Config::default();
-
-    let file = SimpleFile::new(file_name, file_content);
-
-    let report = Diagnostic::error()
-        .with_code(error_code)
-        .with_labels(vec![Label::primary((), span).with_message(message)]);
-
-    term::emit(&mut writer.lock(), &config, &file, &report).unwrap(); // TODO come back
-}
-
-pub fn report_info(
-    error_code: &str,
-    file_name: &str,
-    file_content: &str,
-    message: String,
-    span: Span,
-) {
-    let writer = StandardStream::stderr(ColorChoice::Always);
-    let config = codespan_reporting::term::Config::default();
-
-    let file = SimpleFile::new(file_name, file_content);
-
-    let report = Diagnostic::note()
-        .with_code(error_code)
-        .with_labels(vec![Label::primary((), span).with_message(message)]);
-
-    term::emit(&mut writer.lock(), &config, &file, &report).unwrap(); // TODO come back
-}
-
-pub fn back_trace(file_name: &str, file_content: &str, span: Span) {
-    let writer = StandardStream::stderr(ColorChoice::Always);
-    let config = codespan_reporting::term::Config::default();
-
-    let file = SimpleFile::new(file_name, file_content);
-
-    let report = Diagnostic::note().with_labels(vec![Label::primary((), span)]);
-
-    term::emit(&mut writer.lock(), &config, &file, &report).unwrap(); // TODO come back
-}
-
-// TODO: Abstract this to just take the writer interface optionally, otherwise just write to a string?
-pub fn back_trace_to_string(file_name: &str, file_content: &str, span: Span) -> String {
-    let mut writer = NoColor::new(Vec::<u8>::new());
-    let config = codespan_reporting::term::Config::default();
-
-    let file = SimpleFile::new(file_name, file_content);
-
-    let report = Diagnostic::note().with_labels(vec![Label::primary((), span)]);
-
-    term::emit(&mut writer, &config, &file, &report).unwrap(); // TODO come back
-
-    let output = writer.into_inner();
-
-    std::str::from_utf8(&output).unwrap().to_string()
-}
-
-#[macro_export]
-macro_rules! steelerr {
-    // ($type:ident) => {
-    //     return Err(SteelErr::new(ErrorKind::$type, None));
-    // };
-    ($type:ident => $fmt:expr, $($arg:tt)+) => {
-        Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, format!($fmt, $($arg)+)))
-    };
-    ($type:ident => $thing:expr) => {
-        Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()))
-    };
-    ($type:ident => $thing:expr; $span:expr) => {
-        Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()).with_span($span))
-    };
-    ($type:ident => $thing:expr; $span:expr; $source:expr) => {
-        Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()).with_span($span).with_source($source))
-    };
-}
-
-#[macro_export]
-macro_rules! stop {
-    // ($type:ident) => {
-    //     return Err(SteelErr::new(ErrorKind::$type, None));
-    // };
-    ($type:ident => $fmt:expr, $($arg:tt)+) => {
-        return Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, format!($fmt, $($arg)+)))
-    };
-    ($type:ident => $thing:expr) => {
-        return Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()))
-    };
-    ($type:ident => $thing:expr; $span:expr) => {
-        return Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()).with_span($span))
-    };
-    ($type:ident => $thing:expr; $span:expr; $source:expr) => {
-        return Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()).with_span($span))
-
-        // .with_source($source))
-    };
-}
-
-#[macro_export]
-macro_rules! builtin_stop {
-    // ($type:ident) => {
-    //     return Err(SteelErr::new(ErrorKind::$type, None));
-    // };
-    ($type:ident => $fmt:expr, $($arg:tt)+) => {
-        return Some(Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, format!($fmt, $($arg)+))))
-    };
-    ($type:ident => $thing:expr) => {
-        return Some(Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string())))
-    };
-    ($type:ident => $thing:expr; $span:expr) => {
-        return Some(Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()).with_span($span)))
-    };
-    ($type:ident => $thing:expr; $span:expr; $source:expr) => {
-        return Some(Err($crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()).with_span($span).with_source($source)))
-    };
-}
-
-#[macro_export]
-macro_rules! throw {
-    // ($type:ident) => {
-    //     || SteelErr::$type
-    // };
-    ($type:ident => $fmt:expr, $($arg:tt)+) => {
-        || $crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, format!($fmt, $($arg)+))
-    };
-    ($type:ident => $thing:expr) => {
-        || $crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string())
-    };
-    ($type:ident => $thing:expr; $span:expr) => {
-        || $crate::rerrs::SteelErr::new($crate::rerrs::ErrorKind::$type, ($thing).to_string()).with_span($span)
-    };
-}
diff --git a/crates/steel-core/src/rvals.rs b/crates/steel-core/src/rvals.rs
deleted file mode 100644
index 85eb48489..000000000
--- a/crates/steel-core/src/rvals.rs
+++ /dev/null
@@ -1,2129 +0,0 @@
-pub mod cycles;
-
-use crate::{
-    gc::{unsafe_erased_pointers::OpaqueReference, Gc},
-    parser::{
-        ast::{self, Atom, ExprKind},
-        parser::SyntaxObject,
-        span::Span,
-        tokens::TokenType,
-    },
-    rerrs::{ErrorKind, SteelErr},
-    steel_vm::vm::{threads::closure_into_serializable, BuiltInSignature, Continuation},
-    values::port::SteelPort,
-    values::{
-        closed::{Heap, HeapRef, MarkAndSweepContext},
-        functions::ByteCodeLambda,
-        lazy_stream::LazyStream,
-        port::SendablePort,
-        structs::SerializableUserDefinedStruct,
-        transducers::{Reducer, Transducer},
-    },
-    values::{functions::BoxedDynFunction, structs::UserDefinedStruct},
-};
-
-use std::{
-    any::{Any, TypeId},
-    cell::{Ref, RefCell, RefMut},
-    cmp::Ordering,
-    convert::TryInto,
-    fmt,
-    future::Future,
-    hash::{Hash, Hasher},
-    ops::Deref,
-    pin::Pin,
-    rc::Rc,
-    result,
-    task::Context,
-};
-
-use std::vec::IntoIter;
-
-// TODO
-#[macro_export]
-macro_rules! list {
-    () => { $crate::rvals::SteelVal::ListV(
-        im_lists::list![]
-    ) };
-
-    ( $($x:expr),* ) => {{
-        $crate::rvals::SteelVal::ListV(vec![$(
-            $crate::rvals::IntoSteelVal::into_steelval($x).unwrap()
-        ), *].into())
-    }};
-
-    ( $($x:expr ,)* ) => {{
-        $crate::rvals::SteelVal::ListV(im_lists::list![$(
-            $crate::rvals::IntoSteelVal::into_steelval($x).unwrap()
-        )*])
-    }};
-}
-
-use SteelVal::*;
-
-use im_rc::{HashMap, Vector};
-
-use futures_task::noop_waker_ref;
-use futures_util::future::Shared;
-use futures_util::FutureExt;
-
-use crate::values::lists::List;
-use num::ToPrimitive;
-use steel_parser::tokens::MaybeBigInt;
-
-use self::cycles::{CycleDetector, IterativeDropHandler};
-
-pub type RcRefSteelVal = Rc<RefCell<SteelVal>>;
-pub fn new_rc_ref_cell(x: SteelVal) -> RcRefSteelVal {
-    Rc::new(RefCell::new(x))
-}
-
-pub type Result<T> = result::Result<T, SteelErr>;
-pub type FunctionSignature = fn(&[SteelVal]) -> Result<SteelVal>;
-pub type MutFunctionSignature = fn(&mut [SteelVal]) -> Result<SteelVal>;
-pub type BoxedFunctionSignature = Rc<Box<dyn Fn(&[SteelVal]) -> Result<SteelVal>>>;
-pub type BoxedAsyncFunctionSignature = Box<Rc<dyn Fn(&[SteelVal]) -> Result<FutureResult>>>;
-pub type AsyncSignature = fn(&[SteelVal]) -> FutureResult;
-
-pub type BoxedFutureResult = Pin<Box<dyn Future<Output = Result<SteelVal>>>>;
-
-#[derive(Clone)]
-pub struct FutureResult(Shared<BoxedFutureResult>);
-
-impl FutureResult {
-    pub fn new(fut: BoxedFutureResult) -> Self {
-        // FutureResult()
-        FutureResult(fut.shared())
-    }
-
-    pub fn into_shared(self) -> Shared<BoxedFutureResult> {
-        self.0
-    }
-}
-
-// This is an attempt to one off poll a future
-// This should enable us to use embedded async functions
-// Will require using call/cc w/ a thread queue in steel, however it should be possible
-pub(crate) fn poll_future(mut fut: Shared<BoxedFutureResult>) -> Option<Result<SteelVal>> {
-    // If the future has already been awaited (by somebody) get that value instead
-    if let Some(output) = fut.peek() {
-        return Some(output.clone());
-    }
-
-    // Otherwise, go ahead and poll the value to see if its ready
-    // The context is going to exist exclusively in Steel, hidden behind an `await`
-    let waker = noop_waker_ref();
-    let context = &mut Context::from_waker(waker);
-
-    // Polling requires a pinned future - TODO make sure this is correct
-    let mut_fut = Pin::new(&mut fut);
-
-    match Future::poll(mut_fut, context) {
-        std::task::Poll::Ready(r) => Some(r),
-        std::task::Poll::Pending => None,
-    }
-}
-
-/// Attempt to cast this custom type down to the underlying type
-pub fn as_underlying_type<T: 'static>(value: &dyn CustomType) -> Option<&T> {
-    value.as_any_ref().downcast_ref::<T>()
-}
-
-pub trait Custom: private::Sealed {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        None
-    }
-
-    fn into_serializable_steelval(&mut self) -> Option<SerializableSteelVal> {
-        None
-    }
-
-    fn as_iterator(&self) -> Option<Box<dyn Iterator<Item = SteelVal>>> {
-        None
-    }
-
-    fn gc_drop_mut(&mut self, _drop_handler: &mut IterativeDropHandler) {}
-
-    fn gc_visit_children(&self, _context: &mut MarkAndSweepContext) {}
-
-    fn visit_equality(&self, _visitor: &mut cycles::EqualityVisitor) {}
-
-    fn equality_hint(&self, _other: &dyn CustomType) -> bool {
-        true
-    }
-}
-
-pub trait CustomType {
-    // fn box_clone(&self) -> Box<dyn CustomType>;
-    // fn as_any(&self) -> Box<dyn Any>;
-    fn as_any_ref(&self) -> &dyn Any;
-    fn as_any_ref_mut(&mut self) -> &mut dyn Any;
-    fn name(&self) -> &str {
-        std::any::type_name::<Self>()
-    }
-    fn inner_type_id(&self) -> TypeId;
-    // fn new_steel_val(&self) -> SteelVal;
-    fn display(&self) -> std::result::Result<String, std::fmt::Error> {
-        Ok(format!("#<{}>", self.name().to_string()))
-    }
-
-    fn as_serializable_steelval(&mut self) -> Option<SerializableSteelVal> {
-        None
-    }
-
-    // Implement visit for anything that holds steel values
-    fn drop_mut(&mut self, _drop_handler: &mut IterativeDropHandler) {}
-
-    fn visit_children(&self, _context: &mut MarkAndSweepContext) {}
-
-    fn visit_children_for_equality(&self, _visitor: &mut cycles::EqualityVisitor) {}
-
-    fn check_equality_hint(&self, _other: &dyn CustomType) -> bool {
-        true
-    }
-}
-
-impl<T: Custom + 'static> CustomType for T {
-    fn as_any_ref(&self) -> &dyn Any {
-        self as &dyn Any
-    }
-    fn as_any_ref_mut(&mut self) -> &mut dyn Any {
-        self as &mut dyn Any
-    }
-    fn inner_type_id(&self) -> TypeId {
-        std::any::TypeId::of::<Self>()
-    }
-    fn display(&self) -> std::result::Result<String, std::fmt::Error> {
-        if let Some(formatted) = self.fmt() {
-            formatted
-        } else {
-            Ok(format!("#<{}>", self.name().to_string()))
-        }
-    }
-
-    fn as_serializable_steelval(&mut self) -> Option<SerializableSteelVal> {
-        self.into_serializable_steelval()
-    }
-
-    fn drop_mut(&mut self, drop_handler: &mut IterativeDropHandler) {
-        self.gc_drop_mut(drop_handler)
-    }
-
-    fn visit_children(&self, context: &mut MarkAndSweepContext) {
-        self.gc_visit_children(context)
-    }
-
-    // TODO: Equality visitor
-    fn visit_children_for_equality(&self, visitor: &mut cycles::EqualityVisitor) {
-        self.visit_equality(visitor)
-    }
-
-    fn check_equality_hint(&self, other: &dyn CustomType) -> bool {
-        self.equality_hint(other)
-    }
-}
-
-impl<T: CustomType + 'static> IntoSteelVal for T {
-    fn into_steelval(self) -> Result<SteelVal> {
-        // Ok(self.new_steel_val())
-        Ok(SteelVal::Custom(Gc::new(RefCell::new(Box::new(self)))))
-    }
-}
-
-pub trait IntoSerializableSteelVal {
-    fn into_serializable_steelval(val: &SteelVal) -> Result<SerializableSteelVal>;
-}
-
-impl<T: CustomType + Clone + Send + Sync + 'static> IntoSerializableSteelVal for T {
-    fn into_serializable_steelval(val: &SteelVal) -> Result<SerializableSteelVal> {
-        if let SteelVal::Custom(v) = val {
-            // let left_type = v.borrow().as_any_ref();
-            // TODO: @Matt - dylibs cause issues here, as the underlying type ids are different
-            // across workspaces and builds
-            let left = v.borrow().as_any_ref().downcast_ref::<T>().cloned();
-            let _lifted = left.ok_or_else(|| {
-                let error_message = format!(
-                    "Type Mismatch: Type of SteelVal: {:?}, did not match the given type: {}",
-                    val,
-                    std::any::type_name::<Self>()
-                );
-                SteelErr::new(ErrorKind::ConversionError, error_message)
-            });
-
-            todo!()
-        } else {
-            let error_message = format!(
-                "Type Mismatch: Type of SteelVal: {:?} did not match the given type, expecting opaque struct: {}",
-                val,
-                std::any::type_name::<Self>()
-            );
-
-            Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-        }
-    }
-}
-
-// TODO: Marshalling out of the type could also try to yoink from a native steel struct.
-// If possible, we can try to line the constructor up with the fields
-impl<T: CustomType + Clone + 'static> FromSteelVal for T {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        if let SteelVal::Custom(v) = val {
-            // let left_type = v.borrow().as_any_ref();
-            // TODO: @Matt - dylibs cause issues here, as the underlying type ids are different
-            // across workspaces and builds
-            let left = v.borrow().as_any_ref().downcast_ref::<T>().cloned();
-            left.ok_or_else(|| {
-                let error_message = format!(
-                    "Type Mismatch: Type of SteelVal: {:?}, did not match the given type: {}",
-                    val,
-                    std::any::type_name::<Self>()
-                );
-                SteelErr::new(ErrorKind::ConversionError, error_message)
-            })
-        } else {
-            let error_message = format!(
-                "Type Mismatch: Type of SteelVal: {:?} did not match the given type, expecting opaque struct: {}",
-                val,
-                std::any::type_name::<Self>()
-            );
-
-            Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-        }
-    }
-}
-
-/// The entry point for turning values into SteelVals
-/// The is implemented for most primitives and collections
-/// You can also manually implement this for any type, or can optionally
-/// get this implementation for a custom struct by using the custom
-/// steel derive.
-pub trait IntoSteelVal: Sized {
-    fn into_steelval(self) -> Result<SteelVal>;
-}
-
-/// The exit point for turning SteelVals into outside world values
-/// This is implement for most primitives and collections
-/// You can also manually implement this for any type, or can optionally
-/// get this implementation for a custom struct by using the custom
-/// steel derive.
-pub trait FromSteelVal: Sized {
-    fn from_steelval(val: &SteelVal) -> Result<Self>;
-}
-
-pub trait PrimitiveAsRef<'a>: Sized {
-    fn primitive_as_ref(val: &'a SteelVal) -> Result<Self>;
-}
-
-pub struct RestArgsIter<'a, T>(
-    pub std::iter::Map<std::slice::Iter<'a, SteelVal>, fn(&'a SteelVal) -> Result<T>>,
-);
-
-impl<'a, T: PrimitiveAsRef<'a> + 'a> RestArgsIter<'a, T> {
-    pub fn new(
-        args: std::iter::Map<std::slice::Iter<'a, SteelVal>, fn(&'a SteelVal) -> Result<T>>,
-    ) -> Self {
-        RestArgsIter(args)
-    }
-
-    pub fn from_slice(args: &'a [SteelVal]) -> Result<Self> {
-        Ok(RestArgsIter(args.iter().map(T::primitive_as_ref)))
-    }
-}
-
-impl<'a, T> Iterator for RestArgsIter<'a, T> {
-    type Item = Result<T>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next()
-    }
-}
-
-pub struct RestArgs<T: FromSteelVal>(pub Vec<T>);
-
-impl<T: FromSteelVal> RestArgs<T> {
-    pub fn new(args: Vec<T>) -> Self {
-        RestArgs(args)
-    }
-
-    pub fn from_slice(args: &[SteelVal]) -> Result<Self> {
-        args.iter()
-            .map(|x| T::from_steelval(x))
-            .collect::<Result<Vec<_>>>()
-            .map(RestArgs)
-    }
-}
-
-impl<T: FromSteelVal> std::ops::Deref for RestArgs<T> {
-    type Target = [T];
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-mod private {
-
-    use std::any::Any;
-
-    pub trait Sealed {}
-
-    impl<T: Any> Sealed for T {}
-}
-
-// pub trait DowncastSteelval: private::Sealed {
-//     type Output;
-//     fn downcast(&self) -> Result<&Self::Output>;
-// }
-
-// impl DowncastSteelval for SteelVal {
-//     type Output = Box<dyn CustomType>;
-
-//     fn downcast(&self) -> Result<&Self::Output> {
-//         todo!()
-//     }
-// }
-
-pub enum SRef<'b, T: ?Sized + 'b> {
-    Temporary(&'b T),
-    Owned(Ref<'b, T>),
-    // ExistingBorrow(S),
-}
-
-impl<'b, T: ?Sized + 'b> Deref for SRef<'b, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &T {
-        match self {
-            SRef::Temporary(inner) => inner,
-            SRef::Owned(inner) => inner,
-            // SRef::ExistingBorrow(inner) =>
-        }
-    }
-}
-
-// Can you take a steel val and execute operations on it by reference
-pub trait AsRefSteelVal: Sized {
-    type Nursery: Default;
-
-    fn as_ref<'b, 'a: 'b>(
-        val: &'a SteelVal,
-        _nursery: &'a mut Self::Nursery,
-    ) -> Result<SRef<'b, Self>>;
-}
-
-pub trait AsSlice<T> {
-    fn as_slice_repr(&self) -> &[T];
-}
-
-impl<T> AsSlice<T> for Vec<T> {
-    fn as_slice_repr(&self) -> &[T] {
-        self.as_slice()
-    }
-}
-
-// TODO: Try to incorporate these all into one trait if possible
-pub trait AsRefSteelValFromUnsized<T>: Sized {
-    type Output: AsSlice<T>;
-
-    fn as_ref_from_unsized(val: &SteelVal) -> Result<Self::Output>;
-}
-
-pub trait AsRefMutSteelVal: Sized {
-    fn as_mut_ref<'b, 'a: 'b>(val: &'a SteelVal) -> Result<RefMut<'b, Self>>;
-}
-
-pub trait AsRefMutSteelValFromRef: Sized {
-    fn as_mut_ref_from_ref<'a>(val: &'a SteelVal) -> crate::rvals::Result<&'a mut Self>;
-}
-
-pub trait AsRefSteelValFromRef: Sized {
-    fn as_ref_from_ref<'a>(val: &'a SteelVal) -> crate::rvals::Result<&'a Self>;
-}
-
-impl AsRefSteelVal for List<SteelVal> {
-    type Nursery = ();
-
-    fn as_ref<'b, 'a: 'b>(val: &'a SteelVal, _nursery: &mut ()) -> Result<SRef<'b, Self>> {
-        if let SteelVal::ListV(l) = val {
-            Ok(SRef::Temporary(l))
-        } else {
-            stop!(TypeMismatch => "Value cannot be referenced as a list")
-        }
-    }
-}
-
-impl AsRefSteelVal for UserDefinedStruct {
-    type Nursery = ();
-
-    fn as_ref<'b, 'a: 'b>(val: &'a SteelVal, _nursery: &mut ()) -> Result<SRef<'b, Self>> {
-        if let SteelVal::CustomStruct(l) = val {
-            Ok(SRef::Temporary(l))
-        } else {
-            stop!(TypeMismatch => "Value cannot be referenced as a list")
-        }
-    }
-}
-
-// impl AsRefSteelVal for FunctionSignature {
-//     fn as_ref<'b, 'a: 'b>(val: &'a SteelVal) -> Result<SRef<'b, Self>> {
-//         if let SteelVal::FuncV(f) = val {
-//             Ok(SRef::Temporary(f))
-//         } else {
-//             stop!(TypeMismatch => "Value cannot be referenced as a primitive function!")
-//         }
-//     }
-// }
-
-impl<T: CustomType + 'static> AsRefSteelVal for T {
-    type Nursery = ();
-
-    fn as_ref<'b, 'a: 'b>(
-        val: &'a SteelVal,
-        _nursery: &mut Self::Nursery,
-    ) -> Result<SRef<'b, Self>> {
-        // todo!()
-
-        if let SteelVal::Custom(v) = val {
-            let res = Ref::map(v.borrow(), |x| x.as_any_ref());
-
-            if res.is::<T>() {
-                Ok(SRef::Owned(Ref::map(res, |x| {
-                    x.downcast_ref::<T>().unwrap()
-                })))
-            } else {
-                let error_message = format!(
-                    "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                    val,
-                    std::any::type_name::<Self>()
-                );
-                Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-            }
-            // res
-        } else {
-            let error_message = format!(
-                "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                val,
-                std::any::type_name::<Self>()
-            );
-
-            Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-        }
-    }
-}
-
-impl<T: CustomType + 'static> AsRefMutSteelVal for T {
-    fn as_mut_ref<'b, 'a: 'b>(val: &'a SteelVal) -> Result<RefMut<'b, Self>> {
-        // todo!()
-
-        if let SteelVal::Custom(v) = val {
-            let res = RefMut::map(v.borrow_mut(), |x| x.as_any_ref_mut());
-
-            if res.is::<T>() {
-                Ok(RefMut::map(res, |x| x.downcast_mut::<T>().unwrap()))
-            } else {
-                let error_message = format!(
-                    "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                    val,
-                    std::any::type_name::<Self>()
-                );
-                Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-            }
-            // res
-        } else {
-            let error_message = format!(
-                "Type Mismatch: Type of SteelVal: {} did not match the given type: {}",
-                val,
-                std::any::type_name::<Self>()
-            );
-
-            Err(SteelErr::new(ErrorKind::ConversionError, error_message))
-        }
-    }
-}
-
-impl ast::TryFromSteelValVisitorForExprKind {
-    pub fn visit_syntax_object(&mut self, value: &Syntax) -> Result<ExprKind> {
-        let span = value.span;
-        // let source = self.source.clone();
-        match &value.syntax {
-            // Mutual recursion case
-            SyntaxObject(s) => self.visit_syntax_object(s),
-            BoolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::BooleanLiteral(*x),
-                span,
-            )))),
-            NumV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::NumberLiteral(*x),
-                span,
-            )))),
-            IntV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::IntegerLiteral(MaybeBigInt::Small(*x)),
-                span,
-            )))),
-            VectorV(lst) => {
-                let items: Result<Vec<ExprKind>> = lst.iter().map(|x| self.visit(x)).collect();
-                Ok(ExprKind::List(crate::parser::ast::List::new(items?)))
-            }
-            StringV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::StringLiteral(x.to_string()),
-                span,
-            )))),
-            SymbolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::Identifier(x.as_str().into()),
-                span,
-            )))),
-
-            ListV(l) => {
-                // Rooted - things operate as normal
-                if self.qq_depth == 0 {
-                    let maybe_special_form = l.first().and_then(|x| {
-                        x.as_symbol()
-                            .or_else(|| x.as_syntax_object().and_then(|x| x.syntax.as_symbol()))
-                    });
-
-                    match maybe_special_form {
-                        Some(x) if x.as_str() == "quote" => {
-                            if self.quoted {
-                                let items: std::result::Result<Vec<ExprKind>, _> =
-                                    l.iter().map(|x| self.visit(x)).collect();
-
-                                return Ok(ExprKind::List(ast::List::new(items?)));
-                            }
-
-                            self.quoted = true;
-
-                            let return_value = l
-                                .into_iter()
-                                .map(|x| self.visit(x))
-                                .collect::<std::result::Result<Vec<_>, _>>()?
-                                .try_into()?;
-
-                            self.quoted = false;
-
-                            return Ok(return_value);
-                        } // "quasiquote" => {
-                        //     self.qq_depth += 1;
-                        // }
-                        // None => {
-                        // return Ok(ExprKind::empty());
-                        // }
-                        _ => {}
-                    }
-                }
-
-                Ok(l.into_iter()
-                    .map(|x| self.visit(x))
-                    .collect::<std::result::Result<Vec<_>, _>>()?
-                    .try_into()?)
-            }
-
-            CharV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::CharacterLiteral(*x),
-                span,
-            )))),
-            _ => stop!(ConversionError => "unable to convert {:?} to expression", &value.syntax),
-        }
-    }
-}
-
-// TODO: Replace this with RawSyntaxObject<SteelVal>
-
-#[derive(Debug, Clone)]
-pub struct Syntax {
-    pub(crate) raw: Option<SteelVal>,
-    pub(crate) syntax: SteelVal,
-    span: Span,
-}
-
-impl Syntax {
-    pub fn new(syntax: SteelVal, span: Span) -> Syntax {
-        // dbg!(&syntax);
-
-        Self {
-            raw: None,
-            syntax,
-            span,
-        }
-    }
-
-    pub fn proto(raw: SteelVal, syntax: SteelVal, span: Span) -> Syntax {
-        Self {
-            raw: Some(raw),
-            syntax,
-            span,
-        }
-    }
-
-    pub fn syntax_e(&self) -> SteelVal {
-        self.syntax.clone()
-    }
-
-    pub fn new_with_source(syntax: SteelVal, span: Span) -> Syntax {
-        Self {
-            raw: None,
-            syntax,
-            span,
-        }
-    }
-
-    pub fn syntax_loc(&self) -> Span {
-        self.span
-    }
-
-    pub fn syntax_datum(&self) -> SteelVal {
-        self.raw.clone().unwrap()
-    }
-
-    pub(crate) fn steelval_to_exprkind(value: &SteelVal) -> Result<ExprKind> {
-        match value {
-            // Mutual recursion case
-            SyntaxObject(s) => s.to_exprkind(),
-            BoolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                TokenType::BooleanLiteral(*x),
-            )))),
-            NumV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                TokenType::NumberLiteral(*x),
-            )))),
-            IntV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                TokenType::IntegerLiteral(MaybeBigInt::Small(*x)),
-            )))),
-            VectorV(lst) => {
-                let items: Result<Vec<ExprKind>> =
-                    lst.iter().map(Self::steelval_to_exprkind).collect();
-                Ok(ExprKind::List(crate::parser::ast::List::new(items?)))
-            }
-            StringV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                TokenType::StringLiteral(x.to_string()),
-            )))),
-            // LambdaV(_) => Err("Can't convert from Lambda to expression!"),
-            // MacroV(_) => Err("Can't convert from Macro to expression!"),
-            SymbolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                TokenType::Identifier(x.as_str().into()),
-            )))),
-            ListV(l) => {
-                let items: Result<Vec<ExprKind>> =
-                    l.iter().map(Self::steelval_to_exprkind).collect();
-
-                Ok(ExprKind::List(crate::parser::ast::List::new(items?)))
-            }
-            CharV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::default(
-                TokenType::CharacterLiteral(*x),
-            )))),
-            _ => stop!(ConversionError => "unable to convert {:?} to expression", value),
-        }
-    }
-
-    // TODO: match on self.syntax. If its itself a syntax object, then just recur on that until we bottom out
-    // Otherwise, reconstruct the ExprKind and replace the span and source information into the representation
-    pub fn to_exprkind(&self) -> Result<ExprKind> {
-        let span = self.span;
-        // let source = self.source.clone();
-        match &self.syntax {
-            // Mutual recursion case
-            SyntaxObject(s) => s.to_exprkind(),
-            BoolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::BooleanLiteral(*x),
-                span,
-            )))),
-            NumV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::NumberLiteral(*x),
-                span,
-            )))),
-            IntV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::IntegerLiteral(MaybeBigInt::Small(*x)),
-                span,
-            )))),
-            VectorV(lst) => {
-                let items: Result<Vec<ExprKind>> =
-                    lst.iter().map(Self::steelval_to_exprkind).collect();
-                Ok(ExprKind::List(crate::parser::ast::List::new(items?)))
-            }
-            StringV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::StringLiteral(x.to_string()),
-                span,
-            )))),
-            // LambdaV(_) => Err("Can't convert from Lambda to expression!"),
-            // MacroV(_) => Err("Can't convert from Macro to expression!"),
-            SymbolV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::Identifier(x.as_str().into()),
-                span,
-            )))),
-            ListV(l) => {
-                let items: Result<Vec<ExprKind>> =
-                    l.iter().map(Self::steelval_to_exprkind).collect();
-
-                Ok(ExprKind::List(crate::parser::ast::List::new(items?)))
-            }
-            CharV(x) => Ok(ExprKind::Atom(Atom::new(SyntaxObject::new(
-                TokenType::CharacterLiteral(*x),
-                span,
-            )))),
-            _ => stop!(ConversionError => "unable to convert {:?} to expression", &self.syntax),
-        }
-    }
-}
-
-impl IntoSteelVal for Syntax {
-    fn into_steelval(self) -> Result<SteelVal> {
-        Ok(SteelVal::SyntaxObject(Gc::new(self)))
-    }
-}
-
-impl AsRefSteelVal for Syntax {
-    type Nursery = ();
-
-    fn as_ref<'b, 'a: 'b>(
-        val: &'a SteelVal,
-        _nursery: &'a mut Self::Nursery,
-    ) -> Result<SRef<'b, Self>> {
-        if let SteelVal::SyntaxObject(s) = val {
-            Ok(SRef::Temporary(s))
-        } else {
-            stop!(TypeMismatch => "Value cannot be referenced as a syntax object")
-        }
-    }
-}
-
-impl From<Syntax> for SteelVal {
-    fn from(val: Syntax) -> Self {
-        SteelVal::SyntaxObject(Gc::new(val))
-    }
-}
-
-// TODO:
-// This needs to be a method on the runtime: in order to properly support
-// threads
-// Tracking issue here: https://github.com/mattwparas/steel/issues/98
-
-// Values which can be sent to another thread.
-// If it cannot be sent to another thread, then we'll error out on conversion.
-// TODO: Add boxed dyn functions to this.
-// #[derive(PartialEq)]
-pub enum SerializableSteelVal {
-    Closure(crate::values::functions::SerializedLambda),
-    BoolV(bool),
-    NumV(f64),
-    IntV(isize),
-    CharV(char),
-    Void,
-    StringV(String),
-    FuncV(FunctionSignature),
-    MutFunc(MutFunctionSignature),
-    HashMapV(Vec<(SerializableSteelVal, SerializableSteelVal)>),
-    ListV(Vec<SerializableSteelVal>),
-    VectorV(Vec<SerializableSteelVal>),
-    BoxedDynFunction(BoxedDynFunction),
-    BuiltIn(BuiltInSignature),
-    SymbolV(String),
-    Custom(Box<dyn CustomType + Send>),
-    CustomStruct(SerializableUserDefinedStruct),
-    // Attempt to reuse the storage if possible
-    HeapAllocated(usize),
-
-    Port(SendablePort),
-}
-
-pub enum SerializedHeapRef {
-    Serialized(Option<SerializableSteelVal>),
-    Closed(HeapRef<SteelVal>),
-}
-
-pub struct HeapSerializer<'a> {
-    pub heap: &'a mut Heap,
-    pub fake_heap: &'a mut std::collections::HashMap<usize, SerializedHeapRef>,
-    // After the conversion, we go back through, and patch the values from the fake heap
-    // in to each of the values listed here - otherwise, we'll miss cycles
-    pub values_to_fill_in: &'a mut std::collections::HashMap<usize, HeapRef<SteelVal>>,
-
-    // Cache the functions that get built
-    pub built_functions: &'a mut std::collections::HashMap<usize, Gc<ByteCodeLambda>>,
-}
-
-// Once crossed over the line, convert BACK into a SteelVal
-// This should be infallible.
-pub fn from_serializable_value(ctx: &mut HeapSerializer, val: SerializableSteelVal) -> SteelVal {
-    match val {
-        SerializableSteelVal::Closure(c) => {
-            if c.captures.is_empty() {
-                if let Some(already_made) = ctx.built_functions.get(&c.id) {
-                    SteelVal::Closure(already_made.clone())
-                } else {
-                    let id = c.id;
-                    let value = Gc::new(ByteCodeLambda::from_serialized(ctx, c));
-
-                    // Save those as well
-                    // Probably need to just do this for all
-                    ctx.built_functions.insert(id, value.clone());
-                    SteelVal::Closure(value)
-                }
-            } else {
-                SteelVal::Closure(Gc::new(ByteCodeLambda::from_serialized(ctx, c)))
-            }
-        }
-        SerializableSteelVal::BoolV(b) => SteelVal::BoolV(b),
-        SerializableSteelVal::NumV(n) => SteelVal::NumV(n),
-        SerializableSteelVal::IntV(i) => SteelVal::IntV(i),
-        SerializableSteelVal::CharV(c) => SteelVal::CharV(c),
-        SerializableSteelVal::Void => SteelVal::Void,
-        SerializableSteelVal::StringV(s) => SteelVal::StringV(s.into()),
-        SerializableSteelVal::FuncV(f) => SteelVal::FuncV(f),
-        SerializableSteelVal::MutFunc(f) => SteelVal::MutFunc(f),
-        SerializableSteelVal::HashMapV(h) => SteelVal::HashMapV(
-            Gc::new(
-                h.into_iter()
-                    .map(|(k, v)| {
-                        (
-                            from_serializable_value(ctx, k),
-                            from_serializable_value(ctx, v),
-                        )
-                    })
-                    .collect::<HashMap<_, _>>(),
-            )
-            .into(),
-        ),
-        SerializableSteelVal::ListV(v) => SteelVal::ListV(
-            v.into_iter()
-                .map(|x| from_serializable_value(ctx, x))
-                .collect(),
-        ),
-        SerializableSteelVal::VectorV(v) => SteelVal::VectorV(SteelVector(Gc::new(
-            v.into_iter()
-                .map(|x| from_serializable_value(ctx, x))
-                .collect(),
-        ))),
-        SerializableSteelVal::BoxedDynFunction(f) => SteelVal::BoxedFunction(Rc::new(f)),
-        SerializableSteelVal::BuiltIn(f) => SteelVal::BuiltIn(f),
-        SerializableSteelVal::SymbolV(s) => SteelVal::SymbolV(s.into()),
-        SerializableSteelVal::Custom(b) => SteelVal::Custom(Gc::new(RefCell::new(b))),
-        SerializableSteelVal::CustomStruct(s) => {
-            SteelVal::CustomStruct(Gc::new(UserDefinedStruct {
-                fields: s
-                    .fields
-                    .into_iter()
-                    .map(|x| from_serializable_value(ctx, x))
-                    .collect(),
-                type_descriptor: s.type_descriptor,
-            }))
-        }
-        SerializableSteelVal::Port(p) => SteelVal::PortV(SteelPort::from_sendable_port(p)),
-        SerializableSteelVal::HeapAllocated(v) => {
-            // todo!()
-
-            if let Some(mut guard) = ctx.fake_heap.get_mut(&v) {
-                match &mut guard {
-                    SerializedHeapRef::Serialized(value) => {
-                        let value = std::mem::take(value);
-
-                        if let Some(value) = value {
-                            let value = from_serializable_value(ctx, value);
-                            let allocation = ctx.heap.allocate_without_collection(value);
-
-                            ctx.fake_heap
-                                .insert(v, SerializedHeapRef::Closed(allocation.clone()));
-
-                            SteelVal::HeapAllocated(allocation)
-                        } else {
-                            // println!("If we're getting here - it means the value from the heap has already
-                            // been converting. if so, we should do something...");
-
-                            let fake_allocation =
-                                ctx.heap.allocate_without_collection(SteelVal::Void);
-
-                            ctx.values_to_fill_in.insert(v, fake_allocation.clone());
-
-                            SteelVal::HeapAllocated(fake_allocation)
-                        }
-                    }
-
-                    SerializedHeapRef::Closed(c) => SteelVal::HeapAllocated(c.clone()),
-                }
-            } else {
-                // Shouldn't silently fail here, but we will... for now
-
-                let allocation = ctx.heap.allocate_without_collection(SteelVal::Void);
-
-                ctx.fake_heap
-                    .insert(v, SerializedHeapRef::Closed(allocation.clone()));
-
-                SteelVal::HeapAllocated(allocation)
-            }
-        }
-    }
-}
-
-// The serializable value needs to refer to the original heap -
-// that way can reference the original stuff easily.
-
-// TODO: Use the cycle detector instead
-pub fn into_serializable_value(
-    val: SteelVal,
-    serialized_heap: &mut std::collections::HashMap<usize, SerializableSteelVal>,
-    visited: &mut std::collections::HashSet<usize>,
-) -> Result<SerializableSteelVal> {
-    // dbg!(&serialized_heap);
-
-    match val {
-        SteelVal::Closure(c) => closure_into_serializable(&c, serialized_heap, visited)
-            .map(SerializableSteelVal::Closure),
-        SteelVal::BoolV(b) => Ok(SerializableSteelVal::BoolV(b)),
-        SteelVal::NumV(n) => Ok(SerializableSteelVal::NumV(n)),
-        SteelVal::IntV(n) => Ok(SerializableSteelVal::IntV(n)),
-        SteelVal::CharV(c) => Ok(SerializableSteelVal::CharV(c)),
-        SteelVal::Void => Ok(SerializableSteelVal::Void),
-        SteelVal::StringV(s) => Ok(SerializableSteelVal::StringV(s.to_string())),
-        SteelVal::FuncV(f) => Ok(SerializableSteelVal::FuncV(f)),
-        SteelVal::ListV(l) => Ok(SerializableSteelVal::ListV(
-            l.into_iter()
-                .map(|x| into_serializable_value(x, serialized_heap, visited))
-                .collect::<Result<_>>()?,
-        )),
-        SteelVal::BoxedFunction(f) => Ok(SerializableSteelVal::BoxedDynFunction((*f).clone())),
-        SteelVal::BuiltIn(f) => Ok(SerializableSteelVal::BuiltIn(f)),
-        SteelVal::SymbolV(s) => Ok(SerializableSteelVal::SymbolV(s.to_string())),
-        SteelVal::MutFunc(f) => Ok(SerializableSteelVal::MutFunc(f)),
-        SteelVal::HashMapV(v) => Ok(SerializableSteelVal::HashMapV(
-            v.0.unwrap()
-                .into_iter()
-                .map(|(k, v)| {
-                    let kprime = into_serializable_value(k, serialized_heap, visited)?;
-                    let vprime = into_serializable_value(v, serialized_heap, visited)?;
-
-                    Ok((kprime, vprime))
-                })
-                .collect::<Result<_>>()?,
-        )),
-
-        SteelVal::Custom(c) => {
-            if let Some(output) = c.borrow_mut().as_serializable_steelval() {
-                Ok(output)
-            } else {
-                stop!(Generic => "Custom type not allowed to be moved across threads!")
-            }
-        }
-
-        SteelVal::CustomStruct(s) => Ok(SerializableSteelVal::CustomStruct(
-            SerializableUserDefinedStruct {
-                fields: s
-                    .fields
-                    .iter()
-                    .cloned()
-                    .map(|x| into_serializable_value(x, serialized_heap, visited))
-                    .collect::<Result<Vec<_>>>()?,
-                type_descriptor: s.type_descriptor,
-            },
-        )),
-
-        SteelVal::PortV(p) => SendablePort::from_port(p).map(SerializableSteelVal::Port),
-
-        // If there is a cycle, this could cause problems?
-        SteelVal::HeapAllocated(h) => {
-            // We should pick it up on the way back the recursion
-            if visited.contains(&h.as_ptr_usize())
-                && !serialized_heap.contains_key(&h.as_ptr_usize())
-            {
-                // println!("Already visited: {}", h.as_ptr_usize());
-
-                Ok(SerializableSteelVal::HeapAllocated(h.as_ptr_usize()))
-            } else {
-                visited.insert(h.as_ptr_usize());
-
-                if serialized_heap.contains_key(&h.as_ptr_usize()) {
-                    // println!("Already exists in map: {}", h.as_ptr_usize());
-
-                    Ok(SerializableSteelVal::HeapAllocated(h.as_ptr_usize()))
-                } else {
-                    // println!("Trying to insert: {} @ {}", h.get(), h.as_ptr_usize());
-
-                    let value = into_serializable_value(h.get(), serialized_heap, visited);
-
-                    let value = match value {
-                        Ok(v) => v,
-                        Err(e) => {
-                            // println!("{}", e);
-                            return Err(e);
-                        }
-                    };
-
-                    serialized_heap.insert(h.as_ptr_usize(), value);
-
-                    // println!("Inserting: {}", h.as_ptr_usize());
-
-                    Ok(SerializableSteelVal::HeapAllocated(h.as_ptr_usize()))
-                }
-            }
-        }
-
-        illegal => stop!(Generic => "Type not allowed to be moved across threads!: {}", illegal),
-    }
-}
-
-#[derive(Clone, PartialEq, Eq)]
-pub struct SteelMutableVector(pub(crate) Gc<RefCell<Vec<SteelVal>>>);
-
-#[derive(Clone, PartialEq, Eq)]
-pub struct SteelVector(pub(crate) Gc<im_rc::Vector<SteelVal>>);
-
-impl Deref for SteelVector {
-    type Target = im_rc::Vector<SteelVal>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl From<Gc<im_rc::Vector<SteelVal>>> for SteelVector {
-    fn from(value: Gc<im_rc::Vector<SteelVal>>) -> Self {
-        SteelVector(value)
-    }
-}
-
-#[derive(Clone, PartialEq)]
-pub struct SteelHashMap(pub(crate) Gc<HashMap<SteelVal, SteelVal>>);
-
-impl Deref for SteelHashMap {
-    type Target = HashMap<SteelVal, SteelVal>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl From<Gc<HashMap<SteelVal, SteelVal>>> for SteelHashMap {
-    fn from(value: Gc<HashMap<SteelVal, SteelVal>>) -> Self {
-        SteelHashMap(value)
-    }
-}
-
-#[derive(Clone, PartialEq)]
-pub struct SteelHashSet(pub(crate) Gc<im_rc::HashSet<SteelVal>>);
-
-impl Deref for SteelHashSet {
-    type Target = im_rc::HashSet<SteelVal>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl From<Gc<im_rc::HashSet<SteelVal>>> for SteelHashSet {
-    fn from(value: Gc<im_rc::HashSet<SteelVal>>) -> Self {
-        SteelHashSet(value)
-    }
-}
-
-/// A value as represented in the runtime.
-#[derive(Clone)]
-pub enum SteelVal {
-    /// Represents a bytecode closure
-    Closure(Gc<ByteCodeLambda>),
-    /// Represents a boolean value
-    BoolV(bool),
-    /// Represents a number, currently only f64 numbers are supported
-    NumV(f64),
-    /// Represents an integer
-    IntV(isize),
-    /// Represents a character type
-    CharV(char),
-    /// Vectors are represented as `im_rc::Vector`'s, which are immutable
-    /// data structures
-    VectorV(SteelVector),
-    /// Void return value
-    Void,
-    /// Represents strings
-    StringV(SteelString),
-    /// Represents built in rust functions
-    FuncV(FunctionSignature),
-    /// Represents a symbol, internally represented as `String`s
-    SymbolV(SteelString),
-    /// Container for a type that implements the `Custom Type` trait. (trait object)
-    Custom(Gc<RefCell<Box<dyn CustomType>>>),
-    // Embedded HashMap
-    HashMapV(SteelHashMap),
-    // Embedded HashSet
-    HashSetV(SteelHashSet),
-    /// Represents a scheme-only struct
-    CustomStruct(Gc<UserDefinedStruct>),
-    /// Represents a port object
-    PortV(SteelPort),
-    /// Generic iterator wrapper
-    IterV(Gc<Transducer>),
-    /// Reducers
-    ReducerV(Gc<Reducer>),
-    /// Async Function wrapper
-    FutureFunc(BoxedAsyncFunctionSignature),
-    // Boxed Future Result
-    FutureV(Gc<FutureResult>),
-
-    StreamV(Gc<LazyStream>),
-
-    /// Custom closure
-    BoxedFunction(Rc<BoxedDynFunction>),
-    // Continuation
-    ContinuationFunction(Continuation),
-    // Function Pointer
-    // #[cfg(feature = "jit")]
-    // CompiledFunction(Box<JitFunctionPointer>),
-    // List
-    ListV(crate::values::lists::List<SteelVal>),
-
-    Pair(Gc<crate::values::lists::Pair>),
-
-    // Mutable functions
-    MutFunc(MutFunctionSignature),
-    // Built in functions
-    BuiltIn(BuiltInSignature),
-    // Mutable vector
-    MutableVector(HeapRef<Vec<SteelVal>>),
-    // This should delegate to the underlying iterator - can allow for faster raw iteration if possible
-    // Should allow for polling just a raw "next" on underlying elements
-    BoxedIterator(Gc<RefCell<OpaqueIterator>>),
-
-    SyntaxObject(Gc<Syntax>),
-
-    // Mutable storage, with Gc backing
-    // Boxed(HeapRef),
-    Boxed(Gc<RefCell<SteelVal>>),
-
-    HeapAllocated(HeapRef<SteelVal>),
-
-    // TODO: This itself, needs to be boxed unfortunately.
-    Reference(Rc<OpaqueReference<'static>>),
-
-    BigNum(Gc<num::BigInt>),
-}
-
-impl SteelVal {
-    pub fn anonymous_boxed_function(
-        function: std::sync::Arc<
-            dyn Fn(&[SteelVal]) -> crate::rvals::Result<SteelVal> + Send + Sync + 'static,
-        >,
-    ) -> SteelVal {
-        SteelVal::BoxedFunction(Rc::new(BoxedDynFunction {
-            function,
-            name: None,
-            arity: None,
-        }))
-    }
-
-    pub fn as_box(&self) -> Option<HeapRef<SteelVal>> {
-        if let SteelVal::HeapAllocated(heap_ref) = self {
-            Some(heap_ref.clone())
-        } else {
-            None
-        }
-    }
-
-    pub fn as_box_to_inner(&self) -> Option<SteelVal> {
-        self.as_box().map(|x| x.get())
-    }
-
-    pub fn as_ptr_usize(&self) -> Option<usize> {
-        match self {
-            // Closure(_) => todo!(),
-            // BoolV(_) => todo!(),
-            // NumV(_) => todo!(),
-            // IntV(_) => todo!(),
-            // CharV(_) => todo!(),
-            // VectorV(_) => todo!(),
-            // Void => todo!(),
-            // StringV(_) => todo!(),
-            // FuncV(_) => todo!(),
-            // SymbolV(_) => todo!(),
-            // SteelVal::Custom(_) => todo!(),
-            // HashMapV(_) => todo!(),
-            // HashSetV(_) => todo!(),
-            CustomStruct(c) => Some(c.as_ptr() as usize),
-            // PortV(_) => todo!(),
-            // IterV(_) => todo!(),
-            // ReducerV(_) => todo!(),
-            // FutureFunc(_) => todo!(),
-            // FutureV(_) => todo!(),
-            // StreamV(_) => todo!(),
-            // BoxedFunction(_) => todo!(),
-            // ContinuationFunction(_) => todo!(),
-            ListV(l) => Some(l.as_ptr_usize()),
-            // MutFunc(_) => todo!(),
-            // BuiltIn(_) => todo!(),
-            // MutableVector(_) => todo!(),
-            // BoxedIterator(_) => todo!(),
-            // SteelVal::SyntaxObject(_) => todo!(),
-            // Boxed(_) => todo!(),
-            HeapAllocated(h) => Some(h.as_ptr_usize()),
-            // Reference(_) => todo!(),
-            // BigNum(_) => todo!(),
-            _ => None,
-        }
-    }
-
-    // pub(crate) fn children_mut<'a>(&'a mut self) -> impl IntoIterator<Item = SteelVal> {
-    //     match self {
-    //         Self::CustomStruct(inner) => {
-    //             if let Some(inner) = inner.get_mut() {
-    //                 std::mem::take(&mut inner.borrow_mut().fields)
-    //             } else {
-    //                 std::iter::empty()
-    //             }
-    //         }
-    //         _ => todo!(),
-    //     }
-    // }
-}
-
-// TODO: Consider unboxed value types, for optimized usages when compiling segments of code.
-// If we can infer the types from the concrete functions used, we don't need to have unboxed values -> We also
-// can use concrete forms of the underlying functions as well.
-// #[derive(Clone)]
-// pub enum UnboxedSteelVal {
-//     /// Represents a boolean value
-//     BoolV(bool),
-//     /// Represents a number, currently only f64 numbers are supported
-//     NumV(f64),
-//     /// Represents an integer
-//     IntV(isize),
-//     /// Represents a character type
-//     CharV(char),
-//     /// Vectors are represented as `im_rc::Vector`'s, which are immutable
-//     /// data structures
-//     VectorV(Vector<SteelVal>),
-//     /// Void return value
-//     Void,
-//     /// Represents strings
-//     StringV(SteelString),
-//     /// Represents built in rust functions
-//     FuncV(FunctionSignature),
-//     /// Represents a symbol, internally represented as `String`s
-//     SymbolV(SteelString),
-//     /// Container for a type that implements the `Custom Type` trait. (trait object)
-//     Custom(Gc<RefCell<Box<dyn CustomType>>>),
-//     // Embedded HashMap
-//     HashMapV(HashMap<SteelVal, SteelVal>),
-//     // Embedded HashSet
-//     HashSetV(HashSet<SteelVal>),
-//     /// Represents a scheme-only struct
-//     // StructV(Gc<SteelStruct>),
-//     /// Alternative implementation of a scheme-only struct
-//     CustomStruct(Gc<RefCell<UserDefinedStruct>>),
-//     // Represents a special rust closure
-//     // StructClosureV(Box<SteelStruct>, StructClosureSignature),
-//     // StructClosureV(Box<StructClosure>),
-//     /// Represents a port object
-//     PortV(SteelPort),
-//     /// Represents a bytecode closure
-//     Closure(Gc<ByteCodeLambda>),
-//     /// Generic iterator wrapper
-//     IterV(Gc<Transducer>),
-//     /// Reducers
-//     ReducerV(Gc<Reducer>),
-//     // Reducer(Reducer)
-//     // Generic IntoIter wrapper
-//     // Promise(Gc<SteelVal>),
-//     /// Async Function wrapper
-//     FutureFunc(BoxedAsyncFunctionSignature),
-//     // Boxed Future Result
-//     FutureV(Gc<FutureResult>),
-
-//     StreamV(Gc<LazyStream>),
-//     // Break the cycle somehow
-//     // EvaluationEnv(Weak<RefCell<Env>>),
-//     /// Contract
-//     Contract(Gc<ContractType>),
-//     /// Contracted Function
-//     ContractedFunction(Gc<ContractedFunction>),
-//     /// Custom closure
-//     BoxedFunction(BoxedFunctionSignature),
-//     // Continuation
-//     ContinuationFunction(Gc<Continuation>),
-//     // List
-//     ListV(List<SteelVal>),
-//     // Mutable functions
-//     MutFunc(MutFunctionSignature),
-//     // Built in functions
-//     BuiltIn(BuiltInSignature),
-//     // Mutable vector
-//     MutableVector(Gc<RefCell<Vec<SteelVal>>>),
-//     // This should delegate to the underlying iterator - can allow for faster raw iteration if possible
-//     // Should allow for polling just a raw "next" on underlying elements
-//     BoxedIterator(Gc<RefCell<BuiltInDataStructureIterator>>),
-
-//     SyntaxObject(Gc<Syntax>),
-
-//     // Mutable storage, with Gc backing
-//     Boxed(HeapRef),
-// }
-
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[repr(C)]
-pub struct SteelString(Rc<String>);
-
-impl Deref for SteelString {
-    type Target = Rc<String>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl From<&str> for SteelString {
-    fn from(val: &str) -> Self {
-        SteelString(Rc::new(val.to_string()))
-    }
-}
-
-impl From<&String> for SteelString {
-    fn from(val: &String) -> Self {
-        SteelString(Rc::new(val.to_owned()))
-    }
-}
-
-impl From<String> for SteelString {
-    fn from(val: String) -> Self {
-        SteelString(Rc::new(val))
-    }
-}
-
-impl From<Rc<String>> for SteelString {
-    fn from(val: Rc<String>) -> Self {
-        SteelString(val)
-    }
-}
-
-impl From<SteelString> for Rc<String> {
-    fn from(value: SteelString) -> Self {
-        value.0
-    }
-}
-
-impl std::fmt::Display for SteelString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl std::fmt::Debug for SteelString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{:?}", self.0)
-    }
-}
-
-// Check that steel values aren't growing without us knowing
-const _ASSERT_SMALL: () = assert!(std::mem::size_of::<SteelVal>() <= 16);
-
-#[test]
-fn check_size_of_steelval() {
-    assert_eq!(std::mem::size_of::<SteelVal>(), 16);
-}
-
-pub struct Chunks {
-    remaining: IntoIter<char>,
-}
-
-impl Chunks {
-    fn new(s: SteelString) -> Self {
-        Chunks {
-            remaining: s.chars().collect::<Vec<_>>().into_iter(),
-        }
-    }
-}
-
-pub struct OpaqueIterator {
-    pub(crate) root: SteelVal,
-    iterator: BuiltInDataStructureIterator,
-}
-
-impl Custom for OpaqueIterator {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("#<iterator>")))
-    }
-}
-
-// TODO: Convert this to just a generic custom type. This does not have to be
-// a special enum variant.
-pub enum BuiltInDataStructureIterator {
-    List(crate::values::lists::ConsumingIterator<SteelVal>),
-    Vector(im_rc::vector::ConsumingIter<SteelVal>),
-    Set(im_rc::hashset::ConsumingIter<SteelVal>),
-    Map(im_rc::hashmap::ConsumingIter<(SteelVal, SteelVal)>),
-    String(Chunks),
-    Opaque(Box<dyn Iterator<Item = SteelVal>>),
-}
-
-impl BuiltInDataStructureIterator {
-    pub fn into_boxed_iterator(self, value: SteelVal) -> SteelVal {
-        SteelVal::BoxedIterator(Gc::new(RefCell::new(OpaqueIterator {
-            root: value,
-            iterator: self,
-        })))
-    }
-}
-
-impl BuiltInDataStructureIterator {
-    pub fn from_iterator<T: IntoSteelVal, S: IntoIterator<Item = T> + 'static>(value: S) -> Self {
-        Self::Opaque(Box::new(
-            value
-                .into_iter()
-                .map(|x| x.into_steelval().expect("This shouldn't fail!")),
-        ))
-    }
-}
-
-impl Iterator for BuiltInDataStructureIterator {
-    type Item = SteelVal;
-
-    fn next(&mut self) -> Option<SteelVal> {
-        match self {
-            Self::List(l) => l.next(),
-            Self::Vector(v) => v.next(),
-            Self::String(s) => s.remaining.next().map(SteelVal::CharV),
-            Self::Set(s) => s.next(),
-            Self::Map(s) => s.next().map(|x| SteelVal::ListV(vec![x.0, x.1].into())),
-            Self::Opaque(s) => s.next(),
-        }
-    }
-}
-
-pub fn value_into_iterator(val: SteelVal) -> Option<SteelVal> {
-    let root = val.clone();
-    match val {
-        SteelVal::ListV(l) => Some(BuiltInDataStructureIterator::List(l.into_iter())),
-        SteelVal::VectorV(v) => Some(BuiltInDataStructureIterator::Vector(
-            (*v).clone().into_iter(),
-        )),
-        SteelVal::StringV(s) => Some(BuiltInDataStructureIterator::String(Chunks::new(s))),
-        SteelVal::HashSetV(s) => Some(BuiltInDataStructureIterator::Set((*s).clone().into_iter())),
-        SteelVal::HashMapV(m) => Some(BuiltInDataStructureIterator::Map((*m).clone().into_iter())),
-        _ => None,
-    }
-    .map(|iterator| BuiltInDataStructureIterator::into_boxed_iterator(iterator, root))
-}
-
-thread_local! {
-    pub static ITERATOR_FINISHED: SteelVal = SteelVal::SymbolV("done".into());
-}
-
-pub fn iterator_next(args: &[SteelVal]) -> Result<SteelVal> {
-    match &args[0] {
-        SteelVal::BoxedIterator(b) => match b.borrow_mut().iterator.next() {
-            Some(v) => Ok(v),
-            None => Ok(ITERATOR_FINISHED.with(|x| x.clone())),
-        },
-        _ => stop!(TypeMismatch => "Unexpected argument"),
-    }
-}
-
-impl SteelVal {
-    pub fn boxed(value: SteelVal) -> SteelVal {
-        SteelVal::Boxed(Gc::new(RefCell::new(value)))
-    }
-
-    pub(crate) fn ptr_eq(&self, other: &SteelVal) -> bool {
-        match (self, other) {
-            // Integers are a special case of ptr eq -> if integers are equal? they are also eq?
-            (IntV(l), IntV(r)) => l == r,
-            (NumV(l), NumV(r)) => l == r,
-            (BoolV(l), BoolV(r)) => l == r,
-            (VectorV(l), VectorV(r)) => Gc::ptr_eq(&l.0, &r.0),
-            (Void, Void) => true,
-            (StringV(l), StringV(r)) => Rc::ptr_eq(l, r),
-            (FuncV(l), FuncV(r)) => *l as usize == *r as usize,
-            (SymbolV(l), SymbolV(r)) => Rc::ptr_eq(l, r),
-            (SteelVal::Custom(l), SteelVal::Custom(r)) => Gc::ptr_eq(l, r),
-            (HashMapV(l), HashMapV(r)) => Gc::ptr_eq(&l.0, &r.0),
-            (HashSetV(l), HashSetV(r)) => Gc::ptr_eq(&l.0, &r.0),
-            (PortV(l), PortV(r)) => Rc::ptr_eq(&l.port, &r.port),
-            (Closure(l), Closure(r)) => Gc::ptr_eq(l, r),
-            (IterV(l), IterV(r)) => Gc::ptr_eq(l, r),
-            (ReducerV(l), ReducerV(r)) => Gc::ptr_eq(l, r),
-            #[allow(clippy::vtable_address_comparisons)]
-            (FutureFunc(l), FutureFunc(r)) => Rc::ptr_eq(l, r),
-            (FutureV(l), FutureV(r)) => Gc::ptr_eq(l, r),
-            (StreamV(l), StreamV(r)) => Gc::ptr_eq(l, r),
-            (BoxedFunction(l), BoxedFunction(r)) => Rc::ptr_eq(l, r),
-            (ContinuationFunction(l), ContinuationFunction(r)) => Continuation::ptr_eq(l, r),
-            (ListV(l), ListV(r)) => {
-                l.ptr_eq(r) || l.storage_ptr_eq(r) || l.is_empty() && r.is_empty()
-            }
-            (MutFunc(l), MutFunc(r)) => *l as usize == *r as usize,
-            (BuiltIn(l), BuiltIn(r)) => *l as usize == *r as usize,
-            (MutableVector(l), MutableVector(r)) => HeapRef::ptr_eq(l, r),
-            (BigNum(l), BigNum(r)) => Gc::ptr_eq(l, r),
-            (_, _) => false,
-        }
-    }
-}
-
-// TODO come back to this for the constant map
-
-// impl Serialize for SteelVal {
-//     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
-//     where
-//         S: Serializer,
-//     {
-//         match self {
-//             SteelVal::BoolV(b) => serializer.serialize_newtype_variant("SteelVal", 0, "BoolV", b),
-//             SteelVal::NumV(n) => serializer.serialize_newtype_variant("SteelVal", 1, "NumV", n),
-//             SteelVal::IntV(n) => serializer.serialize_newtype_variant("SteelVal", 2, "IntV", n),
-//             SteelVal::CharV(c) => serializer.serialize_newtype_variant("SteelVal", 3, "CharV", c),
-//             SteelVal::StringV(s) => {
-//                 serializer.serialize_newtype_variant("SteelVal", 7, "StringV", s)
-//             }
-//             SteelVal::Pair(car, cdr) => {
-//                 let mut state = serializer.serialize_tuple_variant("SteelVal", 4, "Pair", 2)?;
-//                 state.serialize_field(car)?;
-//                 state.serialize_field(cdr)?;
-//                 state.end()
-//             }
-//             _ => panic!("Cannot serialize enum variant: {}", self),
-//         }
-//     }
-// }
-
-impl Hash for SteelVal {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        match self {
-            BoolV(b) => b.hash(state),
-            NumV(n) => n.to_string().hash(state),
-            IntV(i) => i.hash(state),
-            CharV(c) => c.hash(state),
-            ListV(l) => l.hash(state),
-            CustomStruct(s) => s.hash(state),
-            BigNum(n) => n.hash(state),
-            // Pair(cell) => {
-            //     cell.hash(state);
-            // }
-            VectorV(v) => v.hash(state),
-            v @ Void => v.hash(state),
-            StringV(s) => s.hash(state),
-            FuncV(s) => (*s as *const FunctionSignature).hash(state),
-            // LambdaV(_) => unimplemented!(),
-            // MacroV(_) => unimplemented!(),
-            SymbolV(sym) => {
-                "symbol".hash(state);
-                sym.hash(state);
-                // format!("symbol: {}")
-            }
-            Custom(_) => unimplemented!(),
-            // StructClosureV(_) => unimplemented!(),
-            PortV(_) => unimplemented!(),
-            Closure(b) => b.hash(state),
-            HashMapV(hm) => hm.hash(state),
-            IterV(s) => s.hash(state),
-            HashSetV(hs) => hs.hash(state),
-            _ => {
-                println!("Trying to hash: {self:?}");
-                unimplemented!()
-            } // Promise(_) => unimplemented!(),
-        }
-    }
-}
-
-impl SteelVal {
-    #[inline(always)]
-    pub fn is_truthy(&self) -> bool {
-        match &self {
-            SteelVal::BoolV(false) => false,
-            SteelVal::Void => false,
-            SteelVal::ListV(v) => !v.is_empty(),
-            _ => true,
-        }
-    }
-
-    #[inline(always)]
-    pub fn is_falsey(&self) -> bool {
-        match &self {
-            SteelVal::BoolV(false) => true,
-            SteelVal::Void => true,
-            SteelVal::ListV(v) => v.is_empty(),
-            _ => false,
-        }
-    }
-
-    #[inline(always)]
-    pub fn is_future(&self) -> bool {
-        matches!(self, SteelVal::FutureV(_))
-    }
-
-    pub fn is_hashable(&self) -> bool {
-        matches!(
-            self,
-            BoolV(_)
-                | IntV(_)
-                | CharV(_)
-                // | Pair(_)
-                | VectorV(_)
-                | StringV(_)
-                | SymbolV(_)
-                | HashMapV(_)
-                | Closure(_)
-                | ListV(_)
-                | FuncV(_)
-                | CustomStruct(_)
-        )
-    }
-
-    pub fn is_function(&self) -> bool {
-        matches!(
-            self,
-            BoxedFunction(_)
-                | Closure(_)
-                | FuncV(_)
-                // | ContractedFunction(_)
-                | BuiltIn(_)
-                | MutFunc(_)
-        )
-    }
-
-    // pub fn is_contract(&self) -> bool {
-    //     matches!(self, Contract(_))
-    // }
-
-    pub fn empty_hashmap() -> SteelVal {
-        SteelVal::HashMapV(Gc::new(HashMap::new()).into())
-    }
-}
-
-impl SteelVal {
-    // pub fn res_iterator
-
-    pub fn list_or_else<E, F: FnOnce() -> E>(
-        &self,
-        err: F,
-    ) -> std::result::Result<&List<SteelVal>, E> {
-        match self {
-            Self::ListV(v) => Ok(v),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn list(&self) -> Option<&List<SteelVal>> {
-        match self {
-            Self::ListV(l) => Some(l),
-            _ => None,
-        }
-    }
-
-    pub fn pair(&self) -> Option<&Gc<crate::values::lists::Pair>> {
-        match self {
-            Self::Pair(p) => Some(p),
-            _ => None,
-        }
-    }
-
-    pub fn bool_or_else<E, F: FnOnce() -> E>(&self, err: F) -> std::result::Result<bool, E> {
-        match self {
-            Self::BoolV(v) => Ok(*v),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn int_or_else<E, F: FnOnce() -> E>(&self, err: F) -> std::result::Result<isize, E> {
-        match self {
-            Self::IntV(v) => Ok(*v),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn num_or_else<E, F: FnOnce() -> E>(&self, err: F) -> std::result::Result<f64, E> {
-        match self {
-            Self::NumV(v) => Ok(*v),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn char_or_else<E, F: FnOnce() -> E>(&self, err: F) -> std::result::Result<char, E> {
-        match self {
-            Self::CharV(v) => Ok(*v),
-            _ => Err(err()),
-        }
-    }
-
-    /// Vector does copy on the value to return
-    pub fn vector_or_else<E, F: FnOnce() -> E>(
-        &self,
-        err: F,
-    ) -> std::result::Result<Vector<SteelVal>, E> {
-        match self {
-            Self::VectorV(v) => Ok(v.0.unwrap()),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn void_or_else<E, F: FnOnce() -> E>(&self, err: F) -> std::result::Result<(), E> {
-        match self {
-            Self::Void => Ok(()),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn string_or_else<E, F: FnOnce() -> E>(&self, err: F) -> std::result::Result<&str, E> {
-        match self {
-            Self::StringV(v) => Ok(v),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn func_or_else<E, F: FnOnce() -> E>(
-        &self,
-        err: F,
-    ) -> std::result::Result<&FunctionSignature, E> {
-        match self {
-            Self::FuncV(v) => Ok(v),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn boxed_func_or_else<E, F: FnOnce() -> E>(
-        &self,
-        err: F,
-    ) -> std::result::Result<&BoxedDynFunction, E> {
-        match self {
-            Self::BoxedFunction(v) => Ok(v),
-            _ => Err(err()),
-        }
-    }
-
-    // pub fn contract_or_else<E, F: FnOnce() -> E>(
-    //     &self,
-    //     err: F,
-    // ) -> std::result::Result<Gc<ContractType>, E> {
-    //     match self {
-    //         Self::Contract(c) => Ok(c.clone()),
-    //         _ => Err(err()),
-    //     }
-    // }
-
-    pub fn closure_or_else<E, F: FnOnce() -> E>(
-        &self,
-        err: F,
-    ) -> std::result::Result<Gc<ByteCodeLambda>, E> {
-        match self {
-            Self::Closure(c) => Ok(c.clone()),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn symbol_or_else<E, F: FnOnce() -> E>(&self, err: F) -> std::result::Result<&str, E> {
-        match self {
-            Self::SymbolV(v) => Ok(v),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn clone_symbol_or_else<E, F: FnOnce() -> E>(
-        &self,
-        err: F,
-    ) -> std::result::Result<String, E> {
-        match self {
-            Self::SymbolV(v) => Ok(v.to_string()),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn as_isize(&self) -> Option<isize> {
-        match self {
-            Self::IntV(i) => Some(*i),
-            _ => None,
-        }
-    }
-
-    pub fn as_usize(&self) -> Option<usize> {
-        self.as_isize()
-            .and_then(|x| if x >= 0 { Some(x as usize) } else { None })
-    }
-
-    pub fn as_bool(&self) -> Option<bool> {
-        match self {
-            Self::BoolV(b) => Some(*b),
-            _ => None,
-        }
-    }
-
-    pub fn as_future(&self) -> Option<Shared<BoxedFutureResult>> {
-        match self {
-            Self::FutureV(v) => Some(v.clone().unwrap().into_shared()),
-            _ => None,
-        }
-    }
-
-    pub fn as_string(&self) -> Option<&SteelString> {
-        match self {
-            Self::StringV(s) => Some(s),
-            _ => None,
-        }
-    }
-
-    pub fn as_symbol(&self) -> Option<&SteelString> {
-        match self {
-            Self::SymbolV(s) => Some(s),
-            _ => None,
-        }
-    }
-
-    pub fn as_syntax_object(&self) -> Option<&Syntax> {
-        match self {
-            Self::SyntaxObject(s) => Some(s),
-            _ => None,
-        }
-    }
-
-    // pub fn custom_or_else<E, F: FnOnce() -> E>(
-    //     &self,
-    //     err: F,
-    // ) -> std::result::Result<&Box<dyn CustomType>, E> {
-    //     match self {
-    //         Self::Custom(v) => Ok(&v),
-    //         _ => Err(err()),
-    //     }
-    // }
-
-    // pub fn struct_or_else<E, F: FnOnce() -> E>(
-    //     &self,
-    //     err: F,
-    // ) -> std::result::Result<&SteelStruct, E> {
-    //     match self {
-    //         Self::StructV(v) => Ok(v),
-    //         _ => Err(err()),
-    //     }
-    // }
-
-    pub fn closure_arity(&self) -> Option<usize> {
-        if let SteelVal::Closure(c) = self {
-            Some(c.arity())
-        } else {
-            None
-        }
-    }
-}
-
-impl SteelVal {
-    pub const INT_ZERO: SteelVal = SteelVal::IntV(0);
-    pub const INT_ONE: SteelVal = SteelVal::IntV(1);
-    pub const INT_TWO: SteelVal = SteelVal::IntV(2);
-}
-
-impl Eq for SteelVal {}
-
-fn integer_float_equality(int: isize, float: f64) -> bool {
-    let converted = float as isize;
-
-    if float == converted as f64 {
-        int == converted
-    } else {
-        false
-    }
-}
-
-fn bignum_float_equality(bigint: &Gc<num::BigInt>, float: f64) -> bool {
-    if float.fract() == 0.0 {
-        if let Some(promoted) = bigint.to_f64() {
-            promoted == float
-        } else {
-            false
-        }
-    } else {
-        false
-    }
-}
-
-#[steel_derive::function(name = "=", constant = true)]
-pub fn number_equality(left: &SteelVal, right: &SteelVal) -> Result<SteelVal> {
-    let result = match (left, right) {
-        (IntV(l), IntV(r)) => l == r,
-        (NumV(l), NumV(r)) => l == r,
-        (IntV(l), NumV(r)) | (NumV(r), IntV(l)) => integer_float_equality(*l, *r),
-        (BigNum(l), BigNum(r)) => l == r,
-        (BigNum(l), NumV(r)) | (NumV(r), BigNum(l)) => bignum_float_equality(l, *r),
-
-        // Should be impossible to have an integer and a bignum be the same value
-        (IntV(_), BigNum(_)) | (BigNum(_), IntV(_)) => false,
-
-        _ => stop!(TypeMismatch => "= expects two numbers, found: {:?} and {:?}", left, right),
-    };
-
-    Ok(SteelVal::BoolV(result))
-}
-
-// TODO add tests
-// impl PartialEq for SteelVal {
-//     fn eq(&self, other: &Self) -> bool {
-//         match (self, other) {
-//             (Void, Void) => true,
-//             (BoolV(l), BoolV(r)) => l == r,
-//             (BigNum(l), BigNum(r)) => l == r,
-//             // (NumV(l), NumV(r)) => l == r,
-//             (IntV(l), IntV(r)) => l == r,
-
-//             // Floats shouls also be considered equal
-//             (NumV(l), NumV(r)) => l == r,
-
-//             (StringV(l), StringV(r)) => l == r,
-//             (VectorV(l), VectorV(r)) => l == r,
-//             (SymbolV(l), SymbolV(r)) => l == r,
-//             (CharV(l), CharV(r)) => l == r,
-//             (HashSetV(l), HashSetV(r)) => l == r,
-//             (HashMapV(l), HashMapV(r)) => l == r,
-//             (Closure(l), Closure(r)) => l == r,
-//             (IterV(l), IterV(r)) => l == r,
-//             (ListV(l), ListV(r)) => l == r,
-//             (CustomStruct(l), CustomStruct(r)) => l == r,
-//             (FuncV(l), FuncV(r)) => *l == *r,
-//             (Custom(l), Custom(r)) => Gc::ptr_eq(l, r),
-//             (HeapAllocated(l), HeapAllocated(r)) => l.get() == r.get(),
-//             //TODO
-//             (_, _) => false, // (l, r) => {
-//                              //     let left = unwrap!(l, usize);
-//                              //     let right = unwrap!(r, usize);
-//                              //     match (left, right) {
-//                              //         (Ok(l), Ok(r)) => l == r,
-//                              //         (_, _) => false,
-//                              //     }
-//                              // }
-//         }
-//     }
-// }
-
-// TODO add tests
-impl PartialOrd for SteelVal {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        match (self, other) {
-            (NumV(n), NumV(o)) => n.partial_cmp(o),
-            (StringV(s), StringV(o)) => s.partial_cmp(o),
-            (CharV(l), CharV(r)) => l.partial_cmp(r),
-            (IntV(l), IntV(r)) => l.partial_cmp(r),
-            (NumV(l), IntV(r)) => l.partial_cmp(&(*r as f64)),
-            (IntV(l), NumV(r)) => (*l as f64).partial_cmp(r),
-            _ => None, // unimplemented for other types
-        }
-    }
-}
-
-impl fmt::Display for SteelVal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // at the top level, print a ' if we are
-        // trying to print a symbol or list
-        match self {
-            SymbolV(_) | ListV(_) => write!(f, "'")?,
-            VectorV(_) => write!(f, "'#")?,
-            _ => (),
-        };
-
-        CycleDetector::detect_and_display_cycles(self, f)
-
-        // display_helper(self, f)
-    }
-}
-
-impl fmt::Debug for SteelVal {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // at the top level, print a ' if we are
-        // trying to print a symbol or list
-        match self {
-            SymbolV(_) | ListV(_) => write!(f, "'")?,
-            VectorV(_) => write!(f, "'#")?,
-            _ => (),
-        };
-        // display_helper(self, f)
-
-        CycleDetector::detect_and_display_cycles(self, f)
-    }
-}
-
-#[cfg(test)]
-mod or_else_tests {
-
-    use super::*;
-    use im_rc::vector;
-
-    #[test]
-    fn bool_or_else_test_good() {
-        let input = SteelVal::BoolV(true);
-        assert_eq!(input.bool_or_else(throw!(Generic => "test")).unwrap(), true);
-    }
-
-    #[test]
-    fn bool_or_else_test_bad() {
-        let input = SteelVal::CharV('f');
-        assert!(input.bool_or_else(throw!(Generic => "test")).is_err());
-    }
-
-    #[test]
-    fn num_or_else_test_good() {
-        let input = SteelVal::NumV(10.0);
-        assert_eq!(input.num_or_else(throw!(Generic => "test")).unwrap(), 10.0);
-    }
-
-    #[test]
-    fn num_or_else_test_bad() {
-        let input = SteelVal::CharV('f');
-        assert!(input.num_or_else(throw!(Generic => "test")).is_err());
-    }
-
-    #[test]
-    fn char_or_else_test_good() {
-        let input = SteelVal::CharV('f');
-        assert_eq!(input.char_or_else(throw!(Generic => "test")).unwrap(), 'f');
-    }
-
-    #[test]
-    fn char_or_else_test_bad() {
-        let input = SteelVal::NumV(10.0);
-        assert!(input.char_or_else(throw!(Generic => "test")).is_err());
-    }
-
-    #[test]
-    fn vector_or_else_test_good() {
-        let input: SteelVal = vector![SteelVal::IntV(1)].into();
-        assert_eq!(
-            input.vector_or_else(throw!(Generic => "test")).unwrap(),
-            vector![SteelVal::IntV(1)]
-        );
-    }
-
-    #[test]
-    fn vector_or_else_bad() {
-        let input = SteelVal::CharV('f');
-        assert!(input.vector_or_else(throw!(Generic => "test")).is_err());
-    }
-
-    #[test]
-    fn void_or_else_test_good() {
-        let input = SteelVal::Void;
-        assert_eq!(input.void_or_else(throw!(Generic => "test")).unwrap(), ())
-    }
-
-    #[test]
-    fn void_or_else_test_bad() {
-        let input = SteelVal::StringV("foo".into());
-        assert!(input.void_or_else(throw!(Generic => "test")).is_err());
-    }
-
-    #[test]
-    fn string_or_else_test_good() {
-        let input = SteelVal::StringV("foo".into());
-        assert_eq!(
-            input.string_or_else(throw!(Generic => "test")).unwrap(),
-            "foo".to_string()
-        );
-    }
-
-    #[test]
-    fn string_or_else_test_bad() {
-        let input = SteelVal::Void;
-        assert!(input.string_or_else(throw!(Generic => "test")).is_err())
-    }
-
-    #[test]
-    fn symbol_or_else_test_good() {
-        let input = SteelVal::SymbolV("foo".into());
-        assert_eq!(
-            input.symbol_or_else(throw!(Generic => "test")).unwrap(),
-            "foo".to_string()
-        );
-    }
-
-    #[test]
-    fn symbol_or_else_test_bad() {
-        let input = SteelVal::Void;
-        assert!(input.symbol_or_else(throw!(Generic => "test")).is_err())
-    }
-}
diff --git a/crates/steel-core/src/rvals/cycles.rs b/crates/steel-core/src/rvals/cycles.rs
deleted file mode 100644
index 64d096407..000000000
--- a/crates/steel-core/src/rvals/cycles.rs
+++ /dev/null
@@ -1,1979 +0,0 @@
-use crate::values::lists::Pair;
-use std::{cell::Cell, collections::VecDeque};
-
-use num::BigInt;
-
-use crate::steel_vm::{
-    builtin::get_function_name, engine::Engine, vm::Continuation, vm::ContinuationMark,
-};
-
-use super::*;
-
-thread_local! {
-    // Use this to print values, in lieu of a bespoke printer
-    static PRINTING_KERNEL: RefCell<Engine> = {
-
-        let mut engine = Engine::new_printer();
-
-        engine.run(include_str!("../scheme/print.scm")).unwrap();
-
-        RefCell::new(engine)
-    };
-}
-
-pub fn install_printer() {
-    PRINTING_KERNEL.with(|x| {
-        x.borrow().globals();
-    });
-}
-
-#[steel_derive::function(name = "print-in-engine")]
-pub fn print_in_engine(value: SteelVal) {
-    PRINTING_KERNEL
-        .with(|x| {
-            x.borrow_mut()
-                .call_function_by_name_with_args("print", vec![value])
-        })
-        .unwrap();
-}
-
-#[derive(Default)]
-// Keep track of any reference counted values that are visited, in a pointer
-pub(super) struct CycleDetector {
-    // Recording things that have already been seen
-    cycles: fxhash::FxHashMap<usize, usize>,
-
-    // Values captured in cycles
-    values: Vec<SteelVal>,
-
-    depth: usize,
-}
-
-impl CycleDetector {
-    pub(super) fn detect_and_display_cycles(val: &SteelVal, f: &mut fmt::Formatter) -> fmt::Result {
-        // Consider using one shared queue here
-        let mut queue = Vec::new();
-
-        let mut bfs_detector = CycleCollector {
-            visited: fxhash::FxHashSet::default(),
-            cycles: fxhash::FxHashMap::default(),
-            values: Vec::new(),
-            queue: &mut queue,
-            found_mutable: false,
-        };
-
-        bfs_detector.push_back(val.clone());
-
-        bfs_detector.visit();
-
-        CycleDetector {
-            cycles: bfs_detector.cycles,
-            values: bfs_detector.values,
-            depth: 0,
-        }
-        .start_format(val, f)
-    }
-
-    fn start_format(mut self, val: &SteelVal, f: &mut fmt::Formatter) -> fmt::Result {
-        for node in std::mem::take(&mut self.values) {
-            let id = match &node {
-                SteelVal::CustomStruct(c) => {
-                    let ptr_addr = c.as_ptr() as usize;
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::HeapAllocated(b) => {
-                    // Get the object that THIS points to
-                    let ptr_addr = b.get().as_ptr_usize().unwrap();
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::ListV(l) => {
-                    let ptr_addr = l.as_ptr_usize();
-
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::VectorV(l) => {
-                    let ptr_addr = l.0.as_ptr() as usize;
-
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::HashMapV(l) => {
-                    let ptr_addr = l.0.as_ptr() as usize;
-
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::HashSetV(l) => {
-                    let ptr_addr = l.0.as_ptr() as usize;
-
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::Custom(l) => {
-                    let ptr_addr = l.0.as_ptr() as usize;
-
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::Boxed(b) => {
-                    let ptr_addr = b.as_ptr() as usize;
-
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::SyntaxObject(s) => {
-                    let ptr_addr = s.as_ptr() as usize;
-
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                SteelVal::MutableVector(v) => {
-                    let ptr_addr = v.as_ptr_usize();
-
-                    self.cycles.get(&ptr_addr).unwrap()
-                }
-                _ => {
-                    unreachable!()
-                }
-            };
-
-            write!(f, "#{id}=")?;
-            self.top_level_format_with_cycles(&node, f)?;
-            writeln!(f)?;
-        }
-
-        if !self.values.contains(val) {
-            self.format_with_cycles(val, f)?;
-        }
-
-        Ok(())
-    }
-
-    fn top_level_format_with_cycles(
-        &mut self,
-        val: &SteelVal,
-        f: &mut fmt::Formatter,
-    ) -> fmt::Result {
-        self.depth += 1;
-
-        if self.depth > 128 {
-            return write!(f, "...");
-        }
-
-        let res = match val {
-            BoolV(b) => write!(f, "#{b}"),
-            NumV(x) => write!(f, "{x:?}"),
-            IntV(x) => write!(f, "{x}"),
-            StringV(s) => write!(f, "{s:?}"),
-            BigNum(b) => write!(f, "{}", b.as_ref()),
-            CharV(c) => {
-                if c.is_ascii_control() {
-                    write!(f, "{}", c)
-                } else {
-                    write!(f, "#\\{c}")
-                }
-            }
-            Pair(p) => {
-                write!(f, "({} . {})", p.car(), p.cdr())
-            }
-            FuncV(func) => {
-                if let Some(name) = get_function_name(*func) {
-                    write!(f, "#<function:{}>", name.name)
-                } else {
-                    write!(f, "#<function>")
-                }
-            }
-            Void => write!(f, "#<void>"),
-            SymbolV(s) => write!(f, "{s}"),
-            VectorV(lst) => {
-                let mut iter = lst.iter();
-                write!(f, "'#(")?;
-                if let Some(last) = iter.next_back() {
-                    for item in iter {
-                        self.format_with_cycles(item, f)?;
-                        write!(f, " ")?;
-                    }
-                    self.format_with_cycles(last, f)?;
-                }
-                write!(f, ")")
-            }
-            Custom(x) => write!(f, "#<{}>", x.borrow().display()?),
-            CustomStruct(s) => {
-                let guard = s;
-
-                {
-                    if guard
-                        .get(&SteelVal::SymbolV(SteelString::from("#:transparent")))
-                        .and_then(|x| x.as_bool())
-                        .unwrap_or_default()
-                    {
-                        write!(f, "({}", guard.name())?;
-
-                        for i in guard.fields.iter() {
-                            write!(f, " ")?;
-                            self.format_with_cycles(i, f)?;
-                        }
-
-                        write!(f, ")")
-                    } else {
-                        write!(f, "({})", guard.name())
-                    }
-                }
-            }
-
-            PortV(_) => write!(f, "#<port>"),
-            Closure(_) => write!(f, "#<bytecode-closure>"),
-            HashMapV(hm) => write!(f, "#<hashmap {:#?}>", hm.as_ref()),
-            IterV(_) => write!(f, "#<iterator>"),
-            HashSetV(hs) => write!(f, "#<hashset {:?}>", hs.0),
-            FutureFunc(_) => write!(f, "#<future-func>"),
-            FutureV(_) => write!(f, "#<future>"),
-            StreamV(_) => write!(f, "#<stream>"),
-            BoxedFunction(b) => {
-                if let Some(name) = b.name() {
-                    write!(f, "#<function:{}>", name)
-                } else {
-                    write!(f, "#<function>")
-                }
-            }
-            ContinuationFunction(_) => write!(f, "#<continuation>"),
-            // #[cfg(feature = "jit")]
-            // CompiledFunction(_) => write!(f, "#<compiled-function>"),
-            ListV(l) => {
-                write!(f, "(")?;
-
-                let mut iter = l.iter().peekable();
-
-                while let Some(item) = iter.next() {
-                    self.format_with_cycles(item, f)?;
-                    if iter.peek().is_some() {
-                        write!(f, " ")?
-                    }
-                }
-
-                write!(f, ")")
-            }
-            MutFunc(_) => write!(f, "#<function>"),
-            BuiltIn(_) => write!(f, "#<function>"),
-            ReducerV(_) => write!(f, "#<reducer>"),
-            MutableVector(v) => write!(f, "{:?}", v.get()),
-            SyntaxObject(s) => {
-                if let Some(raw) = &s.raw {
-                    write!(f, "#<syntax:{:?} {:?}>", s.span, raw)
-                } else {
-                    write!(f, "#<syntax:{:?} {:?}>", s.span, s.syntax)
-                }
-            }
-            BoxedIterator(_) => write!(f, "#<iterator>"),
-            Boxed(b) => write!(f, "'#&{}", b.borrow()),
-            Reference(x) => write!(f, "{}", x.format()?),
-            HeapAllocated(b) => write!(f, "'#&{}", b.get()),
-        };
-
-        self.depth -= 1;
-
-        res
-    }
-
-    fn format_with_cycles(&mut self, val: &SteelVal, f: &mut fmt::Formatter) -> fmt::Result {
-        self.depth += 1;
-
-        if self.depth > 128 {
-            return write!(f, "...");
-        }
-
-        let res = match val {
-            BoolV(b) => write!(f, "#{b}"),
-            NumV(x) => write!(f, "{x:?}"),
-            IntV(x) => write!(f, "{x}"),
-            StringV(s) => write!(f, "{s:?}"),
-            CharV(c) => {
-                if c.is_ascii_control() {
-                    write!(f, "{}", c)
-                } else {
-                    write!(f, "#\\{c}")
-                }
-            }
-            FuncV(func) => {
-                if let Some(name) = get_function_name(*func) {
-                    write!(f, "#<function:{}>", name.name)
-                } else {
-                    write!(f, "#<function>")
-                }
-            }
-            Pair(p) => {
-                write!(f, "({} . {})", p.car(), p.cdr())
-            }
-            Void => write!(f, "#<void>"),
-            SymbolV(s) => write!(f, "{s}"),
-            VectorV(lst) => {
-                let mut iter = lst.iter();
-                write!(f, "(")?;
-                if let Some(last) = iter.next_back() {
-                    for item in iter {
-                        self.format_with_cycles(item, f)?;
-                        write!(f, " ")?;
-                    }
-                    self.format_with_cycles(last, f)?;
-                }
-                write!(f, ")")
-            }
-            Custom(x) => write!(f, "{}", x.borrow().display()?),
-            CustomStruct(s) => {
-                if let Some(id) = self.cycles.get(&(s.as_ptr() as usize)) {
-                    write!(f, "#{id}#")
-                } else {
-                    let guard = s;
-
-                    {
-                        if s.get(&SteelVal::SymbolV(SteelString::from("#:transparent")))
-                            .and_then(|x| x.as_bool())
-                            .unwrap_or_default()
-                        {
-                            write!(f, "({}", guard.name())?;
-
-                            for i in guard.fields.iter() {
-                                write!(f, " ")?;
-                                self.format_with_cycles(i, f)?;
-                            }
-
-                            write!(f, ")")
-                        } else {
-                            write!(f, "({})", guard.name())
-                        }
-                    }
-                }
-            }
-
-            PortV(_) => write!(f, "#<port>"),
-            Closure(_) => write!(f, "#<bytecode-closure>"),
-            HashMapV(hm) => write!(f, "#<hashmap {:#?}>", hm.as_ref()),
-            IterV(_) => write!(f, "#<iterator>"),
-            HashSetV(hs) => write!(f, "#<hashset {:?}>", hs.0),
-            FutureFunc(_) => write!(f, "#<future-func>"),
-            FutureV(_) => write!(f, "#<future>"),
-            // Promise(_) => write!(f, "#<promise>"),
-            StreamV(_) => write!(f, "#<stream>"),
-            BoxedFunction(b) => {
-                if let Some(name) = b.name() {
-                    write!(f, "#<function:{}>", name)
-                } else {
-                    write!(f, "#<function>")
-                }
-            }
-            ContinuationFunction(_) => write!(f, "#<continuation>"),
-            // #[cfg(feature = "jit")]
-            // CompiledFunction(_) => write!(f, "#<compiled-function>"),
-            ListV(l) => {
-                write!(f, "(")?;
-
-                let mut iter = l.iter().peekable();
-
-                while let Some(item) = iter.next() {
-                    self.format_with_cycles(item, f)?;
-                    if iter.peek().is_some() {
-                        write!(f, " ")?
-                    }
-                }
-
-                // for item in l.iter().pe
-
-                // for item in l {
-                //     display_helper(item, f)?;
-                //     write!(f, " ")?;
-                // }
-                write!(f, ")")
-            }
-            // write!(f, "#<list {:?}>", l),
-            MutFunc(_) => write!(f, "#<function>"),
-            BuiltIn(_) => write!(f, "#<function>"),
-            ReducerV(_) => write!(f, "#<reducer>"),
-            MutableVector(v) => write!(f, "{:?}", v.get()),
-            SyntaxObject(s) => {
-                if let Some(raw) = &s.raw {
-                    write!(f, "#<syntax:{:?} {:?}>", s.span, raw)
-                } else {
-                    write!(f, "#<syntax:{:?} {:?}>", s.span, s.syntax)
-                }
-            }
-            BoxedIterator(_) => write!(f, "#<iterator>"),
-            Boxed(b) => write!(f, "'#&{}", b.borrow()),
-            Reference(x) => write!(f, "{}", x.format()?),
-            BigNum(b) => write!(f, "{}", b.as_ref()),
-            HeapAllocated(b) => {
-                if let Some(id) = b.get().as_ptr_usize().and_then(|x| self.cycles.get(&x)) {
-                    write!(f, "#{id}#")
-                } else {
-                    write!(f, "'#&{}", b.get())
-                }
-            }
-        };
-
-        self.depth -= 1;
-
-        res
-    }
-}
-
-fn replace_with_void(value: &mut SteelVal) -> SteelVal {
-    std::mem::replace(value, SteelVal::Void)
-}
-
-impl SteelVal {
-    fn make_void(&mut self) -> SteelVal {
-        std::mem::replace(self, SteelVal::Void)
-    }
-}
-
-pub(crate) struct SteelCycleCollector {
-    cycles: fxhash::FxHashMap<usize, usize>,
-    values: List<SteelVal>,
-}
-
-impl Custom for SteelCycleCollector {}
-
-impl SteelCycleCollector {
-    pub fn from_root(value: SteelVal) -> Self {
-        let mut queue = Vec::new();
-
-        let mut collector = CycleCollector {
-            visited: fxhash::FxHashSet::default(),
-            cycles: fxhash::FxHashMap::default(),
-            values: Vec::new(),
-            queue: &mut queue,
-            found_mutable: false,
-        };
-
-        collector.push_back(value);
-
-        collector.visit();
-
-        if collector.found_mutable {
-            SteelCycleCollector {
-                cycles: collector.cycles,
-                values: collector.values.into(),
-            }
-        } else {
-            SteelCycleCollector {
-                cycles: fxhash::FxHashMap::default(),
-                values: List::new(),
-            }
-        }
-    }
-
-    // Get the value
-    pub fn get(&self, node: SteelVal) -> Option<usize> {
-        match node {
-            SteelVal::CustomStruct(c) => {
-                let ptr_addr = c.as_ptr() as usize;
-                self.cycles.get(&ptr_addr)
-            }
-            SteelVal::HeapAllocated(b) => {
-                // Get the object that THIS points to
-                let ptr_addr = b.get().as_ptr_usize().unwrap();
-                self.cycles.get(&ptr_addr)
-            }
-            SteelVal::ListV(l) => {
-                let ptr_addr = l.as_ptr_usize();
-
-                self.cycles.get(&ptr_addr)
-            }
-            SteelVal::VectorV(l) => {
-                let ptr_addr = l.0.as_ptr() as usize;
-
-                self.cycles.get(&ptr_addr)
-            }
-            SteelVal::HashMapV(l) => {
-                let ptr_addr = l.0.as_ptr() as usize;
-
-                self.cycles.get(&ptr_addr)
-            }
-            SteelVal::HashSetV(l) => {
-                let ptr_addr = l.0.as_ptr() as usize;
-
-                self.cycles.get(&ptr_addr)
-            }
-            SteelVal::Custom(l) => {
-                let ptr_addr = l.0.as_ptr() as usize;
-
-                self.cycles.get(&ptr_addr)
-            }
-            SteelVal::Boxed(b) => {
-                let ptr_addr = b.as_ptr() as usize;
-
-                self.cycles.get(&ptr_addr)
-            }
-            SteelVal::SyntaxObject(s) => {
-                let ptr_addr = s.as_ptr() as usize;
-
-                self.cycles.get(&ptr_addr)
-            }
-            _ => None,
-        }
-        .copied()
-    }
-
-    pub fn values(&self) -> List<SteelVal> {
-        self.values.clone()
-    }
-}
-
-struct CycleCollector<'a> {
-    // Keep a mapping of the pointer -> gensym
-    visited: fxhash::FxHashSet<usize>,
-
-    // Recording things that have already been seen
-    cycles: fxhash::FxHashMap<usize, usize>,
-
-    // Values captured in cycles
-    values: Vec<SteelVal>,
-
-    // Queue of items to check
-    queue: &'a mut Vec<SteelVal>,
-
-    // Whether we found something mutable - if we haven't, then a cycle
-    // isn't even possible
-    found_mutable: bool,
-}
-
-impl<'a> CycleCollector<'a> {
-    fn add(&mut self, val: usize, steelval: &SteelVal) -> bool {
-        if !self.found_mutable {
-            false;
-        }
-
-        if self.visited.contains(&val) {
-            let id = self.cycles.len();
-
-            // If we've already seen this, its fine, we can just move on
-            if let std::collections::hash_map::Entry::Vacant(e) = self.cycles.entry(val) {
-                e.insert(id);
-                // Keep track of the actual values that are being captured
-                self.values.push(steelval.clone());
-            } else {
-                return true;
-            }
-
-            return true;
-        }
-
-        self.visited.insert(val);
-        false
-    }
-}
-
-impl<'a> BreadthFirstSearchSteelValVisitor for CycleCollector<'a> {
-    type Output = ();
-
-    fn default_output(&mut self) -> Self::Output {}
-
-    fn pop_front(&mut self) -> Option<SteelVal> {
-        self.queue.pop()
-    }
-
-    fn push_back(&mut self, value: SteelVal) {
-        self.queue.push(value)
-    }
-
-    fn visit_closure(&mut self, _closure: Gc<ByteCodeLambda>) -> Self::Output {}
-    fn visit_bool(&mut self, _boolean: bool) -> Self::Output {}
-    fn visit_float(&mut self, _float: f64) -> Self::Output {}
-    fn visit_int(&mut self, _int: isize) -> Self::Output {}
-    fn visit_char(&mut self, _c: char) -> Self::Output {}
-
-    fn visit_immutable_vector(&mut self, vector: SteelVector) -> Self::Output {
-        if !self.add(
-            vector.0.as_ptr() as usize,
-            &SteelVal::VectorV(vector.clone()),
-        ) {
-            for value in vector.0.iter() {
-                self.push_back(value.clone());
-            }
-        }
-    }
-
-    fn visit_void(&mut self) -> Self::Output {}
-    fn visit_string(&mut self, _string: SteelString) -> Self::Output {}
-    fn visit_function_pointer(&mut self, _ptr: FunctionSignature) -> Self::Output {}
-    fn visit_symbol(&mut self, _symbol: SteelString) -> Self::Output {}
-
-    // If we have cycles here, it is game over - we probably don't want to be
-    // able to render to these easily?
-    fn visit_custom_type(
-        &mut self,
-        _custom_type: Gc<RefCell<Box<dyn CustomType>>>,
-    ) -> Self::Output {
-    }
-
-    fn visit_hash_map(&mut self, hashmap: SteelHashMap) -> Self::Output {
-        if !self.add(
-            hashmap.0.as_ptr() as usize,
-            &SteelVal::HashMapV(hashmap.clone()),
-        ) {
-            for (key, value) in hashmap.0.iter() {
-                self.push_back(key.clone());
-                self.push_back(value.clone());
-            }
-        }
-    }
-
-    fn visit_hash_set(&mut self, hashset: SteelHashSet) -> Self::Output {
-        if !self.add(
-            hashset.0.as_ptr() as usize,
-            &SteelVal::HashSetV(hashset.clone()),
-        ) {
-            for key in hashset.0.iter() {
-                self.push_back(key.clone())
-            }
-        }
-    }
-
-    fn visit_steel_struct(&mut self, steel_struct: Gc<UserDefinedStruct>) -> Self::Output {
-        if !self.add(
-            steel_struct.as_ptr() as usize,
-            &SteelVal::CustomStruct(steel_struct.clone()),
-        ) {
-            for value in steel_struct.fields.iter() {
-                self.push_back(value.clone())
-            }
-        }
-    }
-
-    fn visit_port(&mut self, _port: SteelPort) -> Self::Output {}
-    fn visit_transducer(&mut self, _transducer: Gc<Transducer>) -> Self::Output {}
-    fn visit_reducer(&mut self, _reducer: Gc<Reducer>) -> Self::Output {}
-    fn visit_future_function(&mut self, _function: BoxedAsyncFunctionSignature) -> Self::Output {}
-    fn visit_future(&mut self, _future: Gc<FutureResult>) -> Self::Output {}
-    fn visit_stream(&mut self, _stream: Gc<LazyStream>) -> Self::Output {}
-    fn visit_boxed_function(&mut self, _function: Rc<BoxedDynFunction>) -> Self::Output {}
-    fn visit_continuation(&mut self, _continuation: Continuation) -> Self::Output {}
-
-    fn visit_list(&mut self, list: List<SteelVal>) -> Self::Output {
-        if !self.add(list.as_ptr_usize(), &SteelVal::ListV(list.clone())) {
-            for value in list {
-                self.push_back(value);
-            }
-        }
-    }
-
-    fn visit_mutable_function(&mut self, _function: MutFunctionSignature) -> Self::Output {}
-
-    // TODO: Figure out the mutable vector first
-    fn visit_mutable_vector(&mut self, vector: HeapRef<Vec<SteelVal>>) -> Self::Output {
-        self.found_mutable = true;
-
-        if !self.add(
-            vector.as_ptr_usize(),
-            &SteelVal::MutableVector(vector.clone()),
-        ) {
-            for value in vector.get().iter() {
-                self.push_back(value.clone());
-            }
-        }
-    }
-
-    fn visit_builtin_function(&mut self, _function: BuiltInSignature) -> Self::Output {}
-
-    fn visit_boxed_iterator(&mut self, _iterator: Gc<RefCell<OpaqueIterator>>) -> Self::Output {}
-
-    fn visit_syntax_object(&mut self, syntax_object: Gc<Syntax>) -> Self::Output {
-        if !self.add(
-            syntax_object.as_ptr() as usize,
-            &SteelVal::SyntaxObject(syntax_object.clone()),
-        ) {
-            if let Some(raw) = syntax_object.raw.clone() {
-                self.push_back(raw);
-            }
-
-            self.push_back(syntax_object.syntax.clone());
-        }
-    }
-
-    fn visit_boxed_value(&mut self, boxed_value: Gc<RefCell<SteelVal>>) -> Self::Output {
-        if !self.add(
-            boxed_value.as_ptr() as usize,
-            &SteelVal::Boxed(boxed_value.clone()),
-        ) {
-            self.push_back(boxed_value.borrow().clone());
-        }
-    }
-
-    fn visit_reference_value(&mut self, _reference: Rc<OpaqueReference<'static>>) -> Self::Output {}
-    fn visit_bignum(&mut self, _bignum: Gc<BigInt>) -> Self::Output {}
-
-    fn visit_heap_allocated(&mut self, heap_ref: HeapRef<SteelVal>) -> Self::Output {
-        self.found_mutable = true;
-
-        if !self.add(
-            heap_ref.as_ptr_usize(),
-            &SteelVal::HeapAllocated(heap_ref.clone()),
-        ) {
-            self.push_back(heap_ref.get());
-        }
-    }
-
-    // TODO: Revisit this!
-    fn visit_pair(&mut self, pair: Gc<Pair>) -> Self::Output {
-        self.push_back(pair.car());
-        self.push_back(pair.cdr());
-    }
-}
-
-#[cfg(not(feature = "without-drop-protection"))]
-pub(crate) mod drop_impls {
-
-    use super::*;
-
-    thread_local! {
-        pub static DROP_BUFFER: RefCell<VecDeque<SteelVal>> = RefCell::new(VecDeque::with_capacity(128));
-        pub static FORMAT_BUFFER: RefCell<VecDeque<SteelVal>> = RefCell::new(VecDeque::with_capacity(128));
-    }
-
-    impl Drop for SteelVector {
-        fn drop(&mut self) {
-            if self.0.is_empty() {
-                return;
-            }
-
-            if let Some(inner) = self.0.get_mut() {
-                DROP_BUFFER
-                    .try_with(|drop_buffer| {
-                        if let Ok(mut drop_buffer) = drop_buffer.try_borrow_mut() {
-                            for value in std::mem::take(inner) {
-                                drop_buffer.push_back(value);
-                            }
-
-                            IterativeDropHandler::bfs(&mut drop_buffer);
-                        }
-                    })
-                    .ok();
-            }
-        }
-    }
-
-    impl Drop for SteelHashMap {
-        fn drop(&mut self) {
-            if self.0.is_empty() {
-                return;
-            }
-
-            if let Some(inner) = self.0.get_mut() {
-                DROP_BUFFER
-                    .try_with(|drop_buffer| {
-                        if let Ok(mut drop_buffer) = drop_buffer.try_borrow_mut() {
-                            for (key, value) in std::mem::take(inner) {
-                                drop_buffer.push_back(key);
-                                drop_buffer.push_back(value);
-                            }
-
-                            IterativeDropHandler::bfs(&mut drop_buffer);
-                        }
-                    })
-                    .ok();
-            }
-        }
-    }
-
-    impl Drop for UserDefinedStruct {
-        fn drop(&mut self) {
-            if self.fields.is_empty() {
-                return;
-            }
-
-            if DROP_BUFFER
-                .try_with(|drop_buffer| {
-                    if let Ok(mut drop_buffer) = drop_buffer.try_borrow_mut() {
-                        // for value in std::mem::take(&mut self.fields) {
-                        //     drop_buffer.push_back(value);
-                        // }
-
-                        drop_buffer.extend(Vec::from(std::mem::take(&mut self.fields)));
-
-                        IterativeDropHandler::bfs(&mut drop_buffer);
-                    }
-                })
-                .is_err()
-            {
-                let mut buffer = Vec::from(std::mem::take(&mut self.fields)).into();
-
-                IterativeDropHandler::bfs(&mut buffer);
-            }
-        }
-    }
-
-    impl Drop for LazyStream {
-        fn drop(&mut self) {
-            if self.initial_value == SteelVal::Void && self.stream_thunk == SteelVal::Void {
-                return;
-            }
-
-            DROP_BUFFER
-                .try_with(|drop_buffer| {
-                    if let Ok(mut drop_buffer) = drop_buffer.try_borrow_mut() {
-                        drop_buffer.push_back(self.initial_value.make_void());
-                        drop_buffer.push_back(self.stream_thunk.make_void());
-
-                        IterativeDropHandler::bfs(&mut drop_buffer);
-                    }
-                })
-                .ok();
-        }
-    }
-
-    // impl Drop for ByteCodeLambda {
-    //     fn drop(&mut self) {
-    //         if self.captures.is_empty() {
-    //             return;
-    //         }
-
-    //         DROP_BUFFER
-    //             .try_with(|drop_buffer| {
-    //                 if let Ok(mut drop_buffer) = drop_buffer.try_borrow_mut() {
-    //                     for value in std::mem::take(&mut self.captures) {
-    //                         drop_buffer.push_back(value);
-    //                     }
-
-    //                     IterativeDropHandler::bfs(&mut drop_buffer);
-    //                 }
-    //             })
-    //             .ok();
-    //     }
-    // }
-}
-
-pub struct IterativeDropHandler<'a> {
-    drop_buffer: &'a mut VecDeque<SteelVal>,
-}
-
-impl<'a> IterativeDropHandler<'a> {
-    pub fn bfs(drop_buffer: &'a mut VecDeque<SteelVal>) {
-        // println!("Current depth: {}", DEPTH.with(|x| x.get()));
-
-        // DEPTH.with(|x| x.set(x.get() + 1));
-        IterativeDropHandler { drop_buffer }.visit();
-        // DEPTH.with(|x| x.set(x.get() - 1));
-    }
-}
-
-impl<'a> BreadthFirstSearchSteelValVisitor for IterativeDropHandler<'a> {
-    type Output = ();
-
-    fn default_output(&mut self) -> Self::Output {
-        ()
-    }
-
-    fn pop_front(&mut self) -> Option<SteelVal> {
-        self.drop_buffer.pop_front()
-    }
-
-    fn push_back(&mut self, value: SteelVal) {
-        match &value {
-            SteelVal::BoolV(_)
-            | SteelVal::NumV(_)
-            | SteelVal::IntV(_)
-            | SteelVal::CharV(_)
-            | SteelVal::Void
-            | SteelVal::StringV(_)
-            | SteelVal::FuncV(_)
-            | SteelVal::SymbolV(_)
-            | SteelVal::FutureFunc(_)
-            | SteelVal::FutureV(_)
-            | SteelVal::BoxedFunction(_)
-            | SteelVal::MutFunc(_)
-            | SteelVal::BuiltIn(_)
-            | SteelVal::BigNum(_) => return,
-            _ => {
-                self.drop_buffer.push_back(value);
-            }
-        }
-    }
-
-    fn visit_bool(&mut self, _boolean: bool) {}
-    fn visit_float(&mut self, _float: f64) {}
-    fn visit_int(&mut self, _int: isize) {}
-    fn visit_char(&mut self, _c: char) {}
-    fn visit_void(&mut self) {}
-    fn visit_string(&mut self, _string: SteelString) {}
-    fn visit_function_pointer(&mut self, _ptr: FunctionSignature) {}
-    fn visit_symbol(&mut self, _symbol: SteelString) {}
-    fn visit_port(&mut self, _port: SteelPort) {}
-    fn visit_future(&mut self, _future: Gc<FutureResult>) {}
-    fn visit_mutable_function(&mut self, _function: MutFunctionSignature) {}
-    fn visit_bignum(&mut self, _bignum: Gc<BigInt>) {}
-    fn visit_future_function(&mut self, _function: BoxedAsyncFunctionSignature) {}
-    fn visit_builtin_function(&mut self, _function: BuiltInSignature) {}
-    fn visit_boxed_function(&mut self, _function: Rc<BoxedDynFunction>) {}
-
-    fn visit_closure(&mut self, closure: Gc<ByteCodeLambda>) {
-        if let Ok(mut inner) = closure.try_unwrap() {
-            for value in std::mem::take(&mut inner.captures) {
-                self.push_back(value);
-            }
-        }
-    }
-
-    fn visit_immutable_vector(&mut self, mut vector: SteelVector) {
-        if let Some(inner) = vector.0.get_mut() {
-            for value in std::mem::take(inner) {
-                self.push_back(value);
-            }
-        }
-    }
-
-    fn visit_custom_type(&mut self, custom_type: Gc<RefCell<Box<dyn CustomType>>>) {
-        if let Ok(inner) = custom_type.try_unwrap() {
-            let mut inner = inner.into_inner();
-
-            // let this decide if we're doing anything with this custom type
-            inner.drop_mut(self);
-        }
-    }
-
-    fn visit_hash_map(&mut self, mut hashmap: SteelHashMap) {
-        if let Some(inner) = hashmap.0.get_mut() {
-            for (key, value) in std::mem::take(inner) {
-                self.push_back(key);
-                self.push_back(value);
-            }
-        }
-    }
-
-    fn visit_hash_set(&mut self, mut hashset: SteelHashSet) {
-        if let Some(inner) = hashset.0.get_mut() {
-            for key in std::mem::take(inner) {
-                self.push_back(key);
-            }
-        }
-    }
-
-    fn visit_steel_struct(&mut self, steel_struct: Gc<UserDefinedStruct>) {
-        if let Ok(mut inner) = steel_struct.try_unwrap() {
-            for value in Vec::from(std::mem::take(&mut inner.fields)) {
-                self.push_back(value);
-            }
-        }
-    }
-
-    fn visit_transducer(&mut self, transducer: Gc<Transducer>) {
-        if let Ok(inner) = transducer.try_unwrap() {
-            for transducer in inner.ops {
-                match transducer {
-                    crate::values::transducers::Transducers::Map(m) => self.push_back(m),
-                    crate::values::transducers::Transducers::Filter(v) => self.push_back(v),
-                    crate::values::transducers::Transducers::Take(t) => self.push_back(t),
-                    crate::values::transducers::Transducers::Drop(d) => self.push_back(d),
-                    crate::values::transducers::Transducers::FlatMap(fm) => self.push_back(fm),
-                    crate::values::transducers::Transducers::Flatten => {}
-                    crate::values::transducers::Transducers::Window(w) => self.push_back(w),
-                    crate::values::transducers::Transducers::TakeWhile(tw) => self.push_back(tw),
-                    crate::values::transducers::Transducers::DropWhile(dw) => self.push_back(dw),
-                    crate::values::transducers::Transducers::Extend(e) => self.push_back(e),
-                    crate::values::transducers::Transducers::Cycle => {}
-                    crate::values::transducers::Transducers::Enumerating => {}
-                    crate::values::transducers::Transducers::Zipping(z) => self.push_back(z),
-                    crate::values::transducers::Transducers::Interleaving(i) => self.push_back(i),
-                }
-            }
-        }
-    }
-
-    fn visit_reducer(&mut self, reducer: Gc<Reducer>) {
-        if let Ok(inner) = reducer.try_unwrap() {
-            match inner {
-                Reducer::ForEach(f) => self.push_back(f),
-                Reducer::Generic(rf) => {
-                    self.push_back(rf.initial_value);
-                    self.push_back(rf.function);
-                }
-                _ => {}
-            }
-        }
-    }
-
-    fn visit_stream(&mut self, stream: Gc<LazyStream>) {
-        if let Ok(mut inner) = stream.try_unwrap() {
-            self.push_back(replace_with_void(&mut inner.initial_value));
-            self.push_back(replace_with_void(&mut inner.stream_thunk));
-        }
-    }
-
-    // Walk the whole thing! This includes the stack and all the stack frames
-    fn visit_continuation(&mut self, continuation: Continuation) {
-        if let Ok(inner) = Rc::try_unwrap(continuation.inner).map(RefCell::into_inner) {
-            match inner {
-                ContinuationMark::Closed(mut inner) => {
-                    for value in std::mem::take(&mut inner.stack) {
-                        self.push_back(value);
-                    }
-
-                    if let Some(inner) = inner.current_frame.function.get_mut() {
-                        for value in std::mem::take(&mut inner.captures) {
-                            self.push_back(value);
-                        }
-                    }
-
-                    for mut frame in std::mem::take(&mut inner.stack_frames) {
-                        if let Some(inner) = frame.function.get_mut() {
-                            for value in std::mem::take(&mut inner.captures) {
-                                self.push_back(value);
-                            }
-                        }
-                    }
-                }
-
-                ContinuationMark::Open(mut inner) => {
-                    for value in inner.current_stack_values {
-                        self.push_back(value);
-                    }
-
-                    if let Some(inner) = inner.current_frame.function.get_mut() {
-                        for value in std::mem::take(&mut inner.captures) {
-                            self.push_back(value);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    fn visit_list(&mut self, list: List<SteelVal>) {
-        // println!("VISITING LIST: {}", list.strong_count());
-        // println!("list: {:?}", list);
-
-        if list.strong_count() == 1 {
-            for value in list.draining_iterator() {
-                // println!(
-                // "PUSHING BACK VALUE - queue size: {}",
-                // self.drop_buffer.len()
-                // );
-
-                // println!("enqueueing: {}", value);
-
-                self.push_back(value);
-            }
-        }
-
-        // if list.strong_count() == 1 {
-        //     for value in list {
-        //         self.push_back(value);
-        //     }
-        // }
-    }
-
-    // TODO: When this gets replaced with heap storage, then we can do this more
-    // effectively!
-    fn visit_mutable_vector(&mut self, _vector: HeapRef<Vec<SteelVal>>) {}
-
-    // TODO: Once the root is added back to this, bring it back
-    fn visit_boxed_iterator(&mut self, iterator: Gc<RefCell<OpaqueIterator>>) {
-        if let Ok(inner) = iterator.try_unwrap() {
-            self.push_back(inner.into_inner().root)
-        }
-    }
-
-    fn visit_syntax_object(&mut self, syntax_object: Gc<Syntax>) {
-        if let Ok(inner) = syntax_object.try_unwrap() {
-            if let Some(raw) = inner.raw {
-                self.push_back(raw);
-            }
-
-            self.push_back(inner.syntax);
-        }
-    }
-
-    fn visit_boxed_value(&mut self, boxed_value: Gc<RefCell<SteelVal>>) {
-        if let Ok(inner) = boxed_value.try_unwrap() {
-            self.push_back(inner.into_inner());
-        }
-    }
-
-    fn visit_reference_value(&mut self, reference: Rc<OpaqueReference<'static>>) {
-        if let Ok(mut inner) = Rc::try_unwrap(reference) {
-            inner.drop_mut(self);
-        }
-    }
-
-    fn visit_heap_allocated(&mut self, _heap_ref: HeapRef<SteelVal>) -> Self::Output {}
-
-    fn visit(&mut self) -> Self::Output {
-        let mut ret = self.default_output();
-
-        while let Some(value) = self.pop_front() {
-            ret = match value {
-                Closure(c) => self.visit_closure(c),
-                BoolV(b) => self.visit_bool(b),
-                NumV(n) => self.visit_float(n),
-                IntV(i) => self.visit_int(i),
-                CharV(c) => self.visit_char(c),
-                VectorV(v) => self.visit_immutable_vector(v),
-                Void => self.visit_void(),
-                StringV(s) => self.visit_string(s),
-                FuncV(f) => self.visit_function_pointer(f),
-                SymbolV(s) => self.visit_symbol(s),
-                SteelVal::Custom(c) => self.visit_custom_type(c),
-                HashMapV(h) => self.visit_hash_map(h),
-                HashSetV(s) => self.visit_hash_set(s),
-                CustomStruct(c) => self.visit_steel_struct(c),
-                PortV(p) => self.visit_port(p),
-                IterV(t) => self.visit_transducer(t),
-                ReducerV(r) => self.visit_reducer(r),
-                FutureFunc(f) => self.visit_future_function(f),
-                FutureV(f) => self.visit_future(f),
-                StreamV(s) => self.visit_stream(s),
-                BoxedFunction(b) => self.visit_boxed_function(b),
-                ContinuationFunction(c) => self.visit_continuation(c),
-                ListV(l) => self.visit_list(l),
-                MutFunc(m) => self.visit_mutable_function(m),
-                BuiltIn(b) => self.visit_builtin_function(b),
-                MutableVector(b) => self.visit_mutable_vector(b),
-                BoxedIterator(b) => self.visit_boxed_iterator(b),
-                SteelVal::SyntaxObject(s) => self.visit_syntax_object(s),
-                Boxed(b) => self.visit_boxed_value(b),
-                Reference(r) => self.visit_reference_value(r),
-                BigNum(b) => self.visit_bignum(b),
-                HeapAllocated(b) => self.visit_heap_allocated(b),
-                Pair(p) => self.visit_pair(p),
-            };
-        }
-
-        // println!("--- finished draining drop queue ----");
-
-        ret
-    }
-
-    fn visit_pair(&mut self, pair: Gc<Pair>) -> Self::Output {
-        if let Ok(inner) = Gc::try_unwrap(pair) {
-            self.push_back(inner.car);
-            self.push_back(inner.cdr);
-        }
-    }
-}
-
-pub trait BreadthFirstSearchSteelValVisitor {
-    type Output;
-
-    fn default_output(&mut self) -> Self::Output;
-
-    fn pop_front(&mut self) -> Option<SteelVal>;
-
-    fn push_back(&mut self, value: SteelVal);
-
-    fn visit(&mut self) -> Self::Output {
-        let mut ret = self.default_output();
-
-        while let Some(value) = self.pop_front() {
-            ret = match value {
-                Closure(c) => self.visit_closure(c),
-                BoolV(b) => self.visit_bool(b),
-                NumV(n) => self.visit_float(n),
-                IntV(i) => self.visit_int(i),
-                CharV(c) => self.visit_char(c),
-                VectorV(v) => self.visit_immutable_vector(v),
-                Void => self.visit_void(),
-                StringV(s) => self.visit_string(s),
-                FuncV(f) => self.visit_function_pointer(f),
-                SymbolV(s) => self.visit_symbol(s),
-                SteelVal::Custom(c) => self.visit_custom_type(c),
-                HashMapV(h) => self.visit_hash_map(h),
-                HashSetV(s) => self.visit_hash_set(s),
-                CustomStruct(c) => self.visit_steel_struct(c),
-                PortV(p) => self.visit_port(p),
-                IterV(t) => self.visit_transducer(t),
-                ReducerV(r) => self.visit_reducer(r),
-                FutureFunc(f) => self.visit_future_function(f),
-                FutureV(f) => self.visit_future(f),
-                StreamV(s) => self.visit_stream(s),
-                BoxedFunction(b) => self.visit_boxed_function(b),
-                ContinuationFunction(c) => self.visit_continuation(c),
-                ListV(l) => self.visit_list(l),
-                MutFunc(m) => self.visit_mutable_function(m),
-                BuiltIn(b) => self.visit_builtin_function(b),
-                MutableVector(b) => self.visit_mutable_vector(b),
-                BoxedIterator(b) => self.visit_boxed_iterator(b),
-                SteelVal::SyntaxObject(s) => self.visit_syntax_object(s),
-                Boxed(b) => self.visit_boxed_value(b),
-                Reference(r) => self.visit_reference_value(r),
-                BigNum(b) => self.visit_bignum(b),
-                HeapAllocated(b) => self.visit_heap_allocated(b),
-                Pair(p) => self.visit_pair(p),
-            };
-        }
-
-        ret
-    }
-
-    fn visit_closure(&mut self, closure: Gc<ByteCodeLambda>) -> Self::Output;
-    fn visit_bool(&mut self, boolean: bool) -> Self::Output;
-    fn visit_float(&mut self, float: f64) -> Self::Output;
-    fn visit_int(&mut self, int: isize) -> Self::Output;
-    fn visit_char(&mut self, c: char) -> Self::Output;
-    fn visit_immutable_vector(&mut self, vector: SteelVector) -> Self::Output;
-    fn visit_void(&mut self) -> Self::Output;
-    fn visit_string(&mut self, string: SteelString) -> Self::Output;
-    fn visit_function_pointer(&mut self, ptr: FunctionSignature) -> Self::Output;
-    fn visit_symbol(&mut self, symbol: SteelString) -> Self::Output;
-    fn visit_custom_type(&mut self, custom_type: Gc<RefCell<Box<dyn CustomType>>>) -> Self::Output;
-    fn visit_hash_map(&mut self, hashmap: SteelHashMap) -> Self::Output;
-    fn visit_hash_set(&mut self, hashset: SteelHashSet) -> Self::Output;
-    fn visit_steel_struct(&mut self, steel_struct: Gc<UserDefinedStruct>) -> Self::Output;
-    fn visit_port(&mut self, port: SteelPort) -> Self::Output;
-    fn visit_transducer(&mut self, transducer: Gc<Transducer>) -> Self::Output;
-    fn visit_reducer(&mut self, reducer: Gc<Reducer>) -> Self::Output;
-    fn visit_future_function(&mut self, function: BoxedAsyncFunctionSignature) -> Self::Output;
-    fn visit_future(&mut self, future: Gc<FutureResult>) -> Self::Output;
-    fn visit_stream(&mut self, stream: Gc<LazyStream>) -> Self::Output;
-    fn visit_boxed_function(&mut self, function: Rc<BoxedDynFunction>) -> Self::Output;
-    fn visit_continuation(&mut self, continuation: Continuation) -> Self::Output;
-    fn visit_list(&mut self, list: List<SteelVal>) -> Self::Output;
-    fn visit_mutable_function(&mut self, function: MutFunctionSignature) -> Self::Output;
-    fn visit_mutable_vector(&mut self, vector: HeapRef<Vec<SteelVal>>) -> Self::Output;
-    fn visit_builtin_function(&mut self, function: BuiltInSignature) -> Self::Output;
-    fn visit_boxed_iterator(&mut self, iterator: Gc<RefCell<OpaqueIterator>>) -> Self::Output;
-    fn visit_syntax_object(&mut self, syntax_object: Gc<Syntax>) -> Self::Output;
-    fn visit_boxed_value(&mut self, boxed_value: Gc<RefCell<SteelVal>>) -> Self::Output;
-    fn visit_reference_value(&mut self, reference: Rc<OpaqueReference<'static>>) -> Self::Output;
-    fn visit_bignum(&mut self, bignum: Gc<BigInt>) -> Self::Output;
-    fn visit_heap_allocated(&mut self, heap_ref: HeapRef<SteelVal>) -> Self::Output;
-    fn visit_pair(&mut self, pair: Gc<Pair>) -> Self::Output;
-}
-
-pub trait BreadthFirstSearchSteelValReferenceVisitor<'a> {
-    type Output;
-
-    fn default_output(&mut self) -> Self::Output;
-
-    fn pop_front(&mut self) -> Option<&'a SteelVal>;
-
-    fn push_back(&mut self, value: &'a SteelVal);
-
-    fn visit(&mut self) -> Self::Output {
-        let mut ret = self.default_output();
-
-        while let Some(value) = self.pop_front() {
-            ret = match value {
-                Closure(c) => self.visit_closure(c),
-                BoolV(b) => self.visit_bool(*b),
-                NumV(n) => self.visit_float(*n),
-                IntV(i) => self.visit_int(*i),
-                CharV(c) => self.visit_char(*c),
-                VectorV(v) => self.visit_immutable_vector(v),
-                Void => self.visit_void(),
-                StringV(s) => self.visit_string(s),
-                FuncV(f) => self.visit_function_pointer(*f),
-                SymbolV(s) => self.visit_symbol(s),
-                SteelVal::Custom(c) => self.visit_custom_type(c),
-                HashMapV(h) => self.visit_hash_map(h),
-                HashSetV(s) => self.visit_hash_set(s),
-                CustomStruct(c) => self.visit_steel_struct(c),
-                PortV(p) => self.visit_port(p),
-                IterV(t) => self.visit_transducer(t),
-                ReducerV(r) => self.visit_reducer(r),
-                FutureFunc(f) => self.visit_future_function(f),
-                FutureV(f) => self.visit_future(f),
-                StreamV(s) => self.visit_stream(s),
-                BoxedFunction(b) => self.visit_boxed_function(b),
-                ContinuationFunction(c) => self.visit_continuation(c),
-                ListV(l) => self.visit_list(l),
-                MutFunc(m) => self.visit_mutable_function(m),
-                BuiltIn(b) => self.visit_builtin_function(b),
-                MutableVector(b) => self.visit_mutable_vector(b),
-                BoxedIterator(b) => self.visit_boxed_iterator(b),
-                SteelVal::SyntaxObject(s) => self.visit_syntax_object(s),
-                Boxed(b) => self.visit_boxed_value(b),
-                Reference(r) => self.visit_reference_value(r),
-                BigNum(b) => self.visit_bignum(b),
-                HeapAllocated(b) => self.visit_heap_allocated(b),
-                Pair(p) => self.visit_pair(p),
-            };
-        }
-
-        ret
-    }
-
-    fn visit_closure(&mut self, closure: &'a Gc<ByteCodeLambda>) -> Self::Output;
-    fn visit_bool(&mut self, boolean: bool) -> Self::Output;
-    fn visit_float(&mut self, float: f64) -> Self::Output;
-    fn visit_int(&mut self, int: isize) -> Self::Output;
-    fn visit_char(&mut self, c: char) -> Self::Output;
-    fn visit_immutable_vector(&mut self, vector: &'a SteelVector) -> Self::Output;
-    fn visit_void(&mut self) -> Self::Output;
-    fn visit_string(&mut self, string: &'a SteelString) -> Self::Output;
-    fn visit_function_pointer(&mut self, ptr: FunctionSignature) -> Self::Output;
-    fn visit_symbol(&mut self, symbol: &'a SteelString) -> Self::Output;
-    fn visit_custom_type(
-        &mut self,
-        custom_type: &'a Gc<RefCell<Box<dyn CustomType>>>,
-    ) -> Self::Output;
-    fn visit_hash_map(&mut self, hashmap: &'a SteelHashMap) -> Self::Output;
-    fn visit_hash_set(&mut self, hashset: &'a SteelHashSet) -> Self::Output;
-    fn visit_steel_struct(&mut self, steel_struct: &'a Gc<UserDefinedStruct>) -> Self::Output;
-    fn visit_port(&mut self, port: &'a SteelPort) -> Self::Output;
-    fn visit_transducer(&mut self, transducer: &'a Gc<Transducer>) -> Self::Output;
-    fn visit_reducer(&mut self, reducer: &'a Gc<Reducer>) -> Self::Output;
-    fn visit_future_function(&mut self, function: &'a BoxedAsyncFunctionSignature) -> Self::Output;
-    fn visit_future(&mut self, future: &'a Gc<FutureResult>) -> Self::Output;
-    fn visit_stream(&mut self, stream: &'a Gc<LazyStream>) -> Self::Output;
-    fn visit_boxed_function(&mut self, function: &'a Rc<BoxedDynFunction>) -> Self::Output;
-    fn visit_continuation(&mut self, continuation: &'a Continuation) -> Self::Output;
-    fn visit_list(&mut self, list: &'a List<SteelVal>) -> Self::Output;
-    fn visit_mutable_function(&mut self, function: &'a MutFunctionSignature) -> Self::Output;
-    fn visit_mutable_vector(&mut self, vector: &'a HeapRef<Vec<SteelVal>>) -> Self::Output;
-    fn visit_builtin_function(&mut self, function: &'a BuiltInSignature) -> Self::Output;
-    fn visit_boxed_iterator(&mut self, iterator: &'a Gc<RefCell<OpaqueIterator>>) -> Self::Output;
-    fn visit_syntax_object(&mut self, syntax_object: &'a Gc<Syntax>) -> Self::Output;
-    fn visit_boxed_value(&mut self, boxed_value: &'a Gc<RefCell<SteelVal>>) -> Self::Output;
-    fn visit_reference_value(
-        &mut self,
-        reference: &'a Rc<OpaqueReference<'static>>,
-    ) -> Self::Output;
-    fn visit_bignum(&mut self, bignum: &'a Gc<BigInt>) -> Self::Output;
-    fn visit_heap_allocated(&mut self, heap_ref: &'a HeapRef<SteelVal>) -> Self::Output;
-    fn visit_pair(&mut self, pair: &'a Gc<Pair>) -> Self::Output;
-}
-
-thread_local! {
-    static LEFT_QUEUE: RefCell<Vec<SteelVal>> = RefCell::new(Vec::with_capacity(128));
-    static RIGHT_QUEUE: RefCell<Vec<SteelVal>> = RefCell::new(Vec::with_capacity(128));
-    static VISITED_SET: RefCell<fxhash::FxHashSet<usize>> = RefCell::new(fxhash::FxHashSet::default());
-    static EQ_DEPTH: Cell<usize> = Cell::new(0);
-}
-
-fn increment_eq_depth() {
-    #[cfg(feature = "sandbox")]
-    EQ_DEPTH.with(|x| x.set(x.get() + 1));
-}
-
-fn decrement_eq_depth() {
-    #[cfg(feature = "sandbox")]
-    EQ_DEPTH.with(|x| x.set(x.get() - 1));
-}
-
-fn reset_eq_depth() {
-    #[cfg(feature = "sandbox")]
-    EQ_DEPTH.with(|x| x.set(0));
-}
-
-fn eq_depth() -> usize {
-    #[cfg(feature = "sandbox")]
-    return EQ_DEPTH.with(|x| x.get());
-
-    #[cfg(not(feature = "sandbox"))]
-    0
-}
-
-struct RecursiveEqualityHandler<'a> {
-    left: EqualityVisitor<'a>,
-    right: EqualityVisitor<'a>,
-    visited: &'a mut fxhash::FxHashSet<usize>,
-    // found_mutable_object: bool,
-}
-
-impl<'a> RecursiveEqualityHandler<'a> {
-    pub fn compare_equality(&mut self, left: SteelVal, right: SteelVal) -> bool {
-        self.left.push_back(left);
-        self.right.push_back(right);
-
-        self.visit()
-    }
-
-    fn should_visit(&mut self, value: usize) -> bool {
-        // if !self.found_mutable_object {
-        // return true;
-        // }
-
-        if self.visited.insert(value) {
-            return true;
-        }
-
-        return false;
-    }
-
-    fn visit(&mut self) -> bool {
-        loop {
-            let (left, right) = match (self.left.pop_front(), self.right.pop_front()) {
-                (Some(l), Some(r)) => (l, r),
-                (None, None) => return true,
-                _ => return false,
-            };
-
-            // println!("{} - {}", left, right);
-
-            // println!(
-            //     "Queue size: {:?}",
-            //     self.left.queue.len(),
-            //     // self.right.queue.len()
-            // );
-
-            match (left, right) {
-                (ListV(l), ListV(r)) => {
-                    // If we've reached the same object, we're good
-                    if l.ptr_eq(&r) || l.storage_ptr_eq(&r) {
-                        continue;
-                    }
-
-                    if self.should_visit(l.elements_as_ptr_usize())
-                        && self.should_visit(r.elements_as_ptr_usize())
-                    {
-                        if l.len() != r.len() {
-                            return false;
-                        }
-
-                        for (lvalue, rvalue) in l.iter().zip(r.iter()) {
-                            // TODO: @Matt - need to do optimistic checks here so we don't
-                            // visit things we don't need to - basically a "check left" function
-                            match (lvalue, rvalue) {
-                                (SteelVal::ListV(llist), SteelVal::ListV(rlist))
-                                    if (llist.is_empty() && rlist.is_empty())
-                                        || llist.ptr_eq(&rlist)
-                                        || llist.storage_ptr_eq(&rlist) =>
-                                {
-                                    continue;
-                                }
-                                // (SteelVal::ListV(llist), SteelVal::ListV(rlist)) if llist.len() == 1 && rlist.len() == 1 {
-
-                                // }
-                                (a, b) => {
-                                    // println!("Pushing back: {}", a);
-
-                                    self.left.push_back(a.clone());
-                                    self.right.push_back(b.clone());
-                                }
-                            }
-                        }
-                    }
-
-                    continue;
-                }
-                // If we run into issues with any stack overflow
-                // check here first.
-                (Pair(l), Pair(r)) => {
-                    if Gc::ptr_eq(&l, &r) {
-                        continue;
-                    }
-
-                    self.left.push_back(l.car());
-                    self.right.push_back(r.car());
-
-                    self.left.push_back(l.cdr());
-                    self.right.push_back(r.cdr());
-                }
-                (BoolV(l), BoolV(r)) => {
-                    if l != r {
-                        return false;
-                    }
-
-                    continue;
-                }
-                (NumV(l), NumV(r)) => {
-                    if l != r {
-                        return false;
-                    }
-
-                    continue;
-                }
-                (IntV(l), IntV(r)) => {
-                    if l != r {
-                        return false;
-                    }
-
-                    continue;
-                }
-                (CharV(l), CharV(r)) => {
-                    if l != r {
-                        return false;
-                    }
-
-                    continue;
-                }
-                (VectorV(l), VectorV(r)) => {
-                    if l.len() != r.len() {
-                        return false;
-                    }
-
-                    // If these point to the same object, break early
-                    if Gc::ptr_eq(&l.0, &r.0) {
-                        continue;
-                    }
-
-                    // Should we visit these?
-                    if self.should_visit(l.0.as_ptr() as usize)
-                        && self.should_visit(r.0.as_ptr() as usize)
-                    {
-                        self.left.visit_immutable_vector(l);
-                        self.right.visit_immutable_vector(r);
-                    } else {
-                        return false;
-                    }
-
-                    continue;
-                }
-                (Void, Void) => {
-                    continue;
-                }
-                (StringV(l), StringV(r)) => {
-                    if l != r {
-                        return false;
-                    }
-                    continue;
-                }
-                (FuncV(l), FuncV(r)) => {
-                    if l as usize != r as usize {
-                        return false;
-                    }
-                    continue;
-                }
-                (SymbolV(l), SymbolV(r)) => {
-                    if l != r {
-                        return false;
-                    }
-                    continue;
-                }
-                (SteelVal::Custom(l), SteelVal::Custom(r)) => {
-                    if l.borrow().inner_type_id() != r.borrow().inner_type_id() {
-                        return false;
-                    }
-
-                    if l.borrow().check_equality_hint(r.borrow().as_ref()) {
-                        // Go down to the next level
-                        self.left.visit_custom_type(l);
-                        self.right.visit_custom_type(r);
-                        continue;
-                    } else {
-                        return false;
-                    }
-                }
-                (SteelVal::HashMapV(l), SteelVal::HashMapV(r)) => {
-                    if Gc::ptr_eq(&l.0, &r.0) {
-                        println!("Found ptr equality");
-
-                        continue;
-                    }
-
-                    if self.should_visit(l.0.as_ptr() as usize)
-                        && self.should_visit(r.0.as_ptr() as usize)
-                    {
-                        if l.len() != r.len() {
-                            return false;
-                        }
-
-                        // TODO: Implicitly here we are assuming that this key was even hashable
-                        // to begin with, since it ended up in the right spot, and didn't blow
-                        // the stack on a recursive structure.
-                        //
-                        // This still does not handle the pathological edge case of something like
-                        // (hash (hash (hash ...) value) value)
-                        //
-                        // In this case, we'll get a stack overflow, when trying to compare equality
-                        // with these maps if they're sufficiently deep.
-                        //
-                        // The issue is that if the two maps are equivalent, we need to check the
-                        // existence of each key in the left map with each key in the right map.
-                        // Doing so invokes an equality check, where we'll then invoke this logic
-                        // again. We could solve this by disallowing hashmaps as keys - then
-                        // we would not the same issue where putting a hashmap into the map
-                        // causes the equality checks to go off the rails.
-
-                        if eq_depth() > 512 {
-                            log::error!("Aborting eq checks before the stack overflows");
-
-                            return false;
-                        }
-
-                        for (key, value) in l.0.iter() {
-                            if let Some(right_value) = r.0.get(key) {
-                                self.left.push_back(value.clone());
-                                self.right.push_back(right_value.clone());
-                            } else {
-                                // We know that these are not equal, because the
-                                // key in the left map does not exist in the right
-                                return false;
-                            }
-                        }
-                    }
-
-                    continue;
-                }
-                (HashSetV(l), HashSetV(r)) => {
-                    if Gc::ptr_eq(&l.0, &r.0) {
-                        continue;
-                    }
-
-                    if self.should_visit(l.0.as_ptr() as usize)
-                        && self.should_visit(r.0.as_ptr() as usize)
-                    {
-                        if l.len() != r.len() {
-                            return false;
-                        }
-                        if eq_depth() > 512 {
-                            log::error!("Aborting eq checks before the stack overflows");
-
-                            return false;
-                        }
-
-                        for key in l.0.iter() {
-                            if !l.0.contains(key) {
-                                return false;
-                            }
-                        }
-                    }
-
-                    continue;
-                }
-                (CustomStruct(l), CustomStruct(r)) => {
-                    // If these are the same object, just continue
-                    if Gc::ptr_eq(&l, &r) {
-                        continue;
-                    }
-
-                    if self.should_visit(l.as_ptr() as usize)
-                        && self.should_visit(r.as_ptr() as usize)
-                    {
-                        // Check the top level equality indicators to make sure
-                        // that these two types are the same
-                        if !(l.type_descriptor == r.type_descriptor && l.name() == r.name()) {
-                            return false;
-                        }
-
-                        self.left.visit_steel_struct(l);
-                        self.right.visit_steel_struct(r);
-                    }
-
-                    continue;
-                }
-                // (PortV(_), PortV(_)) => {
-                // return
-                // }
-                (IterV(l), IterV(r)) => {
-                    self.left.visit_transducer(l);
-                    self.right.visit_transducer(r);
-
-                    continue;
-                }
-                (ReducerV(l), ReducerV(r)) => {
-                    self.left.visit_reducer(l);
-                    self.right.visit_reducer(r);
-
-                    continue;
-                }
-                // FutureV(f) => self.visit_future(f),
-                (ContinuationFunction(l), ContinuationFunction(r)) => {
-                    if !Continuation::ptr_eq(&l, &r) {
-                        return false;
-                    }
-
-                    continue;
-                }
-                // MutFunc(m) => self.visit_mutable_function(m),
-                (BuiltIn(l), BuiltIn(r)) => {
-                    if l as usize != r as usize {
-                        return false;
-                    }
-                    continue;
-                }
-                // MutableVector(b) => self.visit_mutable_vector(b),
-                // BoxedIterator(b) => self.visit_boxed_iterator(b),
-                // SteelVal::SyntaxObject(s) => self.visit_syntax_object(s),
-                // Boxed(b) => self.visit_boxed_value(b),
-                // Reference(r) => self.visit_reference_value(r),
-                (BigNum(l), BigNum(r)) => {
-                    if l != r {
-                        return false;
-                    }
-                    continue;
-                }
-                (SyntaxObject(l), SyntaxObject(r)) => {
-                    if Gc::ptr_eq(&l, &r) {
-                        continue;
-                    }
-
-                    self.left.visit_syntax_object(l);
-                    self.right.visit_syntax_object(r);
-
-                    continue;
-                }
-                (HeapAllocated(l), HeapAllocated(r)) => {
-                    if HeapRef::ptr_eq(&l, &r) {
-                        continue;
-                    }
-
-                    self.left.visit_heap_allocated(l);
-                    self.right.visit_heap_allocated(r);
-
-                    continue;
-                }
-
-                (MutableVector(l), MutableVector(r)) => {
-                    if HeapRef::ptr_eq(&l, &r) {
-                        continue;
-                    }
-
-                    self.left.visit_mutable_vector(l);
-                    self.right.visit_mutable_vector(r);
-
-                    continue;
-                }
-                (Closure(l), Closure(r)) => {
-                    if l != r {
-                        return false;
-                    }
-
-                    self.left.visit_closure(l);
-                    self.right.visit_closure(r);
-
-                    continue;
-                }
-                (_, _) => {
-                    return false;
-                }
-            }
-
-            // unreachable!();
-        }
-    }
-}
-
-// TODO: This _needs_ to use references. Or otherwise we'll thrash stuff on drop
-pub struct EqualityVisitor<'a> {
-    // Mark each node that we've visited, if we encounter any mutable objects
-    // on the way, then we'll start using the visited set. But we'll optimistically
-    // assume that there are no mutable objects, and we won't start using this
-    // until we absolutely have to.
-    // found_mutable_object: bool,
-    queue: &'a mut Vec<SteelVal>,
-}
-
-impl<'a> BreadthFirstSearchSteelValVisitor for EqualityVisitor<'a> {
-    type Output = ();
-
-    fn default_output(&mut self) -> Self::Output {}
-
-    fn pop_front(&mut self) -> Option<SteelVal> {
-        self.queue.pop()
-    }
-
-    fn push_back(&mut self, value: SteelVal) {
-        self.queue.push(value)
-    }
-
-    fn visit_closure(&mut self, _closure: Gc<ByteCodeLambda>) -> Self::Output {}
-
-    // Leaf nodes, we don't need to do anything here
-    fn visit_bool(&mut self, _boolean: bool) -> Self::Output {}
-    fn visit_float(&mut self, _float: f64) -> Self::Output {}
-    fn visit_int(&mut self, _int: isize) -> Self::Output {}
-    fn visit_char(&mut self, _c: char) -> Self::Output {}
-    fn visit_void(&mut self) -> Self::Output {}
-    fn visit_string(&mut self, _string: SteelString) -> Self::Output {}
-    fn visit_function_pointer(&mut self, _ptr: FunctionSignature) -> Self::Output {}
-    fn visit_symbol(&mut self, _symbol: SteelString) -> Self::Output {}
-    fn visit_port(&mut self, _port: SteelPort) -> Self::Output {}
-    fn visit_boxed_function(&mut self, _function: Rc<BoxedDynFunction>) -> Self::Output {}
-    fn visit_mutable_function(&mut self, _function: MutFunctionSignature) -> Self::Output {}
-    fn visit_builtin_function(&mut self, _function: BuiltInSignature) -> Self::Output {}
-
-    //
-    fn visit_immutable_vector(&mut self, vector: SteelVector) -> Self::Output {
-        // If we've found the mutable object, mark that this has been visited. Only
-        // if self.should_visit(vector.0.as_ptr() as usize) {
-        for value in vector.iter() {
-            self.push_back(value.clone());
-        }
-        // }
-    }
-
-    // SHOULD SET MUTABLE HERE
-    fn visit_custom_type(&mut self, custom_type: Gc<RefCell<Box<dyn CustomType>>>) -> Self::Output {
-        custom_type.borrow().visit_children_for_equality(self);
-    }
-
-    fn visit_hash_map(&mut self, _hashmap: SteelHashMap) -> Self::Output {
-        // TODO: See comment above
-    }
-
-    fn visit_hash_set(&mut self, _hashset: SteelHashSet) -> Self::Output {
-        // TODO: See comment above
-    }
-
-    fn visit_steel_struct(&mut self, steel_struct: Gc<UserDefinedStruct>) -> Self::Output {
-        // if self.should_visit(steel_struct.as_ptr() as usize) {
-        for value in steel_struct.fields.iter() {
-            self.push_back(value.clone());
-        }
-        // }
-    }
-
-    fn visit_transducer(&mut self, transducer: Gc<Transducer>) -> Self::Output {
-        for transducer in transducer.ops.iter() {
-            match transducer.clone() {
-                crate::values::transducers::Transducers::Map(m) => self.push_back(m),
-                crate::values::transducers::Transducers::Filter(v) => self.push_back(v),
-                crate::values::transducers::Transducers::Take(t) => self.push_back(t),
-                crate::values::transducers::Transducers::Drop(d) => self.push_back(d),
-                crate::values::transducers::Transducers::FlatMap(fm) => self.push_back(fm),
-                crate::values::transducers::Transducers::Flatten => {}
-                crate::values::transducers::Transducers::Window(w) => self.push_back(w),
-                crate::values::transducers::Transducers::TakeWhile(tw) => self.push_back(tw),
-                crate::values::transducers::Transducers::DropWhile(dw) => self.push_back(dw),
-                crate::values::transducers::Transducers::Extend(e) => self.push_back(e),
-                crate::values::transducers::Transducers::Cycle => {}
-                crate::values::transducers::Transducers::Enumerating => {}
-                crate::values::transducers::Transducers::Zipping(z) => self.push_back(z),
-                crate::values::transducers::Transducers::Interleaving(i) => self.push_back(i),
-            }
-        }
-    }
-
-    fn visit_reducer(&mut self, reducer: Gc<Reducer>) -> Self::Output {
-        match reducer.as_ref().clone() {
-            Reducer::ForEach(f) => self.push_back(f),
-            Reducer::Generic(rf) => {
-                self.push_back(rf.initial_value);
-                self.push_back(rf.function);
-            }
-            _ => {}
-        }
-    }
-
-    fn visit_future_function(&mut self, _function: BoxedAsyncFunctionSignature) -> Self::Output {}
-    fn visit_future(&mut self, _future: Gc<FutureResult>) -> Self::Output {}
-    fn visit_bignum(&mut self, _bignum: Gc<BigInt>) -> Self::Output {}
-
-    fn visit_stream(&mut self, _stream: Gc<LazyStream>) -> Self::Output {}
-
-    fn visit_continuation(&mut self, _continuation: Continuation) -> Self::Output {}
-
-    fn visit_list(&mut self, list: List<SteelVal>) -> Self::Output {
-        for value in list.iter() {
-            self.push_back(value.clone());
-        }
-    }
-
-    fn visit_mutable_vector(&mut self, vector: HeapRef<Vec<SteelVal>>) -> Self::Output {
-        for value in vector.get().iter() {
-            self.push_back(value.clone());
-        }
-    }
-
-    fn visit_boxed_iterator(&mut self, _iterator: Gc<RefCell<OpaqueIterator>>) -> Self::Output {}
-
-    fn visit_syntax_object(&mut self, syntax_object: Gc<Syntax>) -> Self::Output {
-        if let Some(raw) = syntax_object.raw.clone() {
-            self.push_back(raw);
-        }
-
-        self.push_back(syntax_object.syntax.clone());
-    }
-
-    fn visit_boxed_value(&mut self, boxed_value: Gc<RefCell<SteelVal>>) -> Self::Output {
-        self.push_back(boxed_value.borrow().clone());
-    }
-
-    fn visit_reference_value(&mut self, _reference: Rc<OpaqueReference<'static>>) -> Self::Output {}
-
-    // Should set mutable here
-    fn visit_heap_allocated(&mut self, heap_ref: HeapRef<SteelVal>) -> Self::Output {
-        // self.found_mutable_object = true;
-
-        // if self.should_visit(heap_ref.as_ptr_usize()) {
-        self.push_back(heap_ref.get());
-        // }
-    }
-
-    fn visit_pair(&mut self, pair: Gc<Pair>) -> Self::Output {
-        self.push_back(pair.car());
-        self.push_back(pair.cdr());
-    }
-}
-
-impl PartialEq for SteelVal {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Void, Void) => true,
-            (BoolV(l), BoolV(r)) => l == r,
-            (BigNum(l), BigNum(r)) => l == r,
-            (IntV(l), IntV(r)) => l == r,
-
-            // Floats shouls also be considered equal
-            (NumV(l), NumV(r)) => l == r,
-
-            (StringV(l), StringV(r)) => l == r,
-            // (VectorV(l), VectorV(r)) => l == r,
-            (SymbolV(l), SymbolV(r)) => l == r,
-            (CharV(l), CharV(r)) => l == r,
-            // (ListV(l), ListV(r)) => l == r,
-            // (HashSetV(l), HashSetV(r)) => l == r,
-            // (HashMapV(l), HashMapV(r)) => l == r,
-            // (Closure(l), Closure(r)) => l == r,
-            // (IterV(l), IterV(r)) => l == r,
-            // (ListV(l), ListV(r)) => l == r,
-            // (CustomStruct(l), CustomStruct(r)) => l == r,
-            (FuncV(l), FuncV(r)) => *l as usize == *r as usize,
-            // (Custom(l), Custom(r)) => Gc::ptr_eq(l, r),
-            // (HeapAllocated(l), HeapAllocated(r)) => l.get() == r.get(),
-            (left, right) => LEFT_QUEUE.with(|left_queue| {
-                RIGHT_QUEUE.with(|right_queue| {
-                    VISITED_SET.with(|visited_set| {
-                        match (
-                            left_queue.try_borrow_mut(),
-                            right_queue.try_borrow_mut(),
-                            visited_set.try_borrow_mut(),
-                        ) {
-                            (Ok(mut left_queue), Ok(mut right_queue), Ok(mut visited_set)) => {
-                                let mut equality_handler = RecursiveEqualityHandler {
-                                    left: EqualityVisitor {
-                                        queue: &mut left_queue,
-                                    },
-                                    right: EqualityVisitor {
-                                        queue: &mut right_queue,
-                                    },
-                                    visited: &mut visited_set,
-                                    // found_mutable_object: false,
-                                };
-
-                                let res =
-                                    equality_handler.compare_equality(left.clone(), right.clone());
-
-                                // EQ_DEPTH.with(|x| x.set(0));
-
-                                reset_eq_depth();
-
-                                // Clean up!
-                                equality_handler.left.queue.clear();
-                                equality_handler.right.queue.clear();
-                                equality_handler.visited.clear();
-
-                                res
-                            }
-                            _ => {
-                                let mut left_queue = Vec::new();
-                                let mut right_queue = Vec::new();
-
-                                let mut visited_set = fxhash::FxHashSet::default();
-
-                                // EQ_DEPTH.with(|x| x.set(x.get() + 1));
-
-                                increment_eq_depth();
-
-                                // println!("{}", EQ_DEPTH.with(|x| x.get()));
-
-                                let mut equality_handler = RecursiveEqualityHandler {
-                                    left: EqualityVisitor {
-                                        queue: &mut left_queue,
-                                    },
-                                    right: EqualityVisitor {
-                                        queue: &mut right_queue,
-                                    },
-                                    visited: &mut visited_set,
-                                    // found_mutable_object: false,
-                                };
-
-                                let res =
-                                    equality_handler.compare_equality(left.clone(), right.clone());
-
-                                // EQ_DEPTH.with(|x| x.set(x.get() - 1));
-
-                                decrement_eq_depth();
-
-                                res
-                            }
-                        }
-                    })
-                })
-            }),
-        }
-    }
-}
diff --git a/crates/steel-core/src/scheme/async.rkt b/crates/steel-core/src/scheme/async.rkt
deleted file mode 100644
index 16a1a39fe..000000000
--- a/crates/steel-core/src/scheme/async.rkt
+++ /dev/null
@@ -1,10 +0,0 @@
-(define/contract (block-on future)
-  (->/c future? any/c)
-  (define (loop future)
-    (define output (poll! future))
-    (if (equal? #f output)
-        ;; Here, we would yield to the executor if we were await-ing
-        ;; but we're going to just block until the future is complete
-        (loop future)
-        output))
-  (loop future))
\ No newline at end of file
diff --git a/crates/steel-core/src/scheme/contract.rkt b/crates/steel-core/src/scheme/contract.rkt
deleted file mode 100644
index 4bdcc0fdf..000000000
--- a/crates/steel-core/src/scheme/contract.rkt
+++ /dev/null
@@ -1,39 +0,0 @@
-; ;; Contract combinators
-; (define (listof pred)
-;         (lambda (lst)
-;             (define (loop lst)
-;                 (cond [(null? lst) #t]
-;                       [(pred (car lst)) (loop (cdr lst))]
-;                       [else #f]))
-;             (cond [(null? lst) #t]
-;                   [(list? lst)
-;                     (loop lst)]
-;                   [else #f])))
-
-; ;; Contracts for <
-; (define (</c n)
-;     (make/c (fn (x) (< x n)) (list '</c n)))
-
-; ;; Contracts for >
-; (define (>/c n)
-;     (make/c (fn (x) (> x n)) (list '>/c n)))
-
-; ;; Contracts for <=
-; (define (<=/c n)
-;     (make/c (fn (x) (<= x n)) (list '<=/c n)))
-
-; ;; Contracts for >=
-; (define (>=/c n)
-;     (make/c (fn (x) (>= x n)) (list '>=/c n)))
-
-; ;; Satisfies any single value
-; (define (any/c x)
-;     (make/c (fn (x) #t) 'any/c))
-
-; ;; produces a function compatible with contract definitions
-; (define (and/c x y)
-;     (lambda (z) (and (x z) (y z))))
-
-; ;; produces a function compatible with contract definitions
-; (define (or/c x y)
-;     (lambda (z) (or (x z) (y z))))
diff --git a/crates/steel-core/src/scheme/display.rkt b/crates/steel-core/src/scheme/display.rkt
deleted file mode 100644
index 2dd768405..000000000
--- a/crates/steel-core/src/scheme/display.rkt
+++ /dev/null
@@ -1,31 +0,0 @@
-; (define (displayln object) 
-;   (display object)
-;   (newline))
-
-; (define/contract (struct-name s)
-;   (->/c custom-struct? symbol?)
-;   (mut-vector-ref s 1))
-
-; (define/contract (struct-transparent? s)
-;   (->/c custom-struct? boolean?)
-;   (hash-try-get (mut-vector-ref s 2) #:transparent))
-
-; (define (displayln . rest)
-;   (transduce rest
-;              (into-for-each (lambda (x) (display " "))))
-;   (newline))
-
-; (displayln "hello" "world" "this" "is" "multiple" "values")
-
-; (make-struct Applesauce (a b c))
-
-(define println simple-displayln)
-  ; (displayln 
-  ;   (if (custom-struct? x)
-  ;     (if (struct-transparent? x)
-  ;         (cons (struct-name x) (transduce x (into-list)))
-  ;         (string-append "#<"
-  ;                       (string-append
-  ;                         (symbol->string (struct-name x))
-  ;                       ">")))
-  ;     x)))
diff --git a/crates/steel-core/src/scheme/kernel-lambda.scm b/crates/steel-core/src/scheme/kernel-lambda.scm
deleted file mode 100644
index cf43b24eb..000000000
--- a/crates/steel-core/src/scheme/kernel-lambda.scm
+++ /dev/null
@@ -1,22 +0,0 @@
-; (provide (for-syntax lambda))
-
-; (define-syntax lambda
-;   (syntax-rules ()
-;     [(lambda () expr) (#%plain-lambda () expr)]
-;     [(lambda ()
-;        expr
-;        exprs ...)
-;      (#%plain-lambda () expr exprs ...)]
-;     [(lambda (x) expr) (#%plain-lambda (x) expr)]
-;     [(lambda (x)
-;        expr
-;        exprs ...)
-;      (#%plain-lambda (x) expr exprs ...)]
-;     [(lambda (x xs ...)
-;        expr
-;        exprs ...)
-;      (#%plain-lambda (x xs ...) expr exprs ...)]
-;     [(lambda x
-;        expr
-;        exprs ...)
-;      (#%plain-lambda x expr exprs ...)]))
diff --git a/crates/steel-core/src/scheme/kernel.scm b/crates/steel-core/src/scheme/kernel.scm
deleted file mode 100644
index 58e812edc..000000000
--- a/crates/steel-core/src/scheme/kernel.scm
+++ /dev/null
@@ -1,526 +0,0 @@
-;; The kernel for Steel.
-;; This contains core forms that are expanded during the last phase of macro expansion
-;; Macros that are exported from the kernel and applied on code externally are defined via
-;; the form `(#%define-syntax <macro> <body>)`.
-;;
-;; This makes this function publicly available for the kernel to expand
-;; forms with.
-
-; (define *transformer-functions* (hashset))
-
-;; Compatibility layers for making defmacro not as painful
-(define displayln stdout-simple-displayln)
-
-(define-syntax #%syntax-transformer-module
-  (syntax-rules (provide)
-
-    [(#%syntax-transformer-module name (provide ids ...) funcs ...)
-     (define (datum->syntax name)
-       (let ()
-         funcs ...
-         (#%syntax-transformer-module provide ids ...)))]
-
-    ;; Normal case
-    [(#%syntax-transformer-module provide name) (%proto-hash% 'name name)]
-
-    ;; Normal case
-    [(#%syntax-transformer-module provide name rest ...)
-     (%proto-hash-insert% (#%syntax-transformer-module provide rest ...) 'name name)]))
-
-;; Loading macros via defmacro - there will be a pass where we lower anything with defmacro down to the kernel,
-;; which will then load and register macros accordingly.
-(define-syntax defmacro
-  (syntax-rules ()
-    [(defmacro environment (name arg) expr)
-     (begin
-       (register-macro-transformer! (symbol->string 'name) environment)
-       (define (name arg)
-         expr))]
-
-    [(defmacro environment (name arg) exprs ...)
-     (begin
-       (register-macro-transformer! (symbol->string 'name) environment)
-       (define (name arg)
-         exprs ...))]
-
-    [(defmacro environment name expr)
-     (begin
-       (register-macro-transformer! (symbol->string 'name) environment)
-       (define name expr))]))
-
-(define-syntax #%define-syntax
-  (syntax-rules ()
-
-    [(#%define-syntax (name arg) expr)
-     (begin
-       (register-macro-transformer! (symbol->string 'name) "default")
-       (define (name arg)
-         expr))]
-
-    [(#%define-syntax (name arg)
-       exprs ...)
-     (begin
-       (register-macro-transformer! (symbol->string 'name) "default")
-       (define (name arg)
-         exprs ...))]
-
-    [(#%define-syntax name expr)
-     (begin
-       (register-macro-transformer! (symbol->string 'name) "default")
-       (define name expr))]))
-
-;; Kernal-lambda -> Used in the meantime while `lambda` finds its way out of the reserved keywords.
-(define-syntax klambda
-  (syntax-rules ()
-    [(klambda () expr exprs ...) (#%plain-lambda () expr exprs ...)]
-    [(klambda (x xs ...) expr exprs ...) (#%plain-lambda (x xs ...) expr exprs ...)]
-    [(klambda x expr exprs ...) (#%plain-lambda x expr exprs ...)]))
-
-;; Enumerate the given list starting at index `start`
-(define (enumerate start accum lst)
-  (if (empty? lst)
-      (reverse accum)
-      (enumerate (+ start 1) (cons (list (car lst) start) accum) (cdr lst))))
-
-(define (hash->list hm)
-  (transduce (transduce hm (into-list))
-             (mapping (lambda (pair)
-                        ;; If we have a symbol as a key, that means we need to
-                        ;; quote it before we put it back into the map
-                        (if (symbol? (car pair))
-                            ;; TODO: @Matt - this causes a parser error
-                            ;; (cons `(quote ,(car x)) (cdr x))
-                            (list (list 'quote (car pair)) (cadr pair))
-                            pair)))
-             (flattening)
-             (into-list)))
-
-(define (mutable-keyword? x)
-  (equal? x '#:mutable))
-(define (transparent-keyword? x)
-  (equal? x '#:transparent))
-
-(#%define-syntax (struct expr)
-  (define unwrapped (syntax-e expr))
-  (define struct-name (syntax->datum (second unwrapped)))
-  (define fields (syntax->datum (third unwrapped)))
-  (define options
-    (let ([raw (cdddr unwrapped)])
-      ; (displayln raw)
-      (if (empty? raw) raw (map syntax->datum raw))))
-
-  (struct-impl struct-name fields options))
-
-;; Macro for creating a new struct, in the form of:
-;; `(struct <struct-name> (fields ...) options ...)`
-;; The options can consist of the following:
-;;
-;; Single variable options (those which their presence indicates #true)
-;; - #:mutable
-;; - #:transparent
-;;
-;; Other options must be presented as key value pairs, and will get stored
-;; in the struct instance. They will also be bound to the variable
-;; ___<struct-name>-options___ in the same lexical environment where the
-;; struct was defined. For example:
-;;
-;; (Applesauce (a b c) #:mutable #:transparent #:unrecognized-option 1234)
-;;
-;; Will result in the value `___Applesauce-options___` like so:
-;; (hash #:mutable #true #:transparent #true #:unrecognized-option 1234)
-;;
-;; By default, structs are immutable, which means setter functions will not
-;; be generated. Also by default, structs are not transparent, which means
-;; printing them will result in an opaque struct that does not list the fields
-(define (struct-impl struct-name fields options)
-
-  ;; Add a field for storing the options, and for the index to the func
-  (define field-count (length fields))
-  ;; Mark whether this is actually a mutable and transparent struct, and
-  ;; then drain the values from the
-  (define mutable? (contains? mutable-keyword? options))
-  (define transparent? (contains? transparent-keyword? options))
-
-  (define options-without-single-keywords
-    (transduce options
-               (filtering (lambda (x) (not (mutable-keyword? x))))
-               (filtering (lambda (x) (not (transparent-keyword? x))))
-               (into-list)))
-
-  (define default-printer-function
-    (if transparent?
-        `(lambda (obj printer-function)
-           (display "(")
-           (display (symbol->string ,(list 'quote struct-name)))
-           ,@(map (lambda (field)
-                    `(begin
-                       (display " ")
-                       (printer-function (,(concat-symbols struct-name '- field) obj))))
-                  fields)
-
-           (display ")"))
-
-        #f))
-
-  ;; Set up default values to go in the table
-  (define extra-options
-    (hash '#:mutable
-          mutable?
-          '#:transparent
-          transparent?
-          '#:fields
-          (list 'quote fields)
-          '#:name
-          (list 'quote struct-name)))
-
-  (when (not (list? fields))
-    (error! "struct expects a list of field names, found " fields))
-
-  (when (not (symbol? struct-name))
-    (error! "struct expects an identifier as the first argument, found " struct-name))
-
-  (when (odd? (length options-without-single-keywords))
-    (error! "struct options are malformed - each option requires a value"))
-
-  ;; Update the options-map to have the fields included
-  (let* ([options-map (apply hash options-without-single-keywords)]
-         [options-map (hash-union options-map extra-options)]
-         [options-map (if (hash-try-get options-map '#:printer)
-                          options-map
-                          (hash-insert options-map '#:printer default-printer-function))]
-         [maybe-procedure-field (hash-try-get options-map '#:prop:procedure)])
-
-    (when (and maybe-procedure-field (> maybe-procedure-field (length fields)))
-      (error! "struct #:prop:procedure cannot refer to an index that is out of bounds"))
-
-    `(begin
-       ; (#%black-box "STRUCT" (quote ,struct-name))
-       (define ,(concat-symbols '___ struct-name '-options___)
-         (hash ,@(hash->list options-map)))
-       (define ,struct-name 'unintialized)
-       (define ,(concat-symbols 'struct: struct-name)
-         'uninitialized)
-       (define ,(concat-symbols struct-name '?)
-         'uninitialized)
-       ,@(map (lambda (field)
-                `(define ,(concat-symbols struct-name '- field)
-                   'uninitialized))
-              fields)
-       ;; If we're mutable, set up the identifiers to later be `set!`
-       ;; below in the same scope
-       ,@(if mutable?
-             (map (lambda (field)
-                    `(define ,(concat-symbols 'set- struct-name '- field '!)
-                       'unintialized))
-                  fields)
-             (list))
-
-       ;; TODO: Change this to plain let to see the error
-       (%plain-let
-        ([prototypes (make-struct-type (quote ,struct-name) ,field-count)])
-        (%plain-let
-         ([struct-type-descriptor (list-ref prototypes 0)] [constructor-proto (list-ref prototypes 1)]
-                                                           [predicate-proto (list-ref prototypes 2)]
-                                                           [getter-proto (list-ref prototypes 3)])
-         (set! ,(concat-symbols 'struct: struct-name) struct-type-descriptor)
-         (#%vtable-update-entry! struct-type-descriptor
-                                 ,maybe-procedure-field
-                                 ,(concat-symbols '___ struct-name '-options___))
-         ,(if mutable?
-              `(set! ,struct-name
-                     (lambda ,fields (constructor-proto ,@(map (lambda (x) `(#%box ,x)) fields))))
-
-              `(set! ,struct-name constructor-proto))
-         ,(new-make-predicate struct-name fields)
-         ,@
-         (if mutable? (mutable-make-getters struct-name fields) (new-make-getters struct-name fields))
-         ;; If this is a mutable struct, generate the setters
-         ,@(if mutable? (mutable-make-setters struct-name fields) (list))
-         void)))))
-
-(define (new-make-predicate struct-name fields)
-  `(set! ,(concat-symbols struct-name '?) predicate-proto))
-
-; (define (new-make-constructor struct-name procedure-index fields)
-;   `(set!
-;     ,struct-name
-;     (lambda ,fields
-;       (constructor-proto ,(concat-symbols '___ struct-name '-options___) ,procedure-index ,@fields))))
-
-(define (mutable-make-getters struct-name fields)
-  (map (lambda (field)
-         `(set! ,(concat-symbols struct-name '- (car field))
-                (lambda (this) (#%unbox (getter-proto this ,(list-ref field 1))))))
-       (enumerate 0 '() fields)))
-
-(define (mutable-make-setters struct-name fields)
-  (map (lambda (field)
-         `(set! ,(concat-symbols 'set- struct-name '- (car field) '!)
-                (lambda (this value) (#%set-box! (getter-proto this ,(list-ref field 1)) value))))
-       (enumerate 0 '() fields)))
-
-(define (new-make-getters struct-name fields)
-  (map (lambda (field)
-         `(set! ,(concat-symbols struct-name '- (car field))
-                (lambda (this) (getter-proto this ,(list-ref field 1)))))
-       (enumerate 0 '() fields)))
-
-(define (new-make-setters struct-name fields)
-  (map (lambda (field)
-         `(set! ,(concat-symbols 'set- struct-name '- (car field) '!)
-                (lambda (this value) (setter-proto this ,(list-ref field 1) value))))
-       (enumerate 0 '() fields)))
-
-(define (%make-memoize f)
-  (lambda n
-    (let ([previous-value (%memo-table-ref %memo-table f n)])
-      (if (and (Ok? previous-value) (Ok->value previous-value))
-          (begin
-            ; (displayln "READ VALUE: " previous-value " with args " n)
-            (Ok->value previous-value))
-          (let ([new-value (apply f n)])
-            ; (displayln "SETTING VALUE " new-value " with args " n)
-            (%memo-table-set! %memo-table f n new-value)
-            new-value)))))
-
-(define *gensym-counter* 0)
-(define (gensym)
-  (set! *gensym-counter* (+ 1 *gensym-counter*))
-  (string->symbol (string-append "##gensym" (to-string *gensym-counter*))))
-
-;; TODO: @Matt -> for whatever reason, using ~> plus (lambda (x) ...) generates a stack overflow... look into that
-(define (make-unreadable symbol)
-  (~>> symbol (symbol->string) (string-append "##") (string->symbol)))
-
-; (define (define-values bindings expr)
-;   `(begin
-;      (define ,(make-unreadable '#%proto-define-values-binding-gensym__)
-;        ,expr)
-;      ,@(map (lambda (binding-index-pair)
-;               `(define ,(car binding-index-pair)
-;                  ,(list-ref binding-index-pair 1)))
-;             (enumerate 0 '() bindings))))
-
-(#%define-syntax (define-values expr)
-  ; (displayln expr)
-  (define underlying (syntax-e expr))
-  (define bindings (syntax->datum (second underlying)))
-  (define expression (third underlying))
-
-  (define unreadable-list-name (make-unreadable '#%proto-define-values-binding-gensym__))
-
-  `(begin
-     (define ,unreadable-list-name ,expression)
-     ,@(map (lambda (binding-index-pair)
-              `(define ,(car binding-index-pair)
-                 (list-ref ,unreadable-list-name ,(list-ref binding-index-pair 1))))
-            (enumerate 0 '() bindings))))
-
-(#%define-syntax (#%better-lambda expr)
-  ; (displayln "Expanding: " expr)
-  ; (displayln "unwrapping one level..." (syntax-e expr))
-  (quasisyntax (list 10 20 30)))
-
-;; TODO: make this not so suspect, but it does work!
-(#%define-syntax (#%current-kernel-transformers expr)
-  (cons 'list (map (lambda (x) (list 'quote x)) (current-macro-transformers!))))
-
-(#%define-syntax (#%fake-lambda expr)
-  (define underlying (syntax-e expr))
-  (define rest (cdr underlying))
-  ; (displayln rest)
-  ; (displayln (syntax-e (list-ref rest 1)))
-  (cons '#%plain-lambda rest))
-
-;; Implement defmacro!
-;; Defmacro: Load functions that operate on syntax, directly into the kernel.
-;; And then, call those as such in the kernel via transformers.
-
-; (#%define-syntax )
-
-;; TODO: Come back to this once theres something to attach it to
-; (define (@doc expr comment)
-;   (if (equal? (car expr) 'define)
-;       `(begin
-;           (define ,(concat-symbols '__doc- (second expr)) ,comment)
-;           ,expr
-;        )
-;        expr))
-
-;; TODO: This is going to fail simply because when re-reading in the body of
-;; expanded functions. The parser is unable to parse already made un-parseable
-;; items. In this case, we should not re-parse the items, but rather
-;; convert the s-expression BACK into a typed ast instead.
-; (define (default-loop args found-pair)
-;   (cond [(empty? args) #f]
-;         [(pair? (car args)) (default-loop (cdr args) #t)]
-;         [else
-;          (if found-pair
-;              #t
-;              (default-loop (cdr args) #f))]))
-
-; (define (non-default-after-default? args)
-;   (default-loop args #f))
-
-; (define (%test-lambda% args body)
-;                                         ;   (->/c non-default-after-default? any/c any/c)
-;   (when (non-default-after-default? args)
-;     (error! "Non default argument occurs after a default argument"))
-;   (let (
-;         (args-len (length args))
-;         (non-default-bindings (filter (lambda (x) (not (pair? x))) args))
-;         (bindings
-;          (transduce
-;           ;; Now we have attached the index of the list to the iteration
-;           args
-;           ;; extract out the arguments that have a default associated
-;           ;; So from the argument list like so:
-;           ;; (a b [c <expr>] [d <expr>])
-;           ;; We will get out ([c <expr>] [d <expr>])
-;           (filtering (lambda (x) (pair? x)))
-;           (enumerating)
-;           ;; Map to the let form of (binding expr)
-;           (mapping (lambda (x)
-;                      ;; ( (x, expr), index )
-;                      ;; TODO: clean this up
-;                      (let ((var-name (car (list-ref x 1)))
-;                            (expr (car (cdr (list-ref x 1))))
-;                            (index (car x)))
-;                        `(,var-name (let ((,var-name (try-list-ref !!dummy-rest-arg!! ,index)))
-;                                      (if ,var-name ,var-name ,expr))))))
-;           (into-list))))
-
-;                                         ; (displayln bindings)
-
-;     ;; TODO: Yes I understand this violates the macro writers bill of rights
-;     ;; that being said I'm only doing this as a proof of concept anyway so it can be rewritten
-;     ;; to be simpler and put the weight on the compiler later
-;     (if (equal? args-len (length non-default-bindings))
-;         `(lambda ,args ,body)
-;                                         ; (displayln "hello world")
-;         `(lambda (,@non-default-bindings . !!dummy-rest-arg!!)
-;                                         ;  (displayln !!dummy-rest-arg!!)
-;            (if (> (+ ,(length non-default-bindings) (length !!dummy-rest-arg!!))
-;                   ,args-len)
-;                (error! "Arity mismatch - function expected " ,args-len)
-;                void)
-;            (let (,@bindings) ,body)))))
-
-; (define (keyword? symbol)
-;     (unless (symbol? symbol) (return! #false))
-;     (let ((symbol-as-list (-> symbol (symbol->string) (string->list))))
-;       (and (equal? (list-ref symbol-as-list 0) #\#)
-;            (equal? (list-ref symbol-as-list 1) #\:))))
-
-; (define (keyword? symbol)
-;   (and (symbol? symbol) (-> symbol (symbol->string) (starts-with? "#:"))))
-
-; (define (drop-while pred? lst)
-;   (cond [(empty? lst) lst]
-;         [(pred? (car lst)) (drop-while pred? (cdr lst))]
-;         [else lst]))
-
-; (define (take-while-accum pred? lst accum)
-;   (cond [(empty? lst) accum]
-;         [(pred? (car lst)) (take-while-accum pred? (cdr lst) (cons (car lst) accum))]
-;         [else accum]))
-
-; (define (take-while pred? lst)
-;   (reverse (take-while-accum pred? lst '())))
-
-; (define (all func lst)
-;   (if (null? lst)
-;       #t
-;       (if (func (car lst))
-;           (all func (cdr lst))
-;           #f)))
-
-; (define (contains? pred? lst)
-;                                         ; (displayln lst)
-;   (cond [(empty? lst) #f]
-;         [(pred? (car lst)) #t]
-;         [else (contains? pred? (cdr lst))]))
-
-; (define (contains-keywords? args)
-;   (contains? keyword? args))
-
-; (define (contains-defaults? args)
-;   (contains? pair? args))
-
-; (define (%better-lambda% args body)
-;   (cond [(contains-keywords? args) (%lambda-keyword% args body)]
-;         [(contains-defaults? args) (%test-lambda% args body)]
-;         [else => `(#%plain-lambda ,args ,body)]))
-
-; (define (%lambda-keyword% args body)
-;   ;; TODO: Using define here causes a bug with the internal define expansion
-;                                         ; (define keyword-args (drop-while (lambda (x) (not (keyword? x))) args))
-
-;   (define keyword-args (drop-while (lambda (x) (not (keyword? x))) args))
-;   (when (odd? (length keyword-args))
-;     (error! "keyword arguments malformed - each option requires a value"))
-
-;   (define non-keyword-args (take-while (lambda (x) (not (keyword? x))) args))
-;   (define keyword-map (apply hash keyword-args))
-;   (when (not (all keyword? (hash-keys->list keyword-map)))
-;     (error! "Non keyword arguments found after the first keyword argument"))
-
-;   (define bindings
-;     (transduce
-;      keyword-map
-;      (mapping (lambda (x)
-;                 (let* ((keyword (list-ref x 0))
-;                        (original-var-name (list-ref x 1))
-;                        (expr (if (pair? original-var-name)
-;                                  (list-ref original-var-name 1)
-;                                  original-var-name))
-;                        (var-name (if (pair? original-var-name)
-;                                      (list-ref original-var-name 0)
-;                                      original-var-name)))
-
-;                   `(,var-name (let ((,var-name (hash-try-get !!dummy-rest-arg!! (quote ,keyword))))
-;                                 (if (hash-contains? !!dummy-rest-arg!! (quote ,keyword))
-;                                     ,var-name
-;                                     (if
-;                                      ,(pair? original-var-name)
-;                                      ,expr
-;                                      (error!
-;                                       "Function application missing required keyword argument: "
-;                                       (quote ,keyword)))))))))
-;      (into-list)))
-
-;   `(lambda (,@non-keyword-args . !!dummy-rest-arg!!)
-;      (let ((!!dummy-rest-arg!! (apply hash !!dummy-rest-arg!!)))
-;        (let (,@bindings) ,body))))
-
-; (let ((keyword-args (drop-while (lambda (x) (not (keyword? x))) args))
-;       (non-keyword-args (take-while (lambda (x) (not (keyword? x))) args)))
-;     (when (odd? (length keyword-args))
-;         (error! "keyword arguments malformed - each option requires a value"))
-
-;     (let ((keyword-map (apply hash keyword-args)))
-;         (when (not (all keyword? (hash-keys->list keyword-map)))
-;             (error! "Non keyword arguments found after the first keyword argument"))
-
-;         (let ((bindings
-;                 (transduce
-;                   keyword-map
-;                    (mapping (lambda (x)
-;                         (let* ((keyword (list-ref x 0))
-;                                (original-var-name (list-ref x 1))
-;                                (expr (if (pair? original-var-name) (list-ref original-var-name 1) original-var-name))
-;                                (var-name (if (pair? original-var-name) (list-ref original-var-name 0) original-var-name)))
-
-;                             `(,var-name (let ((,var-name (hash-try-get !!dummy-rest-arg!! (quote ,keyword))))
-;                                           (if (hash-contains? !!dummy-rest-arg!! (quote ,keyword))
-;                                               ,var-name
-;                                               (if
-;                                                 ,(pair? original-var-name)
-;                                                 ,expr
-;                                                 (error! "Function application missing required keyword argument: " (quote ,keyword)))))))))
-;                    (into-list))))
-;             `(lambda (,@non-keyword-args . !!dummy-rest-arg!!)
-;                 (let ((!!dummy-rest-arg!! (apply hash !!dummy-rest-arg!!)))
-;                     (let (,@bindings) ,body)))))))
-
-; (define test (%lambda-keyword% (a b #:transparent [transparent #t]) (if transparent (begin (displayln "hello world") (+ a b)) (+ a b 10))))
diff --git a/crates/steel-core/src/scheme/merge.rkt b/crates/steel-core/src/scheme/merge.rkt
deleted file mode 100644
index c0036f52e..000000000
--- a/crates/steel-core/src/scheme/merge.rkt
+++ /dev/null
@@ -1,49 +0,0 @@
-(export merge-sort)
-
-;;; -----------------------------------------------------------------
-;;; Merge two lists of numbers which are already in increasing order
-
-(define merge-lists
-  (lambda (l1 l2)
-    (if (null? l1)
-        l2
-        (if (null? l2)
-            l1
-            (if (< (car l1) (car l2))
-                (cons (car l1) (merge-lists (cdr l1) l2))
-                (cons (car l2) (merge-lists (cdr l2) l1)))))))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in even positions
-
-(define even-numbers
-  (lambda (l)
-    (if (null? l)
-        '()
-        (if (null? (cdr l))
-            '()
-            (cons (car (cdr l)) (even-numbers (cdr (cdr l))))))))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in odd positions
-
-(define odd-numbers
-  (lambda (l)
-    (if (null? l)
-        '()
-        (if (null? (cdr l))
-            (list (car l))
-            (cons (car l) (odd-numbers (cdr (cdr l))))))))
-
-;;; ---------------------------------------------------------------------
-;;; Use the procedures above to create a simple and efficient merge-sort
-
-(define merge-sort
-  (lambda (l)
-    (if (null? l)
-        l
-        (if (null? (cdr l))
-            l
-            (merge-lists
-             (merge-sort (odd-numbers l))
-             (merge-sort (even-numbers l)))))))
diff --git a/crates/steel-core/src/scheme/methods.rkt b/crates/steel-core/src/scheme/methods.rkt
deleted file mode 100644
index 303999f0e..000000000
--- a/crates/steel-core/src/scheme/methods.rkt
+++ /dev/null
@@ -1,18 +0,0 @@
-(export def-method impl)
-
-(define-syntax def-method
-  (syntax-rules ()
-    [(def-method struct-name (define/method (a this b ...) body ...))
-     (define ((datum->syntax struct-name . a) this b ...)
-       (unless ((datum->syntax struct-name ?) this)
-         (error! (datum->syntax struct-name . a) "method takes a value of" struct-name "given" this))
-       body ...)]))
-
-
-(define-syntax impl
-  (syntax-rules ()
-    [(impl struct-name (define/method (a this b ...) body ...) c ...)
-     (begin (def-method struct-name (define (a this b ...) body ...))
-            (impl struct-name c ...))]
-    [(impl struct-name (define/method (a this b ...) body ...))
-     (def-method struct-name (define (a this b ...) body ...))]))
diff --git a/crates/steel-core/src/scheme/modules/contracts.scm b/crates/steel-core/src/scheme/modules/contracts.scm
deleted file mode 100644
index c6cab980a..000000000
--- a/crates/steel-core/src/scheme/modules/contracts.scm
+++ /dev/null
@@ -1,452 +0,0 @@
-(provide make-function/c
-         make/c
-         bind/c
-         FlatContract
-         FlatContract?
-         FlatContract-predicate
-         FlatContract-name
-         FunctionContract
-         FunctionContract?
-         FunctionContract-pre-conditions
-         FunctionContract-post-condition
-         contract->string
-         (for-syntax ->/c)
-         (for-syntax define/contract))
-
-;; struct definitions
-(struct FlatContract (predicate name)
-  #:prop:procedure 0
-  #:printer (lambda (obj printer-function) (printer-function (contract->string obj))))
-;; Contract Attachment - use this for understanding where something happened
-(struct ContractAttachmentLocation (type name))
-
-;; Function Contract - keep track of preconditions and post conditions, where
-;; the contract was attached, and a pointer to the parent contract. Can probably
-;; replace parent with just a list of the parents since it can be shared
-;; directly
-(struct FunctionContract (pre-conditions post-condition contract-attachment-location parents)
-  #:printer (lambda (obj printer-function) (printer-function (contract->string obj))))
-
-(struct DependentPair (argument-name arguments thunk thunk-name))
-
-(struct DependentContract
-        (arg-positions pre-conditions post-condition contract-attachment-location parent))
-
-;; TODO: Raise error with contract violation directly attached, if possible
-;;
-(struct ContractViolation (error-message))
-
-(struct ContractedFunction (contract function name))
-
-;; Alias the name for clarity
-(define make-flat-contract FlatContract)
-
-;; Formats a contract nicely as a string
-(define (contract->string contract)
-  (cond
-    [(FlatContract? contract)
-     =>
-     (symbol->string (FlatContract-name contract))]
-    [(FunctionContract? contract)
-     =>
-     (to-string "(->"
-                (apply to-string
-                       (transduce (FunctionContract-pre-conditions contract)
-                                  (mapping contract->string)
-                                  (into-list)))
-                (contract->string (FunctionContract-post-condition contract))
-                ")")]
-    [else
-     =>
-     (error! "Unexpected value found in contract:" contract)]))
-
-;; Given a list, splits off the last argument, returns as a pair
-(define (split-last lst)
-  (define (loop accum lst)
-    (if (empty? (cdr lst)) (list (reverse accum) (car lst)) (loop (cons (car lst) accum) (cdr lst))))
-  (loop '() lst))
-
-;;@doc
-;; Creates a `FunctionContract` from the list of conditions, splitting out the
-;; preconditions and the postconditions
-(define make-function/c
-  (lambda conditions
-    (let ([split (split-last conditions)]) (FunctionContract (first split) (second split) void '()))))
-
-;; Applies a flat contract to the given argument
-(define (apply-flat-contract flat-contract arg)
-  ; ((FlatContract-predicate flat-contract) arg)
-  (if (flat-contract arg)
-      #true
-      (ContractViolation
-       (to-string "Contract violation: found in the application of a flat contract for"
-                  (FlatContract-name flat-contract)
-                  ": the given input:"
-                  arg
-                  "resulted in a contract violation"))))
-
-;; Call a contracted function
-(define (apply-contracted-function contracted-function arguments span)
-  ; (displayln "Passed in span: " span)
-  (define span (if span span '(0 0 0)))
-  (apply-function-contract (ContractedFunction-contract contracted-function)
-                           (ContractedFunction-name contracted-function)
-                           (ContractedFunction-function contracted-function)
-                           arguments
-                           span))
-
-;;@doc
-;; Verifies the arguments against the FunctionContract, and then produces
-;; a new list of arguments, with any arguments wrapped in function contracts if they happen
-;; to be higher order
-(define (verify-preconditions self-contract arguments name span)
-  (unless (equal? (length arguments) (length (FunctionContract-pre-conditions self-contract)))
-    (error-with-span span
-                     "Arity mismatch, function expected "
-                     (length (FunctionContract-pre-conditions self-contract))
-                     "Found: "
-                     (length arguments)))
-
-  (transduce
-   arguments
-   (zipping (FunctionContract-pre-conditions self-contract))
-   (enumerating)
-   (mapping
-    (lambda (x)
-      (let ([i (first x)] [arg (first (second x))] [contract (second (second x))])
-
-        (cond
-          [(FlatContract? contract)
-           =>
-
-           (let ([result (apply-flat-contract contract arg)])
-             (if (ContractViolation? result)
-                 (error-with-span span
-                                  "This function call caused an error"
-                                  "- it occured in the domain position:"
-                                  i
-                                  ", with the contract: "
-                                  (contract->string contract)
-                                  (ContractViolation-error-message result)
-                                  ", blaming "
-                                  (ContractAttachmentLocation-name
-                                   (FunctionContract-contract-attachment-location self-contract))
-                                  "(callsite)")
-                 arg))]
-          [(FunctionContract? contract)
-           =>
-           (if (ContractedFunction? arg)
-               (let ([pre-parent (ContractedFunction-contract arg)])
-                 (let ([parent (FunctionContract
-                                (FunctionContract-pre-conditions pre-parent)
-                                (FunctionContract-post-condition pre-parent)
-                                (ContractAttachmentLocation 'DOMAIN (ContractedFunction-name arg))
-                                (FunctionContract-parents pre-parent))])
-                   (let ([fc (FunctionContract
-                              (FunctionContract-pre-conditions contract)
-                              (FunctionContract-post-condition contract)
-                              (ContractAttachmentLocation 'DOMAIN (ContractedFunction-name arg))
-                              (cons parent (FunctionContract-parents parent)))])
-
-                     (bind/c fc arg name span))))
-               (bind/c contract arg name span))]
-          [else
-           =>
-           (error! "Unexpected value in pre conditions: " contract)]))))
-   (into-list)))
-
-(define (apply-function-contract contract name function arguments span)
-  ;; Check that each of the arguments abides by the
-  (let ([validated-arguments (verify-preconditions contract arguments name span)])
-
-    (let (; [output (with-handler (lambda (err) (raise-error err))
-          ; (apply function validated-arguments))]
-
-          ; (with-handler (lambda (err) (raise-error err))
-          [output (apply function validated-arguments)]
-
-          [self-contract contract]
-          [self-contract-attachment-location (FunctionContract-contract-attachment-location contract)]
-          [contract (FunctionContract-post-condition contract)])
-
-      (cond
-        [(FlatContract? contract)
-         =>
-
-         (let ([result (apply-flat-contract contract output)])
-           (if (ContractViolation? result)
-               (let ([blame-location (if (void? self-contract-attachment-location)
-                                         name
-                                         self-contract-attachment-location)])
-
-                 (cond
-                   [(void? blame-location)
-                    =>
-                    (error-with-span
-                     span
-                     "this function call resulted in an error - occured in the range position of this contract: "
-                     (contract->string self-contract)
-                     (ContractViolation-error-message result)
-                     "blaming: None - broke its own contract")]
-
-                   [else
-                    =>
-                    (error-with-span
-                     span
-                     "this function call resulted in an error - occurred in the range position of this contract: "
-                     (contract->string self-contract)
-                     (ContractViolation-error-message result)
-                     "blaming: "
-                     blame-location)]))
-
-               output))]
-        [(FunctionContract? contract)
-         =>
-
-         (define original-function output)
-
-         (if (FunctionContract? (get-contract-struct output))
-
-             ;; TODO: Come back to this and understand what the heck its doing
-             ;; Figured it out -> its never actually a contracted function, because we're wrapping
-             ;; it directly in a normal function type.
-             (begin
-               (define output (get-contract-struct output))
-               (define pre-parent contract)
-               (define contract-attachment-location
-                 (ContractAttachmentLocation 'RANGE
-                                             (ContractAttachmentLocation-name
-                                              self-contract-attachment-location)))
-               (define parent
-                 (FunctionContract (FunctionContract-pre-conditions pre-parent)
-                                   (FunctionContract-post-condition pre-parent)
-                                   contract-attachment-location
-                                   (FunctionContract-parents pre-parent)))
-               (define fc
-                 (FunctionContract (FunctionContract-pre-conditions contract)
-                                   (FunctionContract-post-condition contract)
-                                   contract-attachment-location
-                                   (cons parent (FunctionContract-parents pre-parent))))
-
-               (bind/c fc original-function name span))
-             (bind/c contract output name span))]
-        [else
-         =>
-         (error! "Unhandled value in post condition: " contract)]))))
-
-(define (bind/c contract function name . span)
-  (define post-condition (FunctionContract-post-condition contract))
-
-  (let ([updated-preconditions
-         (transduce (FunctionContract-pre-conditions contract)
-                    (mapping (lambda (c)
-                               (cond
-                                 [(FlatContract? c)
-                                  =>
-                                  c]
-                                 [(FunctionContract? c)
-                                  =>
-                                  (FunctionContract (FunctionContract-pre-conditions c)
-                                                    (FunctionContract-post-condition c)
-                                                    (ContractAttachmentLocation 'DOMAIN name)
-                                                    (FunctionContract-parents c))]
-                                 [else
-                                  =>
-                                  (error "Unexpected value found in bind/c preconditions: " c)])))
-                    (into-list))]
-
-        [updated-postcondition (cond
-                                 [(FlatContract? post-condition)
-                                  =>
-                                  post-condition]
-                                 [(FunctionContract? post-condition)
-                                  =>
-
-                                  (FunctionContract (FunctionContract-pre-conditions post-condition)
-                                                    (FunctionContract-post-condition post-condition)
-                                                    (ContractAttachmentLocation 'RANGE name)
-                                                    (FunctionContract-parents post-condition))]
-                                 [else
-                                  =>
-
-                                  (error "Unexpected value found in bind/c post condition: "
-                                         post-condition)])])
-
-    (let ([contracted-function
-           (ContractedFunction (FunctionContract updated-preconditions
-                                                 updated-postcondition
-                                                 ;  void
-                                                 ;  (ContractAttachmentLocation 'TOPLEVEL name)
-                                                 ;  void
-                                                 (ContractAttachmentLocation 'TOPLEVEL name)
-                                                 (if (get-contract-struct function)
-                                                     (cons (get-contract-struct function)
-                                                           (FunctionContract-parents contract))
-                                                     (FunctionContract-parents contract)))
-                               function
-                               name)])
-
-      (let ([resulting-lambda-function
-             (lambda args
-
-               (apply-contracted-function
-                contracted-function
-                args
-                ; span
-                ; (current-function-span)
-                (if span (car span) (current-function-span))
-                ;          (begin (displayln ("Current span: " (current-function-span)))
-                ;          (current-function-span)))
-                ))])
-        (attach-contract-struct! resulting-lambda-function
-                                 (ContractedFunction-contract contracted-function))
-        resulting-lambda-function))))
-
-(define (make/c contract name)
-  (cond
-    [(FlatContract? contract) contract]
-    [(FunctionContract? contract) contract]
-    [else
-     =>
-     (FlatContract contract name)]))
-
-(define-syntax ->/c
-  (syntax-rules ()
-    [(->/c r) (make-function/c (make/c r 'r))]
-    [(->/c r ...) (make-function/c (make/c r 'r) ...)]))
-
-;; Macro for basic usage of contracts
-(define-syntax define/contract
-  (syntax-rules ()
-    [(define/contract (name args ...)
-       contract
-       body ...)
-     (begin
-       (define name
-         (lambda (args ...)
-           body ...))
-       (set! name (bind/c contract name 'name))
-       void)
-     ;  (define name (bind/c contract (lambda (args ...) body ...) 'name))
-     ]
-    [(define/contract name
-       contract
-       expr)
-     (define name ((bind/c (make-function/c (make/c contract 'contract)) (lambda () expr))))]))
-
-(provide (for-syntax contract/out/test))
-
-(define-syntax contract/out/test
-  (syntax-rules ()
-    [(contract/out/test name contract) (%require-ident-spec name (bind/c contract name 'name))]))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;; Types ;;;;;;;;;;;;;;;;;;;;;;
-
-(provide contract?
-         listof
-         hashof
-         non-empty-listof
-         </c
-         >/c
-         <=/c
-         >=/c
-         any/c
-         and/c
-         or/c)
-
-(define (loop pred lst)
-  (cond
-    [(null? lst) #t]
-    [(pred (car lst)) (loop pred (cdr lst))]
-    [else #f]))
-
-;; Contract combinators
-(define (listof pred)
-  (make/c (lambda (lst)
-            (cond
-              [(null? lst) #t]
-              [(list? lst) (loop pred lst)]
-              [else #f]))
-          (list 'listof (contract-or-procedure-name pred))))
-
-(define (hashof key-pred value-pred)
-  (make/c
-   (lambda (hashmap)
-     ;; For hashof - we want to assert that both all of the keys and all of the values abide by
-     ;; a specific predicate
-     (and ((listof key-pred) (hash-keys->list hashmap))
-          ((listof value-pred) (hash-values->list hashmap))))
-   (list 'hashof (contract-or-procedure-name key-pred) (contract-or-procedure-name value-pred))))
-
-(define (contract-or-procedure-name x)
-  (cond
-    [(FlatContract? x) (FlatContract-name x)]
-    [(FunctionContract? x) (string->symbol (contract->string x))]
-    [else
-     (let ([lookup (function-name x)]) (if (string? lookup) (string->symbol lookup) '#<function>))]))
-
-;; Like listof, however requires that the list is non empty as well
-(define (non-empty-listof pred)
-  (make/c (lambda (lst)
-            (cond
-              ; (displayln "getting here?")
-              [(null? lst) #f]
-              [(list? lst) (loop pred lst)]
-              [else #f]))
-          (list 'non-empty-listof (contract-or-procedure-name pred))))
-
-;; Contracts for <
-(define (</c n)
-  (make/c (fn (x) (< x n)) (list '</c n)))
-
-;; Contracts for >
-(define (>/c n)
-  (make/c (fn (x) (> x n)) (list '>/c n)))
-
-;; Contracts for <=
-(define (<=/c n)
-  (make/c (fn (x) (<= x n)) (list '<=/c n)))
-
-;; Contracts for >=
-(define (>=/c n)
-  (make/c (fn (x) (>= x n)) (list '>=/c n)))
-
-;; Satisfies any single value
-(define (any/c _)
-  (make/c (fn (_) #t) 'any/c))
-
-;; produces a function compatible with contract definitions
-(define (and/c x y)
-  (make/c (lambda (z) (and (x z) (y z))) (list 'and/c x y)))
-
-;; produces a function compatible with contract definitions
-(define (or/c x y)
-  (make/c (lambda (z) (or (x z) (y z))) (list 'or/c x y)))
-
-(define combinators (hashset listof non-empty-listof </c >/c <=/c >=/c any/c and/c or/c))
-
-(define (contract? predicate-or-contract)
-  (cond
-    [(function? predicate-or-contract)
-     (or (equal? (arity? predicate-or-contract) 1)
-         (hashset-contains? combinators predicate-or-contract))]
-    [else
-     =>
-     #f]))
-
-;; TODO: Come back to this - I think I need to be very specific about the then-contract and else-contract
-;; and how they get applied
-; (define (if/c predicate then-contract else-contract)
-;     (make/c
-
-;         (lambda (x) (if (predicate x)
-;                         (then-contract predicate)
-;                         (else-contract predicate)))
-;         (list 'if/c then-contract else-contract)))
-
-; (define (type/c type contract)
-;     (and/c
-
-; )
-
-; (define (int/c ))
diff --git a/crates/steel-core/src/scheme/modules/iterators.scm b/crates/steel-core/src/scheme/modules/iterators.scm
deleted file mode 100644
index c7ce2fa30..000000000
--- a/crates/steel-core/src/scheme/modules/iterators.scm
+++ /dev/null
@@ -1,130 +0,0 @@
-(require-builtin steel/base)
-
-(provide StreamIterator
-         IntoIterator
-         ITERATOR-FINISHED
-         iter-next
-         into-iter
-         iter-for-each
-         stream-iter-for-each
-         into-stream-iter
-         ;; For defining generators out of functions directly
-         (for-syntax make-generator!)
-         (for-syntax define/generator))
-
-(struct StreamIterator
-        (iter-instance stream-empty-function stream-first-function stream-next-function))
-
-(define (stream-iter-for-each iter func)
-
-  (define obj-stream-empty-function (StreamIterator-stream-empty-function iter))
-  (define obj-stream-first-function (StreamIterator-stream-first-function iter))
-  (define obj-stream-next-function (StreamIterator-stream-next-function iter))
-
-  (let loop ([obj (StreamIterator-iter-instance iter)])
-    (if (obj-stream-empty-function obj)
-        void
-        (begin
-          (func (obj-stream-first-function obj))
-          (loop (obj-stream-next-function obj))))))
-
-(define (list-stream-iterator l)
-  (StreamIterator l empty? car cdr))
-
-(define (into-stream-iter obj)
-  (cond
-    [(list? obj) (list-stream-iterator obj)]
-    [(#%private-struct? obj) ((#%struct-property-ref obj '#:prop:into-stream) obj)]
-
-    [else (error "into-stream implementation not found for object" obj)]))
-
-(struct IntoIterator (iter-object next-function) #:prop:procedure 1)
-
-;; Use the builtin "iterator finished" symbol
-(define ITERATOR-FINISHED (load-from-module! %-builtin-module-steel/meta '#%iterator-finished))
-
-(define (iter-finished? value)
-  (eq? value ITERATOR-FINISHED))
-
-(define (iter-next into-iterator)
-  (into-iterator (IntoIterator-iter-object into-iterator)))
-
-;; Generically get the iterator
-(define (into-iter obj)
-  ;; Check if this is a builtin type - if so, delegate to the underlying iterator
-  (define maybe-builtin-iterator (value->iterator obj))
-
-  (if maybe-builtin-iterator
-      (IntoIterator maybe-builtin-iterator iter-next!)
-      ((#%struct-property-ref obj '#:prop:into-iter) obj)))
-
-;; Call value for each thing
-(define (iter-for-each iter func)
-
-  (define next-value (iter-next iter))
-
-  (if (iter-finished? next-value)
-      void
-      (begin
-        (func next-value)
-        (iter-for-each iter func))))
-
-(define UNEVALUATED 'unevaluated)
-
-(define-syntax make-generator!
-  (syntax-rules (yield)
-
-    [(make-generator! (args ...) body ...)
-     (lambda (args ...)
-
-       (let* ([iterator-object UNEVALUATED]
-              [temp (#%box (lambda () (make-generator! "INTERNAL" iterator-object body ...)))])
-
-         (set! iterator-object temp)
-
-         ;; Produce iterator object - the iterator-object itself is not particularly
-         ;; meaningful.
-         (IntoIterator iterator-object
-                       (lambda (generator-func) ;; Pass the function down
-
-                         ((#%unbox generator-func)) ;; Call it
-                         ))))]
-
-    [(make-generator! (args ...) body)
-     (lambda (args ...)
-
-       ;; Unevaluated
-       (define iterator-object (#%box (lambda () (make-generator! "INTERNAL" iterator-object body))))
-
-       ;; Produce iterator object - the iterator-object itself is not particularly
-       ;; meaningful.
-       (IntoIterator iterator-object
-                     (lambda (generator-func) ;; Pass the function down
-
-                       ((#%unbox generator-func)) ;; Call it
-                       )))]
-
-    [(make-generator! "INTERNAL" generator-id (yield x))
-     (let ([result x])
-       (#%set-box! generator-id (lambda () ITERATOR-FINISHED))
-       result)]
-
-    [(make-generator! "INTERNAL" generator-id (yield x) body ...)
-
-     ;; Freeze the result, set the next function to be the rest of the body
-     (let ([result x])
-       (#%set-box! generator-id (lambda () (make-generator! "INTERNAL" generator-id body ...)))
-       result)]
-
-    [(make-generator! "INTERNAL" generator-id x xs ...)
-
-     (begin
-       x
-       (make-generator! "INTERNAL" generator-id xs ...))]
-
-    [(make-generator! "INTERNAL" generator-id x) x]))
-
-(define-syntax define/generator
-  (syntax-rules ()
-    [(define/generator (name args ...) body ...)
-     (define name (make-generator! (args ...) body ...))]))
diff --git a/crates/steel-core/src/scheme/modules/mvector.scm b/crates/steel-core/src/scheme/modules/mvector.scm
deleted file mode 100644
index e654e32c0..000000000
--- a/crates/steel-core/src/scheme/modules/mvector.scm
+++ /dev/null
@@ -1,125 +0,0 @@
-(require-builtin steel/base)
-(require-builtin #%private/steel/mvector as private.)
-(require "steel/iterators")
-
-;; Clean this up
-;; Make the built in API just use immutable-vector
-(provide vector?
-         immutable-vector?
-         mutable-vector?
-         make-vector
-         vector
-         mutable-vector->list
-         mutable-vector-set!
-         mutable-vector-ref
-         mutable-vector-len
-         list->mutable-vector)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(struct MutableVector (inner)
-  #:mutable
-  #:prop:into-iter
-  (lambda (object) (IntoIterator (MutableVectorIterator object 0) MutableVectorIterator-next))
-  #:printer (lambda (this printer-function)
-              (simple-display "'#(")
-              (cond
-                [(mutable-vector-empty? this) void]
-                [else
-                 (printer-function (mutable-vector-ref this 0))
-                 (mutable-vector-for-each this
-                                          (lambda (elem)
-                                            (simple-display " ")
-                                            (printer-function elem))
-                                          1)
-                 (simple-display ")")])))
-
-;;@doc
-;; Check if the value is an immutable vector
-(define immutable-vector? (load-from-module! %-builtin-module-steel/identity 'vector?))
-
-;;@doc
-;; Check whether the value is a mutable vector
-(define mutable-vector? MutableVector?)
-
-;;@doc
-;; Checks whether the value is a vector (mutable or immutable)
-(define vector? (lambda (x) (or (immutable-vector? x) (MutableVector? x))))
-
-;;@doc
-;; Create a vector of length k, optionally initialized with each
-;; slot filled with value v.
-(define make-vector
-  (case-lambda
-    [(k)
-     (when (< k 0)
-       (error "make-vector requires a positive integer, found " k))
-
-     (list->mutable-vector (map (lambda (_) void) (range 0 k)))]
-    [(k v)
-     (when (< k 0)
-       (error "make-vector requires a positive integer, found " k))
-
-     (list->mutable-vector (map (lambda (_) v) (range 0 k)))]))
-
-(define (make-mutable-vector)
-  (MutableVector (private.make-mutable-vector)))
-
-(define (mutable-vector-ref vector index)
-  (define inner (MutableVector-inner vector))
-  (when (>= index (private.mutable-vector-len inner))
-    (error "index out of bounds - attempted to index"
-           (private.mutable-vector->list inner)
-           "with index: "
-           index))
-  (private.mutable-vector-ref (MutableVector-inner vector) index))
-
-(define (mutable-vector-set! vector index value)
-  (private.mutable-vector-set! (MutableVector-inner vector) index value))
-
-(define (mutable-vector-push! vector value)
-  (private.mutable-vector-push! (MutableVector-inner vector) value))
-
-(define (mutable-vector->list vector)
-  (private.mutable-vector->list (MutableVector-inner vector)))
-
-(define (mutable-vector-empty? vector)
-  (private.mutable-vector-empty? (MutableVector-inner vector)))
-
-(define (mutable-vector-len vector)
-  (private.mutable-vector-len (MutableVector-inner vector)))
-
-(define (list->mutable-vector list)
-  (MutableVector (private.mutable-vector-from-list list)))
-
-(define (mut-vector . args)
-  (MutableVector (private.mutable-vector-from-list args)))
-
-(define vector mut-vector)
-
-(struct MutableVectorIterator (vec idx) #:mutable)
-
-(define (MutableVectorIterator-next iter)
-
-  (define offset (MutableVectorIterator-idx iter))
-  (define vec (MutableVectorIterator-vec iter))
-
-  (cond
-    [(mutable-vector-empty? vec) ITERATOR-FINISHED]
-    [(>= offset (mutable-vector-len vec)) ITERATOR-FINISHED]
-    [else
-     (let ([return-value (mutable-vector-ref vec offset)])
-       (set-MutableVectorIterator-idx! iter (+ offset 1))
-       return-value)]))
-
-(define (mutable-vector-for-each vec func offset)
-
-  (let loop ([func func] [iterator (MutableVectorIterator vec offset)])
-
-    (let ([next (MutableVectorIterator-next iterator)])
-      (if (eq? next ITERATOR-FINISHED)
-          void
-
-          (begin
-            (func next)
-            (loop func iterator))))))
diff --git a/crates/steel-core/src/scheme/modules/option.scm b/crates/steel-core/src/scheme/modules/option.scm
deleted file mode 100644
index 774259986..000000000
--- a/crates/steel-core/src/scheme/modules/option.scm
+++ /dev/null
@@ -1,64 +0,0 @@
-(require-builtin "steel/core/option")
-
-(provide Some
-         None
-         Some?
-         None?
-         Option?
-         (contract/out map-option (->/c Option? (->/c any/c any/c) Option?))
-         (contract/out unwrap-some (->/c Some? any/c))
-         (contract/out flatten-option (->/c Option? Option?))
-         (contract/out unwrap-or (->/c Option? any/c any/c))
-         unwrap
-         unwrap-or-else
-         Option/c)
-
-; (struct Some (value) #:transparent)
-; (struct None ())
-
-(define (Option? x)
-  (or (Some? x) (None? x)))
-
-;; Contracts for option
-(define (Option/c pred)
-  (make/c (fn (x)
-              (cond
-                [(Some? x) (pred (Some->value x))]
-                [(None? x) #t]
-                [else #f]))
-          'Option/c))
-
-(define (Option? value)
-  (or (Some? value) (None? value)))
-
-;; Map - explore dynamic dispatch with contracts?
-(define (map-option option func)
-  (cond
-    [(Some? option) (Some (func (Some->value option)))]
-    [(None? option) (None)]
-    [else
-     =>
-     (error! "map-option with unknown input")]))
-
-(define (flatten-option option)
-  (if (Some? option) (if (Some? (Some->value option)) (Some->value option) (None)) (None)))
-
-;; Get the inner value of the option - contract checking along the way
-;; Figure out how to turn off contracts on OptLevel3 regardless -
-;; this would speed up performance a lot - also figure out how to map this to compile time options in Rust
-(define unwrap-some Some->value)
-
-(define (unwrap option #:default [other #f])
-  (if (Some? option) (Some->value option) other))
-
-(define unwrap
-  (case-lambda
-    [(option) (Some->value option)]
-    [(option default) (if (Some? option) (Some->value option) default)]))
-
-;; Unwraps the given option or returns the given other value
-(define (unwrap-or option other)
-  (if (Some? option) (Some->value option) other))
-
-(define (unwrap-or-else option thunk)
-  (if (Some? option) (Some->value option) (thunk)))
diff --git a/crates/steel-core/src/scheme/modules/parameters.scm b/crates/steel-core/src/scheme/modules/parameters.scm
deleted file mode 100644
index 5e62371a5..000000000
--- a/crates/steel-core/src/scheme/modules/parameters.scm
+++ /dev/null
@@ -1,160 +0,0 @@
-(provide dynamic-wind
-         (for-syntax parameterize)
-         call/cc
-         call-with-current-continuation
-         make-parameter
-         continuation?)
-
-;;;;;; Parameters ;;;;;
-
-(struct Parameter (getter value)
-  #:mutable
-  #:printer (lambda (obj printer-function) (simple-display "<procedure:parameter-procedure>"))
-  #:prop:procedure 0)
-
-(define (make-parameter value)
-  (define param (Parameter 'uninitialized value))
-
-  (set-Parameter-getter! param
-                         (case-lambda
-                           [() (Parameter-value param)]
-                           [(new-value) (set-Parameter-value! param new-value)]))
-
-  param)
-
-(define-syntax parameterize
-  (syntax-rules ()
-    [(parameterize ()
-       body ...)
-     (begin
-       body ...)]
-
-    [(parameterize ([var val] rest ...)
-       body ...)
-
-     (let ([old-value (var)])
-
-       (dynamic-wind (lambda () (set-Parameter-value! var val))
-                     (lambda ()
-                       (parameterize (rest ...)
-                         body ...))
-                     (lambda () (set-Parameter-value! var old-value))))]))
-
-;;;;;;; Bootstrapping printing functions for various primitive structs
-
-(provide current-input-port
-         current-output-port
-         simple-display
-         simple-displayln
-         newline
-         write-char
-         write)
-
-(define current-input-port (make-parameter (#%default-input-port)))
-(define current-output-port (make-parameter (#%default-output-port)))
-
-(define (simple-display x)
-  (raw-write-string (current-output-port) x))
-
-(define newline
-  (case-lambda
-    [() (raw-write-char (current-output-port) #\newline)]
-    [(port) (raw-write-char port #\newline)]))
-
-(define (simple-displayln x)
-  (simple-display x)
-  (newline))
-
-;; TODO: Swap argument order of primitive
-(define (write-char char port)
-  (raw-write-char port char))
-
-(define (write obj port)
-  (raw-write port obj))
-
-;;;;;;;;;;;;;;;;;;;;; Port functions ;;;;;;;;;;;;;;;;;;;;;
-
-(provide call-with-output-string
-         with-output-to-string)
-
-(define (call-with-output-string proc)
-  (define output-string (open-output-string))
-  (proc output-string)
-  (get-output-string output-string))
-
-(define (with-output-to-string proc)
-  (call-with-output-string (lambda (p)
-                             (parameterize ([current-output-port p])
-                               (proc)))))
-
-;;;;;;;;;;;;;;;;;;;;; Dynamic Wind ;;;;;;;;;;;;;;;;;;;;;;;
-
-(define winders '())
-
-; (define list-tail drop)
-
-; (struct Pair (left right))
-
-(define common-tail
-  (lambda (x y)
-    (let ([lx (length x)] [ly (length y)])
-      (let loop ([x (if (> lx ly) (list-tail x (- lx ly)) x)]
-                 [y (if (> ly lx) (list-tail y (- ly lx)) y)])
-
-        (if (equal? x y) x (loop (cdr x) (cdr y)))))))
-
-(define do-wind
-  (lambda (new)
-    (let ([tail (common-tail new winders)])
-      (let f ([ls winders])
-        (when (not (equal? ls tail))
-          (begin
-            ;; TODO: This is probably wrong!
-            ; (displayln "FIRST" ls)
-            (set! winders (cdr ls))
-            ((cdr (car ls)))
-            (f (cdr ls)))))
-      (let f ([ls new])
-        (when (not (equal? ls tail))
-          (begin
-            ; (displayln "SECOND" ls)
-            (f (cdr ls))
-            ((car (car ls)))
-            (set! winders ls)))))))
-
-(struct Continuation (func)
-  #:prop:procedure 0
-  #:printer (lambda (obj printer)
-
-              (simple-display "#<procedure>")))
-
-(define call/cc
-  (lambda (f)
-    (#%prim.call/cc (lambda (k)
-                      (f (let ([save winders])
-                           (Continuation (lambda (x)
-                                           (unless (eq? save winders)
-                                             (do-wind save))
-                                           (k x)))))))))
-
-(define call-with-current-continuation call/cc)
-
-(define (continuation? x)
-  (or (Continuation? x) (#%prim.continuation? x)))
-
-(define dynamic-wind
-  (lambda (in body out)
-    (in)
-    (set! winders (cons (cons in out) winders))
-
-    (let ([ans* (call-with-exception-handler (lambda (err)
-                                               ;; Catch the exception on the way out
-                                               (set! winders (cdr winders))
-                                               (out)
-                                               (raise-error err)
-
-                                               void)
-                                             (lambda () (body)))])
-      (set! winders (cdr winders))
-      (out)
-      ans*)))
diff --git a/crates/steel-core/src/scheme/modules/reader.scm b/crates/steel-core/src/scheme/modules/reader.scm
deleted file mode 100644
index 648f54042..000000000
--- a/crates/steel-core/src/scheme/modules/reader.scm
+++ /dev/null
@@ -1,52 +0,0 @@
-(require-builtin #%private/steel/reader as reader.)
-(require "steel/result")
-(require "#%private/steel/control")
-
-(provide read)
-
-(define *reader* (reader.new-reader))
-
-(define (read . port)
-
-  (if (null? port)
-
-      (read-impl)
-
-      (parameterize ([current-input-port (car port)])
-
-        (read-impl))))
-
-(define (read-impl)
-
-  (cond
-    [(reader.reader-empty? *reader*)
-     (define next-line (read-line-from-port (current-input-port)))
-
-     (cond
-       [(string? next-line)
-        (reader.reader-push-string *reader* next-line)
-
-        (let ([next (reader.reader-read-one *reader*)])
-
-          (if (void? next)
-              (begin
-                ; (displayln "pushing another string")
-                (reader.reader-push-string *reader* (read-line-from-port (current-input-port)))
-                (read-impl))
-              next))]
-
-       [else
-        =>
-        next-line])]
-
-    ;; The reader is not empty!
-    [else
-     =>
-     (let ([next (reader.reader-read-one *reader*)])
-
-       (if (void? next)
-           (begin
-             ; (displayln "pushing another string")
-             (reader.reader-push-string *reader* (read-line-from-port (current-input-port)))
-             (read-impl))
-           next))]))
diff --git a/crates/steel-core/src/scheme/modules/result.scm b/crates/steel-core/src/scheme/modules/result.scm
deleted file mode 100644
index af6406468..000000000
--- a/crates/steel-core/src/scheme/modules/result.scm
+++ /dev/null
@@ -1,68 +0,0 @@
-; (steel/base)
-
-(require-builtin "steel/core/result")
-
-;; This should get preloaded at the top of every require, except the built ins!
-(require-builtin steel/base)
-(require "#%private/steel/contract"
-         (for-syntax "#%private/steel/contract"))
-
-(provide Result?
-         Ok
-         Ok?
-         Err
-         Err?
-         Result/c
-         ; (contract/out unwrap-ok (->/c Ok? any/c))
-         unwrap-ok
-         (contract/out/test unwrap-err (->/c Err? any/c))
-         (contract/out/test map-ok (->/c Result? (->/c any/c any/c) Result?))
-         (contract/out/test map-err (->/c Result? (->/c any/c any/c) Result?))
-         unwrap-or
-         ok-and-then)
-
-; (struct Ok (value) #:transparent)
-; (struct Err (value) #:transparent)
-
-(define (Result? value)
-  (or (Ok? value) (Err? value)))
-
-;; Contracts for Result
-(define (Result/c ok-pred err-pred)
-  (make/c (fn (x)
-              (cond
-                [(Ok? x) (ok-pred (Ok->value x))]
-                [(Err? x) (err-pred (Err->value x))]
-                [else #f]))
-          'Result/c))
-
-;; (->/c Ok? any/c)
-(define unwrap-ok Ok->value)
-
-;; (->/c Err? any/c)
-(define unwrap-err Err->value)
-
-;; (->/c Result? (->/c any/c any/c) Result?)
-(define (map-ok result func)
-  (cond
-    [(Ok? result) (Ok (func (Ok->value result)))]
-    [(Err? result) result]))
-
-(define (ok-and-then result func)
-  (cond
-    [(Ok? result) (func (Ok->value result))]
-    [(Err? result) result]))
-
-;; (->/c Result? (->/c any/c any/c Result?))
-(define (map-err result func)
-  (cond
-    [(Ok? result) result]
-    [(Err? result) (Err (func (Err->value result)))]))
-
-(define (unwrap-or result value)
-  (if (Ok? result) (Ok->value result) value))
-
-; (define-syntax contract/out/test
-;   (syntax-rules ()
-;     [(contract/out/test name contract)
-;      (%require-ident-spec name (bind-contract-to-function contract name 'name))]))
diff --git a/crates/steel-core/src/scheme/nanopass.rkt b/crates/steel-core/src/scheme/nanopass.rkt
deleted file mode 100644
index c720e2d05..000000000
--- a/crates/steel-core/src/scheme/nanopass.rkt
+++ /dev/null
@@ -1,450 +0,0 @@
-;; Actually instead put here a hashmap
-;; that is exposed by the root enviroment
-;;
-;; then keep track of the bindings to see if its a thing
-;; All that needs to happen is to keep track of bindings
-;; at every point
-;; if a symbol has been shadowed, then we move on
-;; later, we can provide functionality to expose const functions
-
-(define (all func lst)
-  (if (null? lst)
-      #t
-      (if (func (car lst))
-          (all func (cdr lst))
-          #f)))
-
-
-(define (constant? expr)
-  (or (number? expr)
-      (symbol? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-
-(define (constant-not-symbols? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-;; See if this maps to a constant function that exists
-(define (match-func sym bound-vars)
-  (if (and (hash-contains? *env* sym)
-           (not (hashset-contains? bound-vars sym)))
-      (hash-get *env* sym)
-      #f))
-
-;; determines if that function actually was bound by the current expression
-;; match the
-(define (bound? sym)
-  (hash-contains? *env* sym))
-
-;; either outputs the symbol used for the definition
-;; or false otherwise
-(define (define-expr? expr)
-  (if (and (list? expr)
-           (equal? 3 (length expr))
-           (equal? (car expr) 'define))
-      (cadr expr)
-      #f))
-
-(define (lambda-expression-application? expr)
-  (if (and (>= (length expr) 2)
-           (list? (car expr))
-           (equal? (car (car expr)) 'lambda))
-      (car (cdr (car expr)))
-      '()))
-
-
-;; TODO go back through and actually fix the prelude
-;; reduce is broken there
-(define (reduce op z lst)
-  (cond ((null? lst) z)    ; just pass it in as another argument
-    (else (reduce op
-                  (op z (car lst))  ; NB! `z` as first arg
-                  (cdr lst)))))
-
-;; returns the updated bound-variable set
-(define (bind-args-to-env env args)
-  (reduce hashset-insert env args))
-
-(define bind-arg-to-env hashset-insert)
-
-(define get-body-lambda-expression cddr)
-
-(define (match-if expr)
-  (equal? (car expr) 'if))
-
-;; (define (match-define expr)
-;;   (equal? (car expr) 'define))
-
-(define *changed* (box #f))
-(define (init-changed) (set-box! *changed* #f))
-(define (mark-changed) (set-box! *changed* #t))
-(define (changed?) (unbox *changed*))
-
-;; might have to return 2 values each time, the expr and the set
-;; this way I can just pass them around everywhere
-;; select the first element of the return each time
-;; select the second element whenever we want the second one
-(define (constant-fold expr bound-vars)
-  ;; (displayln expr)
-  (cond
-    ;; if its a constant, just return a pair of the expr and bound vars
-    [(constant? expr) (list expr bound-vars)]
-    ;; if its a definition, continue on the body
-    ;; return the new bound vars
-    [(define-expr? expr)
-     ;; (displayln "inside here")
-     (define new-bound-vars (bind-arg-to-env bound-vars (define-expr? expr)))
-     (list
-      (list 'define (cadr expr) (car (constant-fold (caddr expr) bound-vars)))
-      new-bound-vars)]
-    ;; if its a function application
-    ;; bind the args to whatever is there
-    ;; return a pair of the bound vars
-    [(lambda-expression-application? expr)
-     (define new-bound-vars
-       (bind-args-to-env bound-vars (lambda-expression-application? expr)))
-     (list
-      ;; constant fold the args w/ the new bound variables
-      (cons (append (list 'lambda (lambda-expression-application? expr)) ;; args
-                    (map (lambda (x)
-                           (car (constant-fold x new-bound-vars)))
-                         (get-body-lambda-expression (car expr))))
-            ;; constant fold the arguments to the function
-            (map (lambda (x)
-                   (car (constant-fold x bound-vars)))
-                 (cdr expr)))
-      bound-vars)]
-    ;; if we have an if statement
-    ;; go ahead and remove the stuff
-    [(match-if expr)
-     (define condition (car (constant-fold (car (cdr expr)) bound-vars)))
-     ;; HACK / TODO
-     ;; Find how to differentiate something like a constant expression '(1 2 3 4) which
-     ;; evaluates to a list, versus something like '(lambda (x) 10)
-     ;; TODO double check that this check is correct - constant? vs constant-not-symbols?
-     (list
-      (if (constant-not-symbols? condition)
-          (cond
-            [condition
-             (mark-changed)
-             (car (constant-fold (caddr expr) bound-vars))]
-            [else
-             (mark-changed)
-             (car (constant-fold (cadddr expr) bound-vars))])
-          (list
-           'if
-           condition
-           (car (constant-fold (caddr expr) bound-vars))
-           (car (constant-fold (cadddr expr) bound-vars))))
-      bound-vars)]
-
-    ;; now if it actually is a function application
-    ;; get the constants associated with the
-    [(match-func (car expr) bound-vars)
-     (define res (map (lambda (x)
-                        (car (constant-fold x bound-vars))) expr))
-     (if (all constant-not-symbols? (cdr res))
-         (begin
-           (mark-changed)
-           (list (apply (match-func (car expr) bound-vars) (cdr res)) bound-vars))
-         (list res bound-vars))]
-    [else
-     ;; (displayln "else case")
-     ;; (displayln expr)
-     (list
-      (map (lambda (x)
-                 (car (constant-fold x bound-vars))) expr)
-      bound-vars)]))
-
-
-;; (define (CF expr)
-;;   ;; (init-changed)
-;;   (car (constant-fold expr (hashset))))
-
-
-;; (CF
-;;  '(list 1 2 3 4
-;;         (+ 1 2 3 4
-;;            (+ 4 5
-;;               (+ 7 8 9 10)))))
-
-;; (CF
-;;  '(if #t 10 20))
-
-;; (CF
-;;  '(if '(1 2 3 4) 20 40))
-
-;; (CF
-;;  '(if 25 10 20))
-
-;; (CF
-;;  '(if #t
-;;       (lambda (x) 10)
-;;       25))
-
-;; (CF
-;;  '(lambda (x) (* x x)))
-
-(define (atom? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-(define lookup hash-get)
-
-;; this is just an alias here
-(define get-application-args cdr)
-
-;; hash -> (listof sym?) -> (listof any?) -> hash
-(define (bind-args env list-of-symbols args)
-  (if (or (null? list-of-symbols) (null? args))
-      env
-      (bind-args
-       (hash-insert env
-                    (car list-of-symbols) (car args))
-       (cdr list-of-symbols)
-       (cdr args))))
-
-;; naive substitution of constant arguments
-(define (naive-subst* expr env)
-  ;; (displayln expr)
-  ;; (displayln (symbol? expr))
-  (cond [(null? expr) expr]
-        [(atom? expr) expr]
-        [(symbol? expr)
-         ;; (displayln "inside symbol case with: ")
-         ;; (displayln expr)
-         ;; (displayln (hash-contains? env expr))
-         ;; (displayln env)
-         (cond
-           [(hash-contains? env expr)
-            (define expr-value (lookup env expr))
-            ;; (displayln expr-value)
-            (if (constant? expr-value)
-                (begin
-                  (mark-changed)
-                  expr-value)
-                expr)]
-           [else expr])]
-        [(lambda-expression-application? expr)
-         ;; (displayln "Found an expression")
-         ;; (displayln expr)
-         (define list-of-bindings (lambda-expression-application? expr))
-         (define list-of-args (get-application-args expr))
-         (define new-env (bind-args env list-of-bindings list-of-args))
-         ;; (displayln "lambda evaluation")
-         ;; (displayln new-env)
-         ;; (displayln (caddr (car expr)))
-         ;; TODO check if you can remove the constant value
-         ;; in the argument position
-         (cons
-          (list
-           'lambda
-           (car (cdr (car expr)))
-           (naive-subst* (caddr (car expr)) new-env))
-          (cdr expr))]
-        [else
-         (map (lambda (x) (naive-subst* x env)) expr)]))
-
-(define (naive-subst expr)
-  ;; (init-changed)
-  (naive-subst* expr (hash)))
-
-
-;; (naive-subst '((lambda (x) x) 10))
-;; (changed?)
-
-
-(define (lambda-application? e)
-  (and (not (null? e))
-       (list? (car e))
-       (equal? (caar e) 'lambda)))
-
-(define (m-atom? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)
-      (symbol? expr)))
-
-;; (define (get-body-fn l)
-;;   (last l))
-
-(define get-body-exprs cddr)
-(define args cadr)
-
-
-(define (last l)
-  (if (null? (cdr l))
-      (car l)
-      (last (cdr l))))
-
-
-
-(define (lambda-removal expr)
-  (cond [(m-atom? expr) expr]
-        [(lambda-application? expr)
-         (define bodies (map lambda-removal (get-body-exprs (car expr))))
-         ;; TODO
-         ;; actually need to handle the case like
-         ;; (lambda (x) (list 1 2 3) 100)
-         ;; (list 1 2 3) should be removed
-         (if (all constant-not-symbols? bodies)
-             (begin
-               (mark-changed)
-               (last bodies))
-             (cons
-              (append
-               (list 'lambda (args (car expr)))
-               bodies)
-              (cdr expr)))]
-        [else (map lambda-removal expr)]))
-
-
-;; (lambda-removal '((lambda (x) 10) 2))
-;; (lambda-removal '((lambda () 10 20 30 40 50 60)))
-
-
-
-;; (-> '((lambda (x) (* x x)) (+ 1 2 3 (+ 1 2 3)))
-;;     (CF)
-;;     (naive-subst)
-;;     (CF)
-;;     (lambda-removal))
-
-
-;; (CF '((lambda (x) (* x x)) (+ 1 2 3 (+ 1 2 3))))
-
-;; (define *program* '((list 1 2 3)))
-
-(define (insert-define-var bound-vars expr)
-  (let ((v (define-expr? expr)))
-    (if v
-        (hashset-insert bound-vars v)
-        bound-vars)))
-
-
-;; (define *program*
-;;   '((define make-stack (lambda () (quote ())))
-;;     (define pop (lambda (stack) (if (null? stack) (quote (#false (quote ()))) (list (car stack) (cdr stack)))))
-;;     (define push cons)
-;;     (define my-stack (make-stack))
-;;     (begin (define pop-val (car (pop ((lambda (x) (push 4 x))
-;;                                       ((lambda (x) (push 3 x)) ((lambda (x) (push 2 x))
-;;                                                                 ((lambda (x) (push 1 x)) my-stack)))))))
-;;            (define new-stack (car (cdr (pop ((lambda (x) (push 4 x)) ((lambda (x) (push 3 x))
-;;                                                                           ((lambda (x) (push 2 x))
-;;                                                                            ((lambda (x) (push 1 x)) my-stack)))))))))
-;;     pop-val
-;;     new-stack))
-
-
-;; if begin statement, lift the defines up to be flattened at the top
-;; e.g.
-;; (begin (define x 10) (define y 20))
-;; should be converted into
-;; (define x 10)
-;; (define y 20)
-;; TODO/HACK
-(define (lift-defines-out-of-begin begin-expr)
-  (if (all define-expr? (cdr begin-expr))
-      (cdr begin-expr)
-      (begin-expr)))
-
-(define (begin-expr? expr)
-  (and (list? expr)
-       (equal? 'begin (car expr))))
-
-
-(define (flatten-to-define lst)
-  (cond ((null? lst) '())
-        ((define-expr? lst)
-         (list lst))
-        ((list? lst)
-         (append (flatten-to-define (car lst))
-                 (flatten-to-define (cdr lst))))
-        (else (list lst))))
-
-(define (lift-defines-out-of-begin begin-expr)
-  (define (helper expr)
-    (cond
-      [(not (list? expr)) expr]
-      [(null? expr) expr]
-      [(define-expr? expr)
-       expr]
-      [(begin-expr? expr)
-       (map lift-defines-out-of-begin (cdr expr))]
-      [else expr]))
-  (flatten-to-define (helper begin-expr)))
-
-
-(define (lift-defines-out-of-begin-2 expr)
-  (filter (lambda (x) (not (equal? x 'begin))) (flatten-to-define expr)))
-
-
-;; TODO
-(define (flatten-top-level-defines lst-of-exprs)
-  (define (loop input output)
-    (cond [(null? input) output]
-          [(begin-expr? (car input))
-           (loop (cdr input) (append output (lift-defines-out-of-begin (car input))))]
-          [else (loop (cdr input) (append output (list (car input))))]))
-  (loop lst-of-exprs '()))
-
-
-;; (flatten-top-level-defines *program*)
-
-;; ----- main thing kinda starts here ----
-
-(define *flattened-program* (flatten-top-level-defines *program*))
-
-(define initial-bound-vars
-  (reduce insert-define-var (hashset) *flattened-program*))
-
-(define (CF expr)
-  (car (constant-fold expr initial-bound-vars)))
-
-
-(define (optimize! expr)
-  (init-changed)
-  (define output
-    (-> expr
-        (CF)
-        (naive-subst)
-        (lambda-removal)))
-  (if (changed?)
-      (begin
-        (displayln "program changed!")
-        (optimize! output))
-      output))
-
-
-(define (pprint lst)
-  (if (null? lst)
-      '()
-      (begin
-        (displayln (car lst))
-        (pprint (cdr lst)))))
-
-; (map optimize! *flattened-program*)
-
-(displayln "-------------- BEFORE --------------")
-; (displayln *flattened-program*)
-(pprint *flattened-program*)
-(define *result* (map optimize! *flattened-program*))
-(displayln "-------------- AFTER ---------------")
-; (displayln *result*)
-(pprint *result*)
-*result*
-
-;; ----------------------------
diff --git a/crates/steel-core/src/scheme/print.scm b/crates/steel-core/src/scheme/print.scm
deleted file mode 100644
index 499430db0..000000000
--- a/crates/steel-core/src/scheme/print.scm
+++ /dev/null
@@ -1,217 +0,0 @@
-(require-builtin steel/base)
-(require "#%private/steel/control"
-         (for-syntax "#%private/steel/control"))
-
-(provide displayln
-         display
-         #%print
-         #%top-level-print)
-
-(define (for-each func lst)
-  (if (null? lst)
-      void
-      (begin
-        (func (car lst))
-        (when (null? lst)
-          (return! void))
-        (for-each func (cdr lst)))))
-
-(define (display-impl obj)
-  ;; Collect cycles
-  (define cycle-collector (#%private-cycle-collector obj))
-
-  (for-each (λ (obj)
-              (when (int? (#%private-cycle-collector-get cycle-collector obj))
-                (simple-display "#")
-                (simple-display (#%private-cycle-collector-get cycle-collector obj))
-                (simple-display "=")
-                (#%top-level-print obj cycle-collector)
-                (newline)))
-            (#%private-cycle-collector-values cycle-collector))
-
-  ;; Symbols are funny
-  (when (or (symbol? obj) (list? obj))
-    (simple-display "'"))
-
-  (#%top-level-print obj cycle-collector))
-
-(define display
-  (case-lambda
-    [(obj) (display-impl obj)]
-    [(obj port)
-     (parameterize ([current-output-port port])
-       (display-impl obj))]))
-
-;; TODO: Nuke the displayln multiple arguments. I think displayln should
-;; just take one argument for now
-(define (displayln . objs)
-
-  (cond
-    [(= (length objs) 1)
-
-     (display (car objs))
-     (newline)]
-    [else
-
-     (for-each (lambda (x)
-                 (display x)
-                 (simple-display " "))
-               objs)
-     (newline)]))
-
-(define (#%top-level-print obj collector)
-  (cond
-    [(symbol? obj) (simple-display (symbol->string obj))]
-    [(atom? obj) (simple-display obj)]
-    [(function? obj) (simple-display obj)]
-    ;; There is a cycle!
-    ; [(int? (#%private-cycle-collector-get collector obj))
-    ;  (simple-display "#" (#%private-cycle-collector-get collector obj) "#")]
-    [(list? obj)
-     (simple-display "(")
-     (when (not (empty? obj))
-       (#%print (car obj) collector)
-       (for-each (λ (obj)
-                   (simple-display " ")
-                   (#%print obj collector))
-                 (cdr obj)))
-     (simple-display ")")]
-
-    [(#%private-struct? obj)
-
-     (let ([printer (#%struct-property-ref obj '#:printer)])
-
-       (cond
-         [(function? printer) (printer obj (lambda (x) (#%print x collector)))]
-
-         ;; Truthiness here needs to be addressed
-         [printer
-          (simple-display "#<")
-          (simple-display (symbol->string (#%struct-property-ref obj '#:name)))
-          (simple-display ">")]
-
-         [else (simple-display obj)]))]
-
-    [(set? obj)
-     (cond
-       [(= (hashset-length obj) 0) (simple-display "(set)")]
-       [else
-        (simple-display "(set ")
-
-        (let ([set-as-list (hashset->list obj)])
-
-          (#%print (car set-as-list) collector)
-          (for-each (λ (obj)
-                      (simple-display " ")
-                      (#%print obj collector)
-                      collector)
-                    (cdr set-as-list))
-          (simple-display ")"))])]
-
-    [(hash? obj)
-     (simple-display "'#hash(")
-     ;; TODO: This should use the private transduce
-     (let ([hash-as-list-of-pairs (transduce obj (into-list))])
-
-       (cond
-         [(empty? hash-as-list-of-pairs) (simple-display ")")]
-         [else
-
-          (simple-display "(")
-          (#%print (caar hash-as-list-of-pairs) collector)
-          (simple-display " . ")
-          (#%print (cadar hash-as-list-of-pairs) collector)
-          (simple-display ")")
-
-          (for-each (λ (obj)
-                      (simple-display " (")
-                      (#%print (car obj) collector)
-                      (simple-display " . ")
-                      (#%print (list-ref obj 1) collector)
-                      (simple-display ")"))
-                    (cdr hash-as-list-of-pairs))
-
-          (simple-display ")")]))]
-
-    [else (simple-displayln obj)]))
-
-(define (#%print obj collector)
-  (cond
-    [(string? obj)
-     (display "\"")
-     (simple-display obj)
-     (display "\"")]
-    [(symbol? obj) (simple-display (symbol->string obj))]
-    [(atom? obj) (simple-display obj)]
-    [(function? obj) (simple-display obj)]
-    [(void? obj) (simple-display obj)]
-    ;; There is a cycle!
-    [(int? (#%private-cycle-collector-get collector obj))
-     (simple-display "#")
-     (simple-display (#%private-cycle-collector-get collector obj))
-     (simple-display "#")]
-    [(list? obj)
-     (simple-display "(")
-     (when (not (empty? obj))
-       (#%print (car obj) collector)
-       (for-each (λ (obj)
-                   (simple-display " ")
-                   (#%print obj collector))
-                 (cdr obj)))
-     (simple-display ")")]
-
-    [(#%private-struct? obj)
-
-     (let ([printer (#%struct-property-ref obj '#:printer)])
-
-       (cond
-         [(function? printer) (printer obj (lambda (x) (#%print x collector)))]
-         [printer
-          (simple-display "#<")
-          (simple-display (symbol->string (#%struct-property-ref obj '#:name)))
-          (simple-display ">")]
-
-         [else (simple-display obj)]))]
-
-    [(set? obj)
-     (cond
-       [(= (hashset-length obj) 0) (simple-display "(set)")]
-       [else
-        (simple-display "(set ")
-
-        (let ([set-as-list (hashset->list obj)])
-
-          (#%print (car set-as-list) collector)
-          (for-each (λ (obj)
-                      (simple-display " ")
-                      (#%print obj collector)
-                      collector)
-                    (cdr set-as-list))
-          (simple-display ")"))])]
-
-    [(hash? obj)
-     (simple-display "'#hash(")
-     ;; TODO: This should use the private transduce
-     (let ([hash-as-list-of-pairs (transduce obj (into-list))])
-
-       (cond
-         [(empty? hash-as-list-of-pairs) (simple-display ")")]
-         [else
-
-          (simple-display "(")
-          (#%print (caar hash-as-list-of-pairs) collector)
-          (simple-display " . ")
-          (#%print (cadar hash-as-list-of-pairs) collector)
-          (simple-display ")")
-
-          (for-each (λ (obj)
-                      (simple-display " (")
-                      (#%print (car obj) collector)
-                      (simple-display " . ")
-                      (#%print (list-ref obj 1) collector)
-                      (simple-display ")"))
-                    (cdr hash-as-list-of-pairs))
-
-          (simple-display ")")]))]
-
-    [else (simple-display obj)]))
diff --git a/crates/steel-core/src/scheme/stdlib.scm b/crates/steel-core/src/scheme/stdlib.scm
deleted file mode 100644
index 82c1d2847..000000000
--- a/crates/steel-core/src/scheme/stdlib.scm
+++ /dev/null
@@ -1,873 +0,0 @@
-(provide caar
-         cadr
-         cdar
-         cddr
-         caaar
-         caadr
-         cadar
-         caddr
-         cdaar
-         cdadr
-         cddar
-         cdddr
-         caaaar
-         caadar
-         caaddr
-         cadaar
-         cadadr
-         caddar
-         cadddr
-         cdaaar
-         cdadar
-         cdaddr
-         cddaar
-         cddadr
-         cdddar
-         cdddr
-         id
-         flip
-         curry
-         curry2
-         foldl
-         map
-         foldr
-         unfold
-         fold
-         reduce
-         max
-         min
-         mem-helper
-         member
-         contains?
-         assq
-         assoc
-         filter
-         even-rec?
-         odd-rec?
-         sum
-         add1
-         sub1
-         zero?
-         drop
-         slice
-         flatten
-         *meta-continuation*
-         *abort
-         *reset
-         *shift
-         force
-         values
-         call-with-values)
-
-; (define-syntax steel/base
-;   (syntax-rules ()
-;     [(steel/base) (require-builtin steel/base)]))
-
-; (define-syntax quasiquote
-;   (syntax-rules (unquote unquote-splicing)
-;     ((_ ((unquote x) . xs))          (cons x (quasiquote xs)))
-;     ((_ ((unquote-splicing x) . xs)) (append x (quasiquote xs)))
-;     ((_ (unquote x))                 x)
-;     ((_ (x  . xs))                   (cons (quasiquote x) (quasiquote xs)))
-;     ((_ x)                           (quote x))))
-
-(define-syntax quasiquote
-  (syntax-rules (unquote unquote-splicing #%unquote #%unquote-splicing #%quote)
-
-    [(quasiquote ((quote x) xs ...)) (cons (list 'quote (quasiquote x)) (quasiquote (xs ...)))]
-
-    [(quasiquote (quote x)) (list 'quote (quasiquote x))]
-
-    [(quasiquote ((unquote x) xs ...)) (cons (list 'unquote (quasiquote x)) (quasiquote (xs ...)))]
-    [(quasiquote (unquote x)) (list 'unquote (quasiquote x))]
-
-    ; [(quasiquote ((unquote x) xs ...)) (cons x (quasiquote (xs ...)))]
-    ; [(quasiquote (unquote x)) x]
-
-    ; ((quasiquote ((#%unquote x) xs ...))          (cons x (quasiquote (xs ...))))
-
-    [(quasiquote ((#%unquote x) xs ...)) (cons x (quasiquote (xs ...)))]
-    [(quasiquote (#%unquote x)) x]
-
-    [(quasiquote ((#%unquote-splicing x))) (append x '())]
-    [(quasiquote ((#%unquote-splicing x) xs ...)) (append x (quasiquote (xs ...)))]
-
-    ;; TODO: Do unquote-splicing as well, follow the same rules as unquote
-    [(quasiquote ((unquote-splicing x))) (append (list (list 'unquote-splicing (quasiquote x))) '())]
-    [(quasiquote ((unquote-splicing x) xs ...))
-     (append (list (list 'unquote-splicing (quasiquote x))) (quasiquote (xs ...)))]
-    [(quasiquote (x xs ...)) (cons (quasiquote x) (quasiquote (xs ...)))]
-    [(quasiquote x) 'x]))
-
-; (define-syntax #%unquote
-;   (syntax-rules ()
-;     [(#%unquote x) x]))
-
-(define-syntax #%proto-syntax-object
-  (syntax-rules ()
-    [(#%proto-syntax-object x) (#%syntax/raw 'x 'x (#%syntax-span x))]))
-
-;; TODO: @Matt
-;; Bootstrap this by expanding first, then expanding the resulting
-;; TODO: Add syntax->span in the macro expander as a special case function.
-;; That just inlines the span object '(left right <source-id>)
-;; And then also calls the constructor for the
-(define-syntax quasisyntax
-  (syntax-rules (syntax unsyntax unsyntax-splicing #%unsyntax #%unsyntax-splicing #%internal-crunch)
-
-    [(quasisyntax ((syntax x) xs ...)) (cons (list 'syntax (quasisyntax x)) (quasisyntax (xs ...)))]
-
-    [(quasisyntax (syntax x)) (list 'quote (quasisyntax x))]
-
-    [(quasisyntax ((unsyntax x) xs ...))
-     (cons (list 'unsyntax (quasisyntax x)) (quasisyntax (xs ...)))]
-    [(quasisyntax (unsyntax x)) (list 'unsyntax (quasisyntax x))]
-
-    ; ((quasiquote ((#%unquote x) xs ...))          (cons x (quasiquote (xs ...))))
-
-    [(quasisyntax ((#%unsyntax x) xs ...)) (cons x (quasisyntax (xs ...)))]
-    [(quasisyntax (#%unsyntax x)) x]
-
-    [(quasisyntax ((#%unsyntax-splicing x))) (append x '())]
-    [(quasisyntax ((#%unsyntax-splicing x) xs ...)) (append x (quasisyntax (xs ...)))]
-
-    ;; TODO: Do unquote-splicing as well, follow the same rules as unquote
-    [(quasisyntax ((unsyntax-splicing x)))
-     (append (list (list 'unsyntax-splicing (quasisyntax x))) '())]
-    [(quasisyntax ((unsyntax-splicing x) xs ...))
-     (append (list (list 'unsyntax-splicing (quasisyntax x))) (quasisyntax (xs ...)))]
-
-    [(quasisyntax #%internal-crunch ()) (list)]
-    ; (list
-    ; (#%syntax/raw
-    ;   (quote x)
-
-    ;   (cons (quasisyntax x) (quasisyntax #%internal-crunch (xs ...)))
-
-    ;   (#%syntax-span x)))
-
-    [(quasisyntax #%internal-crunch (x xs ...))
-     ; (list
-     ; (#%syntax/raw
-     ; (quote x)
-
-     (cons (quasisyntax x) (quasisyntax #%internal-crunch (xs ...)))]
-
-    ; (#%syntax-span x)))
-
-    [(quasisyntax (x xs ...))
-     ; (list
-     (#%syntax/raw (quote (x xs ...))
-                   (cons (quasisyntax x) (quasisyntax #%internal-crunch (xs ...)))
-                   (#%syntax-span (x xs ...)))]
-    ; )
-
-    ; ((quasisyntax x)                          'x)))
-
-    ; ((quasisyntax (quote ()))     '())
-    [(quasisyntax x) (if (empty? 'x) (list) (#%syntax/raw 'x 'x (#%syntax-span x)))]))
-
-(define-syntax or
-  (syntax-rules ()
-    [(or) #f]
-    [(or x) x]
-    [(or x y) (let ([z x]) (if z z y))]
-    [(or x y ...) (or x (or y ...))]))
-
-(define-syntax and
-  (syntax-rules ()
-    [(and) #t]
-    [(and x) x]
-    [(and x y) (if x y #f)]
-    [(and x y ...) (and x (and y ...))]))
-
-(define-syntax when
-  (syntax-rules ()
-    [(when a
-       b ...)
-     (if a
-         (begin
-           b ...)
-         void)]))
-
-(define-syntax unless
-  (syntax-rules ()
-    [(unless a
-       b ...)
-     (if a
-         void
-         (begin
-           b ...))]))
-
-(define-syntax cond
-  (syntax-rules (else =>)
-    [(cond
-       [else
-        =>
-        e1 ...])
-     (begin
-       e1 ...)]
-    [(cond
-       [else
-        e1 ...])
-     (begin
-       e1 ...)]
-    [(cond
-       [e1
-        e2 ...])
-     (when e1
-       e2 ...)]
-    [(cond
-       [e1
-        =>
-        e2 ...]
-       c1 ...)
-     (if e1
-         (begin
-           e2 ...)
-         (cond
-           c1 ...))]
-    [(cond
-       [e1
-        e2 ...]
-       c1 ...)
-     (if e1
-         (begin
-           e2 ...)
-         (cond
-           c1 ...))]))
-
-(define-syntax case
-  (syntax-rules (else)
-    [(case (key ...)
-       clauses ...)
-     (let ([atom-key (key ...)])
-       (case atom-key
-         clauses ...))]
-    [(case key
-       [else
-        result1
-        result2 ...])
-     (begin
-       result1
-       result2 ...)]
-    [(case key
-       [(atoms ...)
-        result1
-        result2 ...])
-     (when (member key '(atoms ...))
-       (begin
-         result1
-         result2 ...))]
-
-    ; [(case key
-    ;        ((atoms ...) result1 ...)
-    ;        clause clauses ...)
-    ;      (if (member key '(atoms ...))
-    ;          (begin result1 ...)
-    ;          (case key clause clauses ...))]
-
-    [(case key
-       [(atoms ...)
-        result1
-        result2 ...]
-       clause
-       clauses ...)
-     (if (member key '(atoms ...))
-         (begin
-           result1
-           result2 ...)
-         (case key
-           clause
-           clauses ...))]))
-
-(define-syntax while
-  (syntax-rules (do)
-    [(while cond do body ...)
-     (begin
-       (define (loop)
-         (when cond
-           body ...
-           (loop)))
-       (loop))]
-    [(while cond body ...)
-     (begin
-       (define (loop)
-         (when cond
-           body ...
-           (loop)))
-       (loop))]))
-
-;; TODO add the single argument case
-(define-syntax f>
-  (syntax-rules ()
-    [(f> fun) fun]
-    [(f> fun args* ...) (lambda (x) (fun x args* ...))]))
-
-(define-syntax ->
-  (syntax-rules ()
-    [(-> a) a]
-    [(-> a (b c ...)) ((f> b c ...) a)]
-    [(-> a (b)) ((f> b) a)]
-    [(-> a b c ...) (-> (-> a b) c ...)]))
-
-(define-syntax ~>
-  (syntax-rules ()
-    [(~> a) a]
-    [(~> a (b c ...)) ((f> b c ...) a)]
-    [(~> a (b)) ((f> b) a)]
-    [(~> a b) ((f> b) a)]
-    [(~> a b c ...) (~> (~> a b) c ...)]))
-
-(define-syntax l>
-  (syntax-rules ()
-    [(l> fun) fun]
-    [(l> fun args* ...) (lambda (x) (fun args* ... x))]))
-
-(define-syntax ~>>
-  (syntax-rules ()
-    [(~>> a) a]
-    [(~>> a (b c ...)) ((l> b c ...) a)]
-    [(~>> a (b)) ((l> b) a)]
-    [(~>> a b) ((l> b) a)]
-    [(~>> a b c ...) (~>> (~>> a b) c ...)]))
-
-(define-syntax ->>
-  (syntax-rules ()
-    [(->> a) a]
-    [(->> a (b c ...)) ((l> b c ...) a)]
-    [(->> a (b)) ((l> b) a)]
-    [(->> a b c ...) (->> (->> a b) c ...)]))
-
-(define-syntax swap
-  (syntax-rules ()
-    [(swap a b)
-     (let ([tmp b])
-       (begin
-         (set! b a)
-         (set! a tmp)))]))
-
-(define-syntax let*
-  (syntax-rules ()
-    [(let* ()
-       body ...) ; base case
-     ((lambda ()
-        body ...))]
-    [(let* ([var val] rest ...)
-       body ...) ; binding case
-     ((lambda (var)
-        (let* (rest ...)
-          body ...))
-      val)]))
-
-(define-syntax letrec*-helper
-  (syntax-rules ()
-    [(letrec*-helper () body ...)
-     (begin
-       body ...)]
-    [(letrec*-helper ((var val) rest ...) body ...)
-     (begin
-       (define var val)
-       (letrec*-helper (rest ...) body ...))]))
-
-(define-syntax letrec*
-  (syntax-rules ()
-    [(letrec* bindings body ...) ((lambda () (letrec*-helper bindings body ...)))]))
-
-(define-syntax letrec
-  (syntax-rules ()
-    [(letrec bindings
-       body ...)
-     ((lambda () (letrec*-helper bindings body ...)))]))
-
-(define-syntax module
-  (syntax-rules (provide gen-defines
-                         contract/out)
-    [(module name (provide ids ...)
-       funcs ...)
-     (begin
-       (define (datum->syntax name)
-         ((lambda ()
-            funcs ...
-            (module provide ids
-              ...))))
-       (module gen-defines name
-         ids ...))]
-
-    ;; in the contract case, ignore the contract in the hash
-    [(module provide (contract/out name contract)
-       )
-     (%proto-hash% 'name name)]
-    ;; Normal case
-    [(module provide name
-       )
-     (%proto-hash% 'name name)]
-
-    ;; in the contract case, ignore the contract in the hash
-    [(module provide (contract/out name contract)
-       rest ...)
-     (%proto-hash-insert% (module provide rest
-                            ...)
-                          'name
-                          name)]
-
-    ;; Normal case
-    [(module provide name
-       rest ...)
-     (%proto-hash-insert% (module provide rest
-                            ...)
-                          'name
-                          name)]
-
-    ;; Module contract provides
-    [(module gen-defines mod
-       (contract/out name contract))
-     (define (datum->syntax name)
-       (bind/c contract (%proto-hash-get% mod 'name)))]
-    [(module gen-defines mod
-       (contract/out name contract)
-       rest ...)
-     (begin
-       (define (datum->syntax name)
-         (bind/c contract (%proto-hash-get% mod 'name)))
-       (module gen-defines mod
-         rest ...))]
-
-    ;; Normal provides
-    [(module gen-defines mod
-       name)
-     (define (datum->syntax name)
-       (%proto-hash-get% mod 'name))]
-    [(module gen-defines mod
-       name
-       rest ...)
-     (begin
-       (define (datum->syntax name)
-         (%proto-hash-get% mod 'name))
-       (module gen-defines mod
-         rest ...))]))
-
-;; TODO: Replace some of these with just list ref to abuse the underlying implementation
-(define caar (lambda (pair) (car (car pair))))
-(define cadr (lambda (pair) (car (cdr pair))))
-(define cdar (lambda (pair) (cdr (car pair))))
-(define cddr (lambda (pair) (cdr (cdr pair))))
-(define caaar (lambda (pair) (car (car (car pair)))))
-(define caadr (lambda (pair) (car (car (cdr pair)))))
-(define cadar (lambda (pair) (car (cdr (car pair)))))
-(define caddr (lambda (pair) (car (cdr (cdr pair)))))
-(define cdaar (lambda (pair) (cdr (car (car pair)))))
-(define cdadr (lambda (pair) (cdr (car (cdr pair)))))
-(define cddar (lambda (pair) (cdr (cdr (car pair)))))
-(define cdddr (lambda (pair) (cdr (cdr (cdr pair)))))
-(define caaaar (lambda (pair) (car (car (car (car pair))))))
-(define caaadr (lambda (pair) (car (car (car (cdr pair))))))
-(define caadar (lambda (pair) (car (car (cdr (car pair))))))
-(define caaddr (lambda (pair) (car (car (cdr (cdr pair))))))
-(define cadaar (lambda (pair) (car (cdr (car (car pair))))))
-(define cadadr (lambda (pair) (car (cdr (car (cdr pair))))))
-(define caddar (lambda (pair) (car (cdr (cdr (car pair))))))
-(define cadddr (lambda (pair) (car (cdr (cdr (cdr pair))))))
-(define cdaaar (lambda (pair) (cdr (car (car (car pair))))))
-(define cdaadr (lambda (pair) (cdr (car (car (cdr pair))))))
-(define cdadar (lambda (pair) (cdr (car (cdr (car pair))))))
-(define cdaddr (lambda (pair) (cdr (car (cdr (cdr pair))))))
-(define cddaar (lambda (pair) (cdr (cdr (car (car pair))))))
-(define cddadr (lambda (pair) (cdr (cdr (car (cdr pair))))))
-(define cdddar (lambda (pair) (cdr (cdr (cdr (car pair))))))
-(define cddddr (lambda (pair) (cdr (cdr (cdr (cdr pair))))))
-(define id (lambda (obj) obj))
-(define flip (lambda (func) (lambda (arg1 arg2) (func arg2 arg1))))
-(define curry (lambda (func arg1) (lambda (arg) (func arg1 arg))))
-(define curry2 (lambda (func arg1) (lambda (arg2 arg3) (func arg1 arg2 arg3))))
-; (define compose (lambda (f g) (lambda (arg) (f (g arg)))))
-
-(define (foldl func accum lst)
-  (if (null? lst)
-      accum
-      (foldl func
-             (func (car lst) accum) ; here's the change
-             (cdr lst))))
-
-(define (map func lst . lsts)
-
-  (cond
-    [(null? lst) '()]
-    [(null? lsts) (transduce lst (mapping func) (into-list))]
-    [else
-     =>
-     (define (crunch composer remaining-lists)
-       (if (null? remaining-lists)
-           composer
-           (crunch (compose composer (zipping (car remaining-lists))) (cdr remaining-lists))))
-     (if (null? lsts)
-         (map func lst)
-         ;; Handle the case for many lists
-         (let ([composed-transducer (crunch (compose) lsts)])
-           (transduce lst composed-transducer (mapping (lambda (x) (apply func x))) (into-list))))]))
-
-; (if (null? lst)
-;     '()
-;     (transduce lst (mapping func) (into-list))))
-
-(define foldr
-  (lambda (func accum lst) (if (null? lst) accum (func (car lst) (foldr func accum (cdr lst))))))
-
-(define unfold
-  (lambda (func init pred)
-    (if (pred init) (cons init '()) (cons init (unfold func (func init) pred)))))
-
-(define fold (lambda (f a l) (foldl f a l)))
-(define reduce (lambda (f a l) (fold f a l)))
-(define max (lambda (x num-list) (fold (lambda (y z) (if (> y z) y z)) x (cons 0 num-list))))
-(define min (lambda (x num-list) (fold (lambda (y z) (if (< y z) y z)) x (cons 536870911 num-list))))
-
-(define mem-helper
-  (lambda (pred op) (lambda (acc next) (if (and (not acc) (pred (op next))) next acc))))
-
-; (define memq (lambda (obj lst)       (fold (mem-helper (curry eq? obj) id) #f lst)))
-; (define memv (lambda (obj lst)       (fold (mem-helper (curry eqv? obj) id) #f lst)))
-; (define member (lambda (obj lst) (fold (mem-helper (curry equal? obj) id) #f lst)))
-
-(define member
-  (lambda (x los)
-    (cond
-      [(null? los) #f]
-      [(equal? x (car los)) los]
-      [else (member x (cdr los))])))
-
-(define (contains? pred? lst)
-  ; (displayln lst)
-  (cond
-    [(empty? lst) #f]
-    [(pred? (car lst)) #t]
-    [else (contains? pred? (cdr lst))]))
-
-;; TODO come back to this
-(define assq (lambda (obj alist) (fold (mem-helper (curry eq? obj) car) #f alist)))
-
-;; (define assv (lambda (obj alist)     (fold (mem-helper (curry eqv? obj) car) #f alist)))
-; (define assoc (lambda (obj alist) (fold (mem-helper (curry equal? obj) car) #f alist)))
-
-; (define assoc )
-
-(define (assoc thing alist)
-  ; (simple-displayln "Calling assoc")
-  ; (simple-displayln alist)
-  (if (null? alist) #f (if (equal? (car (car alist)) thing) (car alist) (assoc thing (cdr alist)))))
-
-(define (filter pred lst)
-  (if (empty? lst) '() (transduce lst (filtering pred) (into-list))))
-
-; (define (fact n)
-;   (define factorial-tail (lambda (n acc)
-;                            (if (= n 0)
-;                                acc
-;                                (factorial-tail (- n 1)  (* acc n )))))
-;   (factorial-tail n 1))
-
-(define even-rec? (lambda (x) (if (= x 0) #t (odd-rec? (- x 1)))))
-(define odd-rec? (lambda (x) (if (= x 0) #f (even-rec? (- x 1)))))
-
-(define sum (lambda (x) (reduce + 0 x)))
-;; (define head car)
-;; (define tail cdr)
-(define (add1 n)
-  (+ 1 n))
-(define (sub1 n)
-  (- n 1))
-(define (zero? n)
-  (= n 0))
-
-;; currently broken, doesn't work properly
-; (defn (take lst n)
-;   (defn (loop x l acc)
-;     (if (= x 0)
-;         acc
-;         (loop (- x 1) (cdr l) (cons (car l) acc))))
-;   (loop n lst (list)))
-
-(define (drop lst n)
-  (define (loop x l)
-    (if (zero? x) l (loop (sub1 x) (cdr l))))
-  (loop n lst))
-
-(define (slice l offset n)
-  (take (drop l offset) n))
-
-(define (flatten lst)
-  (cond
-    [(null? lst) '()]
-    [(list? lst) (append (flatten (car lst)) (flatten (cdr lst)))]
-    [else (list lst)]))
-
-;;; Macros go here:
-
-(define-syntax reset
-  (syntax-rules ()
-    [(reset ?e) (*reset (lambda () ?e))]))
-
-(define-syntax shift
-  (syntax-rules ()
-    [(shift ?k ?e) (*shift (lambda (?k) ?e))]))
-
-;; TODO: This should be boxed at some point, we don't want it
-;; to be globally accessible directly (I think)
-(define (*meta-continuation* v)
-  (error "You forgot the top-level reset..."))
-
-(define (*abort thunk)
-  (let ([v (thunk)]) (*meta-continuation* v)))
-
-(define (*reset thunk)
-  (let ([mc *meta-continuation*])
-    (call/cc (lambda (k)
-               (begin
-                 (set! *meta-continuation*
-                       (lambda (v)
-                         (set! *meta-continuation* mc)
-                         (k v)))
-                 (*abort thunk))))))
-
-(define (*shift f)
-  (call/cc (lambda (k) (*abort (lambda () (f (lambda (v) (reset (k v)))))))))
-
-(define-syntax with-handler
-  (syntax-rules ()
-    [(with-handler handler expr)
-     (reset (call-with-exception-handler (lambda (err)
-                                           (handler err)
-                                           (shift k (k void)))
-                                         (lambda () expr)))]
-    [(with-handler handler expr ...)
-     (reset (call-with-exception-handler (lambda (err)
-                                           (handler err)
-                                           (shift k (k void)))
-                                         (lambda ()
-                                           expr ...)))]))
-
-(define-syntax case-lambda
-  (syntax-rules ()
-    [(case-lambda) (lambda args (error "CASE-LAMBDA without any clauses."))]
-    [(case-lambda
-       [?a1
-        ?e1 ...]
-       ?clause1 ...)
-     (lambda args
-       (let ([l (length args)])
-         (case-lambda
-           "CLAUSE"
-           args
-           l
-           [?a1
-            ?e1 ...]
-           ?clause1 ...)))]
-    [(case-lambda
-       "CLAUSE"
-       ?args
-       ?l
-       [(?a1 ...)
-        ?e1 ...])
-     (if (= ?l (length '(?a1 ...)))
-         (apply (lambda (?a1 ...)
-                  ?e1 ...)
-                ?args)
-         (error! "Arity mismatch in case lambda: attempted to call function with arg length: "
-                 ?l
-                 "expecting length: "
-                 (length '(?a1 ...))))]
-    [(case-lambda
-       "CLAUSE"
-       ?args
-       ?l
-       [(?a1 ...)
-        ?e1 ...]
-       ?clause1 ...)
-     (if (= ?l (length '(?a1 ...)))
-         (apply (lambda (?a1 ...)
-                  ?e1 ...)
-                ?args)
-         (case-lambda
-           "CLAUSE"
-           ?args
-           ?l
-           ?clause1 ...))]
-    [(case-lambda
-       "CLAUSE"
-       ?args
-       ?l
-       [(?a1 . ?ar)
-        ?e1 ...]
-       ?clause1 ...)
-     (case-lambda
-       "IMPROPER"
-       ?args
-       ?l
-       1
-       [?a1
-        . ?ar]
-       [?ar
-        ?e1 ...]
-       ?clause1 ...)]
-    [(case-lambda
-       "CLAUSE"
-       ?args
-       ?l
-       [?a1
-        ?e1 ...])
-     (let ([?a1 ?args])
-       ?e1 ...)]
-    [(case-lambda
-       "CLAUSE"
-       ?args
-       ?l)
-     (error "Wrong number of arguments to CASE-LAMBDA.")]
-    [(case-lambda
-       "IMPROPER"
-       ?args
-       ?l
-       ?k
-       ?al
-       [(?a1 . ?ar)
-        ?e1 ...]
-       ?clause1 ...)
-     (case-lambda
-       "IMPROPER"
-       ?args
-       ?l
-       [+
-        ?k
-        1]
-       ?al
-       [?ar
-        ?e1 ...]
-       ?clause1 ...)]
-    [(case-lambda
-       "IMPROPER"
-       ?args
-       ?l
-       ?k
-       ?al
-       [?ar
-        ?e1 ...]
-       ?clause1 ...)
-     (if (>= ?l ?k)
-         (apply (lambda ?al
-                  ?e1 ...)
-                ?args)
-         (case-lambda
-           "CLAUSE"
-           ?args
-           ?l
-           ?clause1 ...))]))
-
-(define-syntax help
-  (syntax-rules ()
-    [(help) (simple-displayln "help expects an identifier to lookup documentation for")]
-    [(help ident) (%doc? %-builtin-module-steel/base (quote ident))]
-    [(help module ident) (%doc? (datum->syntax %-builtin-module- module) (quote ident))]))
-
-(define-syntax dbg!
-  (syntax-rules ()
-    [(dbg! expr)
-     (let ([result expr])
-       (simple-display (quote expr))
-       (simple-display " = ")
-       (simple-displayln result)
-       result)]))
-
-(define-syntax contract/out
-  (syntax-rules ()
-    [(contract/out name contract) (%require-ident-spec name (bind/c contract name 'name))]))
-
-(define (force promise)
-  (promise))
-
-;; syntax
-(define-syntax delay
-  (syntax-rules ()
-    [(delay expr) (lambda () expr)]))
-
-(define values list)
-(define (call-with-values producer consumer)
-  (define result (apply consumer (producer)))
-  (cond
-    [(not (list? result)) result]
-    [(= (length result) 1) (car result)]
-    [else result]))
-
-(define-syntax @doc
-  (syntax-rules (struct define/contract)
-    ; [(_ documentation (define name body))
-
-    ;  (begin
-    ;    ; (stdout-simple-displayln "Expanding doc top case: " (quote (define name body)))
-    ;    (define (datum->syntax name __doc__)
-    ;      documentation)
-    ;    (define name body)
-    ;    (#%function-ptr-table-add #%function-ptr-table name (datum->syntax name __doc__)))]
-
-    [(_ documentation
-        (define (name args ...)
-          body ...))
-
-     (begin
-       ; (stdout-simple-displayln "Expanding doc top case: " (quote (define name body)))
-       (define (datum->syntax name __doc__)
-         documentation)
-       (define (name args ...)
-         body ...)
-       (#%function-ptr-table-add #%function-ptr-table name (datum->syntax name __doc__)))]
-
-    [(_ documentation (define name body))
-
-     (begin
-       (define (datum->syntax name __doc__)
-         documentation)
-       (define name body)
-       (#%function-ptr-table-add #%function-ptr-table name (datum->syntax name __doc__)))]
-
-    [(_ documentation (struct name (args ...) options ...))
-
-     (begin
-
-       (define (datum->syntax name __doc__)
-         documentation)
-
-       (struct name (args ...) options ...)
-
-       (#%function-ptr-table-add #%function-ptr-table name (datum->syntax name __doc__)))]
-
-    [(_ documentation
-        (define/contract (name args ...)
-          body ...))
-
-     (begin
-       (define (datum->syntax name __doc__)
-         documentation)
-
-       (define/contract (name args ...)
-         body ...)
-
-       (#%function-ptr-table-add #%function-ptr-table name (datum->syntax name __doc__)))]
-
-    ; [(_ documentation
-    ;     (begin
-    ;       ; (#%black-box "STRUCT" (quote struct-name))
-    ;       exprs ...))
-
-    ;  (begin
-    ;    (stdout-simple-displayln "Matching on begin")
-    ;    exprs ...)]
-
-    ;  (begin
-    ;    (begin
-    ;      (define (datum->syntax struct-name __doc__)
-    ;        documentation)
-    ;      exprs ...)
-    ;    (#%function-ptr-table-add #%function-ptr-table struct-name (datum->syntax name __doc__)))]
-
-    [(_ documentation expr)
-
-     (begin
-       expr)]))
diff --git a/crates/steel-core/src/scheme/test.rkt b/crates/steel-core/src/scheme/test.rkt
deleted file mode 100644
index ad1be6427..000000000
--- a/crates/steel-core/src/scheme/test.rkt
+++ /dev/null
@@ -1,84 +0,0 @@
-; #lang racket
-
-(define-syntax quasiquote
-  (syntax-rules (unquote unquote-splicing)
-    ; ((quasiquote (quote (unquote x)))                 (quote (quasiquote (unquote x))))
-    ((quasiquote (unquote x))                         x)
-    ; ((quasiquote ((unquote x) xs))              (cons x (quasiquote xs)))
-    ((quasiquote ((unquote x) xs ...))          (cons x (quasiquote (xs ...))))
-    ((quasiquote ((unquote-splicing x)))        (append x '()))
-    ((quasiquote ((unquote-splicing x) xs ...)) (append x (quasiquote (xs ...))))
-    ; ((quasiquote (x))                          '(x))
-    ((quasiquote (x xs ...))                   (cons (quasiquote x) (quasiquote (xs ...))))
-    ; ((quasiquote (quote (unquote x)))          (quote x))
-    ((quasiquote x)                           'x)))
-
-
-(define struct-name 'Applesauce)
-(define fields '(a b c))
-
-;; TODO: This actually expands using the reader macro from the parser which expands fancy defines
-;;
-`(define ,struct-name (lambda ,fields (vector __magic_struct_symbol__ (quote ,struct-name) ,@fields)))
-
-(quasiquote (define (unquote struct-name)
-           (lambda (unquote fields)
-             (vector __magic_struct_symbol__
-                     (quote (unquote struct-name))
-                     (unquote-splicing fields)))))
-
-(define field '(getter 2))
-
-;; TODO: this parses the define incorrectly - it should go to an untyped AST and not a typed one
-`(define ,(concat-symbols struct-name '- (car field))
-                                      (bind/c (make-function/c
-                                               (make/c (concat-symbols struct-name '?) (quote ,(concat-symbols struct-name '?)))
-                                               (make/c any/c 'any/c))
-                                              (lambda (this) (vector-ref this ,(car (cdr field))))
-                                              (quote ,(concat-symbols struct-name '- (car field)))))
-
-
-`(define ,(concat-symbols struct-name '?) 
-                                    (bind/c (make-function/c (make/c any/c 'any/c) (make/c boolean? 'boolean?))
-                                      (lambda (this) (if (vector? this)
-                                                         (if (eq? (vector-ref this 0) ___magic_struct_symbol___)
-                                                             (equal? (vector-ref this 1) (quote ,struct-name))
-                                                             #f)
-                                                        #f))
-                                      (quote ,(concat-symbols struct-name '?))))
-
-
-(let ((function-name (concat-symbols struct-name '- (car fields)))
-                                          (pred-name (concat-symbols struct-name '?)))
-                                      `(define ,function-name
-                                         (bind/c (make-function/c
-                                                  (make/c ,pred-name (quote ,pred-name))
-                                                  (make/c any/c 'any/c))
-                                                 (lambda (this) (vector-ref this ,(car (cdr fields))))
-                                                 (quote ,function-name))))
-
-
-;; TODO: Go _back_ to an implementation that just uses S-Expressions and thats it for internal
-;; representation. Don't have special AST implementation other than in the core.
-;; Another solution that will get me part of the way there, is treating quasiquote like quote in the
-;; parser
-
-(define (enumerate start accum lst)
-  (if (empty? lst)
-      (reverse accum)
-      (enumerate (+ start 1)
-                 (cons (list (car lst) start)
-                       accum)
-                 (cdr lst))))
-
-(map (lambda (field)
-                (let ((function-name (concat-symbols 'set- struct-name '- (car fields) '!))
-                      (pred-name (concat-symbols struct-name '?)))
-                  `(define ,function-name
-                     (bind/c (make-function/c
-                              (make/c ,pred-name (quote ,pred-name))
-                              (make/c any/c 'any/c)
-                              (make/c any/c 'any/c))
-                             (lambda (this value) (vector-set! this ,(car (cdr field)) value))
-                             (quote ,function-name)))))
-              (enumerate 2 '() fields))
diff --git a/crates/steel-core/src/scheme/trie.rkt b/crates/steel-core/src/scheme/trie.rkt
deleted file mode 100644
index 33fea6a75..000000000
--- a/crates/steel-core/src/scheme/trie.rkt
+++ /dev/null
@@ -1,92 +0,0 @@
-(struct trie (char children end-word? word-up-to))
-
-;; Rename functions for the sake of compatibility
-(define empty (list))
-(define empty-trie (trie void empty #f empty))
-
-;; Throw in a mediocre flatten definition
-(define (flatten lst)
-  (cond ((null? lst) empty)
-        ((list? lst)
-         (append (flatten (car lst)) (flatten (cdr lst))))
-        (else (list lst))))
-
-;; contract: (listof char?) (listof tries?) integer? -> (listof trie?)
-(define (create-children char-list lst prefix-chars)
-  (cond [(= (length char-list) 1)
-         (handle-last-letter char-list lst prefix-chars)]
-        [else ;; you are in the middle of the word
-         (handle-intern-letter char-list lst prefix-chars)]))
-
-;; contract: (listof char?) (listof trie?) integer? -> (listof trie?)
-(define (handle-last-letter char-list lst prefix-chars)
-  (define char (first char-list))
-  ; (define next-prefix (append prefix-chars (list char)))
-  (define next-prefix (push-back prefix-chars char))
-  (cond [(empty? lst) ;; children are empty, return list of empty children
-         (list (trie char empty #t next-prefix))]
-        [(< char (trie-char (first lst))) ;; less than, put it to the left
-         (cons (trie char empty #t next-prefix) lst)]
-        [(= char (trie-char (first lst))) ;; equal, step down a level
-         (cons (trie char (trie-children (first lst)) #t next-prefix) (rest lst))]
-        [else ;; move to the right
-         (cons (first lst)
-               (create-children char-list (rest lst) prefix-chars))]))
-
-;; contract: (listof char?) (listof trie?) integer? -> (listof trie?)
-(define (handle-intern-letter char-list lst prefix-chars)
-  (define char (first char-list))
-  ; (define next-prefix (append prefix-chars (list char)))
-  (define next-prefix (push-back prefix-chars char))
-  (cond [(empty? lst) ;; no children, pop off front and step down
-         (list (trie char (create-children
-                           (rest char-list) empty next-prefix) #f next-prefix))]
-        [(< char (trie-char (first lst))) ;; place where it is, pop off front and go
-         (cons (trie char (create-children
-                           (rest char-list) empty next-prefix) #f next-prefix) lst)]
-        [(= char (trie-char (first lst))) ;; equal, step down
-         (cons (trie char (create-children (rest char-list) (trie-children (first lst)) next-prefix)
-                     (trie-end-word? (first lst))
-                     (trie-word-up-to (first lst)))
-               (rest lst))]
-        [else ; move to the right
-         (cons (first lst)
-               (create-children char-list (rest lst) prefix-chars))]))
-
-;; contract: trie? string? integer? -> trie?
-(define (insert root-trie word)
-  (define char-list (string->list word))
-  (trie
-   (trie-char root-trie)
-   (create-children char-list (trie-children root-trie) empty)
-   (trie-end-word? root-trie)
-   (trie-word-up-to root-trie)))
-
-; contract: trie? trie? -> boolean?
-(define (trie<? trie-node1 trie-node2)
-  (< (trie-char trie-node1) (trie-char trie-node2)))
-
-
-;; contract: trie? (listof string?) -> trie?
-(define (build-trie-from-list-of-words trie list-of-words)
-  (cond
-    [(= (length list-of-words) 1)
-     (insert trie (first list-of-words))]
-    [else
-     (build-trie-from-list-of-words
-      (insert trie (first list-of-words))
-      (rest list-of-words))]))
-
-;; ------------------ SORTING ---------------------- ;;
-
-(define (trie-sort list-of-words)
-  (define new-trie (build-trie-from-list-of-words empty-trie list-of-words))
-  (pre-order new-trie))
-
-; THIS ONE WORKS (using con and flatten)
-;; contract: trie? -> (listof string?)
-(define (pre-order trie-node)
-  (if (trie-end-word? trie-node)
-    (cons (list->string (trie-word-up-to trie-node))
-      (flatten (map pre-order (trie-children trie-node))))
-    (flatten (map pre-order (trie-children trie-node)))))
diff --git a/crates/steel-core/src/scheme/types.rkt b/crates/steel-core/src/scheme/types.rkt
deleted file mode 100644
index f84698823..000000000
--- a/crates/steel-core/src/scheme/types.rkt
+++ /dev/null
@@ -1,32 +0,0 @@
-(export define-type define-type-body define-type-help)
-
-(define-syntax define-type-help
-  (syntax-rules ()
-    [(define-type name (variant fields) rest ...)
-     (begin
-       (struct variant fields)
-       (define-type name rest ...))]
-    [(define-type name (variant fields))
-     (struct variant fields)]))
-
-(define-syntax define-type-body
-  (syntax-rules ()
-    [(define-type-body x (variant fields) rest ...)
-     (or ((datum->syntax variant ?) x)
-         (define-type-body x rest ...))]
-    [(define-type-body x (variant fields))
-     ((datum->syntax variant ?) x)]))
-
-
-(define-syntax define-type
-  (syntax-rules ()
-    [(define-type name (variant fields) rest ...)
-     (begin
-       (define ((datum->syntax name ?) x)
-         (define-type-body x (variant fields) rest ...))
-       (define-type-help name (variant fields) rest ...))]
-    [(define-type-test name (variant fields))
-     (begin
-       (define ((datum->syntax name ?) x)
-         (define-type-body x (variant fields)))
-       (define-type-help name (variant fields)))]))
\ No newline at end of file
diff --git a/crates/steel-core/src/stdlib.rs b/crates/steel-core/src/stdlib.rs
deleted file mode 100644
index 75c6c0d61..000000000
--- a/crates/steel-core/src/stdlib.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#[cfg(not(target_os = "windows"))]
-pub const PRELUDE: &str = include_str!("scheme/stdlib.scm");
-// pub const PRELUDE: &str = include_str!("scheme/test.rkt");
-#[cfg(not(target_os = "windows"))]
-pub const TRIESORT: &str = include_str!("scheme/trie.rkt");
-#[cfg(not(target_os = "windows"))]
-pub const TYPES: &str = include_str!("scheme/types.rkt");
-#[cfg(not(target_os = "windows"))]
-pub const METHODS: &str = include_str!("scheme/methods.rkt");
-#[cfg(not(target_os = "windows"))]
-pub const MERGE: &str = include_str!("scheme/merge.rkt");
-#[cfg(not(target_os = "windows"))]
-pub const COMPILER: &str = include_str!("scheme/nanopass.rkt");
-#[cfg(not(target_os = "windows"))]
-pub const KERNEL: &str = include_str!("scheme/kernel.scm");
-
-#[cfg(target_os = "windows")]
-pub const PRELUDE: &str = include_str!(r#"scheme\stdlib.scm"#);
-#[cfg(target_os = "windows")]
-pub const TRIESORT: &str = include_str!(r#"scheme\trie.rkt"#);
-#[cfg(target_os = "windows")]
-pub const TYPES: &str = include_str!(r#"scheme\types.rkt"#);
-#[cfg(target_os = "windows")]
-pub const MERGE: &str = include_str!(r#"scheme\merge.rkt"#);
-#[cfg(target_os = "windows")]
-pub const COMPILER: &str = include_str!(r#"scheme\nanopass.rkt"#);
-#[cfg(target_os = "windows")]
-pub const KERNEL: &str = include_str!(r#"scheme\kernel.scm"#);
diff --git a/crates/steel-core/src/steel_vm/builtin.rs b/crates/steel-core/src/steel_vm/builtin.rs
deleted file mode 100644
index 8d9942093..000000000
--- a/crates/steel-core/src/steel_vm/builtin.rs
+++ /dev/null
@@ -1,787 +0,0 @@
-use std::{borrow::Cow, cell::RefCell, rc::Rc, sync::Arc};
-
-use crate::{
-    containers::RegisterValue,
-    parser::{ast::ExprKind, interner::InternedString, parser::SyntaxObject, tokens::TokenType},
-    rvals::{Custom, FromSteelVal, FunctionSignature, IntoSteelVal, Result, SteelVal},
-    values::functions::BoxedDynFunction,
-};
-use im_rc::HashMap;
-use once_cell::sync::Lazy;
-
-/// A module to be consumed by the Steel Engine for later on demand access by scripts
-/// to refresh the primitives that are being used. For instance, the VM should have support
-/// for a primitive like so, where "kernel" has functions like `list`, `cons`, `car`, and `cdr`:
-///
-/// ```scheme
-/// (require-builtin "kernel")
-/// ```
-///
-/// This would then expand into a series of function calls like so:
-/// ```scheme
-/// (begin
-///     (define list (hash-get *--unreadable-module-name--kernel*))
-///     (define cons (hash-get *--unreadable-module-name--kernel*))
-///     (define car (hash-get *--unreadable-module-name--kernel*))
-///     (define cdr (hash-get *--unreadable-module-name--kernel*)))
-/// ```
-/// So for now, its just a hashmap that will get embedded smartly, accompanied with a macro that will assist
-/// with reserving the proper slots in the interner
-///
-/// TODO: @Matt - We run the risk of running into memory leaks here when exposing external mutable
-/// structs. This should be more properly documented.
-#[derive(Clone, Debug)]
-pub struct BuiltInModule {
-    module: Rc<RefCell<BuiltInModuleRepr>>,
-}
-
-#[derive(Clone, Debug)]
-struct BuiltInModuleRepr {
-    pub(crate) name: Rc<str>,
-    values: HashMap<Arc<str>, SteelVal>,
-    docs: Box<InternalDocumentation>,
-    // Add the metadata separate from the pointer, keeps the pointer slim
-    fn_ptr_table: HashMap<*const FunctionSignature, FunctionSignatureMetadata>,
-    // We don't need to generate this every time, just need to
-    // clone it?
-    generated_expression: RefCell<Option<ExprKind>>,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-// Probably need something more interesting than just an integer for the arity
-pub struct FunctionSignatureMetadata {
-    pub name: &'static str,
-    pub arity: Arity,
-    pub is_const: bool,
-}
-
-impl FunctionSignatureMetadata {
-    pub fn new(name: &'static str, arity: Arity, is_const: bool) -> Self {
-        Self {
-            name,
-            arity,
-            is_const,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Arity {
-    Exact(usize),
-    AtLeast(usize),
-    AtMost(usize),
-    Range(usize),
-}
-
-impl Custom for Arity {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(match self {
-            Arity::Exact(a) => format!("(Arity::Exact {a})"),
-            Arity::AtLeast(a) => format!("(Arity::AtLeast {a})"),
-            Arity::AtMost(a) => format!("(Arity::AtMost {a})"),
-            Arity::Range(a) => format!("(Arity::Range {a})"),
-        }))
-    }
-}
-
-impl Custom for FunctionSignatureMetadata {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!(
-            "(FunctionSignatureMetadata #:name {} #:arity {:?} #:const? {})",
-            self.name, self.arity, self.is_const
-        )))
-    }
-}
-
-impl Custom for BuiltInModule {}
-
-impl RegisterValue for BuiltInModule {
-    fn register_value_inner(&mut self, name: &str, value: SteelVal) -> &mut Self {
-        self.module.borrow_mut().values.insert(name.into(), value);
-        self
-    }
-}
-
-pub static MODULE_GET: Lazy<InternedString> = Lazy::new(|| "%module-get%".into());
-pub static VOID: Lazy<InternedString> = Lazy::new(|| "void".into());
-pub static GET_DYLIB: Lazy<InternedString> = Lazy::new(|| "#%get-dylib".into());
-
-// Global function table
-thread_local! {
-    pub static FUNCTION_TABLE: RefCell<HashMap<*const FunctionSignature, FunctionSignatureMetadata>> = RefCell::new(HashMap::new());
-}
-
-pub fn get_function_name(function: FunctionSignature) -> Option<FunctionSignatureMetadata> {
-    FUNCTION_TABLE.with(|x| {
-        x.borrow()
-            .get(&(function as *const FunctionSignature))
-            .copied()
-    })
-}
-
-pub struct NativeFunctionDefinition {
-    pub name: &'static str,
-    pub func: fn(&[SteelVal]) -> Result<SteelVal>,
-    pub arity: Arity,
-    pub doc: Option<MarkdownDoc<'static>>,
-    pub is_const: bool,
-}
-
-impl BuiltInModuleRepr {
-    pub fn new<T: Into<Rc<str>>>(name: T) -> Self {
-        Self {
-            name: name.into(),
-            values: HashMap::new(),
-            docs: Box::new(InternalDocumentation::new()),
-            fn_ptr_table: HashMap::new(),
-            generated_expression: RefCell::new(None),
-        }
-    }
-
-    // pub fn register_native_fn(
-    //     &mut self,
-    //     name: &'static str,
-    //     func: fn(&[SteelVal]) -> Result<SteelVal>,
-    //     arity: Arity,
-    // ) -> &mut Self {
-    //     // Just automatically add it to the function pointer table to help out with searching
-    //     self.add_to_fn_ptr_table(func, FunctionSignatureMetadata::new(name, arity, false));
-    //     self.register_value(name, SteelVal::FuncV(func))
-    // }
-
-    // pub fn register_native_fn_definition(
-    //     &mut self,
-    //     definition: NativeFunctionDefinition,
-    // ) -> &mut Self {
-    //     self.add_to_fn_ptr_table(
-    //         definition.func,
-    //         FunctionSignatureMetadata::new(definition.name, definition.arity, definition.is_const),
-    //     );
-    //     if let Some(doc) = definition.doc {
-    //         self.register_doc(definition.name, doc);
-    //     }
-    //     self.register_value(definition.name, SteelVal::FuncV(definition.func));
-    //     self
-    // }
-
-    // pub fn check_compatibility(self: &BuiltInModule) -> bool {
-    //     // self.version == env!("CARGO_PKG_VERSION")
-    //     true
-    // }
-
-    pub fn contains(&self, ident: &str) -> bool {
-        self.values.contains_key(ident)
-    }
-
-    pub(crate) fn add_to_fn_ptr_table(
-        &mut self,
-        value: FunctionSignature,
-        data: FunctionSignatureMetadata,
-    ) -> &mut Self {
-        // Store this in a globally accessible place for printing
-        FUNCTION_TABLE.with(|table| {
-            table
-                .borrow_mut()
-                .insert(value as *const FunctionSignature, data)
-        });
-
-        // Probably don't need to store it in both places?
-        self.fn_ptr_table
-            .insert(value as *const FunctionSignature, data);
-
-        self
-    }
-
-    pub fn search_by_name(&self, name: &str) -> Option<FunctionSignatureMetadata> {
-        self.values.get(name).and_then(|x| self.search(x.clone()))
-    }
-
-    pub fn search(&self, value: SteelVal) -> Option<FunctionSignatureMetadata> {
-        if let SteelVal::FuncV(f) = value {
-            self.fn_ptr_table
-                .get(&(f as *const FunctionSignature))
-                .cloned()
-            // None
-        } else {
-            None
-        }
-    }
-
-    pub fn bound_identifiers(&self) -> crate::values::lists::List<SteelVal> {
-        self.values
-            .keys()
-            .map(|x| SteelVal::StringV(x.to_string().into()))
-            .collect()
-    }
-
-    pub fn with_module(&mut self, module: BuiltInModule) {
-        self.values = std::mem::take(&mut self.values).union(module.module.borrow().values.clone());
-
-        self.docs
-            .definitions
-            .extend(module.module.borrow().docs.definitions.clone());
-    }
-
-    pub fn register_type<T: FromSteelVal + IntoSteelVal>(
-        &mut self,
-        predicate_name: &'static str,
-    ) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected 1 argument, got {}", predicate_name, args.len()));
-            }
-
-            assert!(args.len() == 1);
-
-            Ok(SteelVal::BoolV(T::from_steelval(&args[0]).is_ok()))
-        };
-
-        self.register_value(
-            predicate_name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(predicate_name),
-                Some(1),
-            ))),
-        )
-    }
-
-    pub fn register_doc(
-        &mut self,
-        definition: impl Into<Cow<'static, str>>,
-        description: impl Into<Documentation<'static>>,
-    ) -> &mut Self {
-        self.docs.register_doc(definition, description.into());
-        self
-    }
-
-    // pub fn docs(&self) ->
-
-    pub fn get_doc(&self, definition: String) {
-        if let Some(value) = self.docs.get(&definition) {
-            println!("{value}")
-        }
-    }
-
-    pub fn get_documentation(&self, definition: &str) -> Option<String> {
-        self.docs.get(definition).map(|x| x.to_string())
-    }
-
-    pub(crate) fn unreadable_name(&self) -> String {
-        "%-builtin-module-".to_string() + &self.name
-    }
-
-    /// Add a value to the module namespace. This value can be any legal SteelVal, or if you're explicitly attempting
-    /// to compile an program for later use and don't currently have access to the functions in memory, use `SteelVal::Void`
-    pub fn register_value(&mut self, name: &str, value: SteelVal) -> &mut Self {
-        self.values.insert(name.into(), value);
-        self
-    }
-
-    pub fn register_value_with_doc(
-        &mut self,
-        name: &'static str,
-        value: SteelVal,
-        doc: DocTemplate<'static>,
-    ) -> &mut Self {
-        self.values.insert(name.into(), value);
-        self.register_doc(Cow::from(name), doc);
-        self
-    }
-
-    // This _will_ panic given an incorrect value. This will be tied together by macros only allowing legal entries
-    pub fn get(&self, name: String) -> SteelVal {
-        self.values.get(name.as_str()).unwrap().clone()
-    }
-
-    /// This does the boot strapping for bundling modules
-    /// Rather than expose a native hash-get, the built in module above should expose a raw
-    /// function to fetch a dependency. It will be a packaged #<BuiltInModule> with only a function to
-    /// fetch a function given its registered name. For instance:
-    ///
-    /// (##module-get## ##unreadable-module-name-core-lists## 'list)
-    ///
-    /// This puts the onus on the expansion of a primitive on the compiler, but now the language
-    /// is bootstrapped via syntax-rules and the kernel macro expansion, and other dependencies
-    /// are included via the usual macro expansion.
-    ///
-    /// In this way its always possible to refresh the native functions (and they don't disappear),
-    /// and bundles of functions from third parties don't get included immediately into the global namespace.
-    /// Scripts can choose to include these modules directly, or opt to not, and are not as risk of clobbering their
-    /// global namespace.
-    pub fn to_syntax(&self, prefix: Option<&str>) -> ExprKind {
-        // log::debug!(target: "engine-creation", "{:p}, Creating module: {} - Prefix: {:?} - cached: {}", self, self.name, prefix, self.generated_expression.borrow().is_some());
-
-        // No need to generate this module multiple times -
-        if prefix.is_none() && self.generated_expression.borrow().is_some() {
-            return self.generated_expression.borrow().as_ref().unwrap().clone();
-        }
-
-        let module_name = self.unreadable_name();
-
-        let mut defines = self
-            .values
-            .keys()
-            .map(|x| {
-                // TODO: Consider a custom delimeter as well
-                // If we have a prefix, put the prefix at the front and append x
-                // Otherwise, just default to using the provided name
-                let name = prefix
-                    .map(|pre| pre.to_string() + x)
-                    .unwrap_or_else(|| x.to_string());
-
-                ExprKind::Define(Box::new(crate::parser::ast::Define::new(
-                    // TODO: Add the custom prefix here
-                    // Handling a more complex case of qualifying imports
-                    ExprKind::atom(name),
-                    ExprKind::List(crate::parser::ast::List::new(vec![
-                        ExprKind::atom(*MODULE_GET),
-                        ExprKind::atom(module_name.clone()),
-                        ExprKind::Quote(Box::new(crate::parser::ast::Quote::new(
-                            ExprKind::atom(x.to_string()),
-                            SyntaxObject::default(TokenType::Quote),
-                        ))),
-                    ])),
-                    SyntaxObject::default(TokenType::Define),
-                )))
-            })
-            .collect::<Vec<_>>();
-
-        defines.push(ExprKind::List(crate::parser::ast::List::new(vec![
-            ExprKind::atom(*MODULE_GET),
-            ExprKind::atom("%-builtin-module-".to_string() + "steel/constants"),
-            ExprKind::Quote(Box::new(crate::parser::ast::Quote::new(
-                ExprKind::atom(*VOID),
-                SyntaxObject::default(TokenType::Quote),
-            ))),
-        ])));
-
-        let res = ExprKind::Begin(crate::parser::ast::Begin::new(
-            defines,
-            SyntaxObject::default(TokenType::Begin),
-        ));
-
-        // Cache the generated expression
-        if prefix.is_none() && self.generated_expression.borrow().is_none() {
-            *self.generated_expression.borrow_mut() = Some(res.clone());
-        }
-
-        // log::debug!(target: "engine-creation", "Generating expression for: {} took: {:?}", self.name, now.elapsed());
-
-        res
-    }
-}
-
-impl BuiltInModule {
-    pub fn new<T: Into<Rc<str>>>(name: T) -> Self {
-        Self {
-            module: Rc::new(RefCell::new(BuiltInModuleRepr::new(name))),
-        }
-    }
-
-    pub fn name(&self) -> Rc<str> {
-        Rc::clone(&self.module.borrow().name)
-    }
-
-    pub fn documentation(&self) -> std::cell::Ref<'_, InternalDocumentation> {
-        std::cell::Ref::map(self.module.borrow(), |x| x.docs.as_ref())
-    }
-
-    // pub fn set_name(&mut self, name: String) {
-    //     self.name = name.into();
-    // }
-
-    pub fn register_native_fn(
-        &mut self,
-        name: &'static str,
-        func: fn(&[SteelVal]) -> Result<SteelVal>,
-        arity: Arity,
-    ) -> &mut Self {
-        // Just automatically add it to the function pointer table to help out with searching
-        self.add_to_fn_ptr_table(func, FunctionSignatureMetadata::new(name, arity, false));
-        self.register_value(name, SteelVal::FuncV(func))
-    }
-
-    pub fn register_native_fn_definition(
-        &mut self,
-        definition: NativeFunctionDefinition,
-    ) -> &mut Self {
-        self.add_to_fn_ptr_table(
-            definition.func,
-            FunctionSignatureMetadata::new(definition.name, definition.arity, definition.is_const),
-        );
-
-        if let Some(doc) = definition.doc {
-            self.register_doc(definition.name, doc);
-        }
-
-        self.register_value(definition.name, SteelVal::FuncV(definition.func));
-
-        self
-    }
-
-    pub fn check_compatibility(self: &BuiltInModule) -> bool {
-        // self.version == env!("CARGO_PKG_VERSION")
-        true
-    }
-
-    pub fn contains(&self, ident: &str) -> bool {
-        // self.values.contains_key(ident)
-        self.module.borrow().contains(ident)
-    }
-
-    pub(crate) fn add_to_fn_ptr_table(
-        &mut self,
-        value: FunctionSignature,
-        data: FunctionSignatureMetadata,
-    ) -> &mut Self {
-        // // Store this in a globally accessible place for printing
-        // FUNCTION_TABLE.with(|table| {
-        //     table
-        //         .borrow_mut()
-        //         .insert(value as *const FunctionSignature, data)
-        // });
-
-        // // Probably don't need to store it in both places?
-        // self.fn_ptr_table
-        //     .insert(value as *const FunctionSignature, data);
-
-        // self
-
-        self.module.borrow_mut().add_to_fn_ptr_table(value, data);
-
-        self
-    }
-
-    pub fn search(&self, value: SteelVal) -> Option<FunctionSignatureMetadata> {
-        self.module.borrow().search(value)
-    }
-
-    pub fn search_by_name(&self, name: &str) -> Option<FunctionSignatureMetadata> {
-        self.module.borrow().search_by_name(name)
-    }
-
-    pub fn bound_identifiers(&self) -> crate::values::lists::List<SteelVal> {
-        // self.values
-        //     .keys()
-        //     .map(|x| SteelVal::StringV(x.to_string().into()))
-        //     .collect()
-
-        self.module.borrow().bound_identifiers()
-    }
-
-    pub fn with_module(self, module: BuiltInModule) -> Self {
-        // self.values.extend(module.values.into_iter());
-
-        // self.docs.definitions.extend(module.docs.definitions);
-        // self
-
-        self.module.borrow_mut().with_module(module);
-        self
-    }
-
-    pub fn register_type<T: FromSteelVal + IntoSteelVal>(
-        &mut self,
-        predicate_name: &'static str,
-    ) -> &mut Self {
-        self.module.borrow_mut().register_type::<T>(predicate_name);
-        self
-    }
-
-    pub fn register_doc(
-        &mut self,
-        definition: impl Into<Cow<'static, str>>,
-        description: impl Into<Documentation<'static>>,
-    ) -> &mut Self {
-        // self.docs.register_doc(definition, description.into());
-        // self
-
-        self.module
-            .borrow_mut()
-            .register_doc(definition, description);
-        self
-    }
-
-    // pub fn docs(&self) ->
-
-    pub fn get_doc(&self, definition: String) {
-        // if let Some(value) = self.docs.get(&definition) {
-        //     println!("{value}")
-        // }
-
-        self.module.borrow().get_doc(definition);
-    }
-
-    pub fn get_documentation(&self, definition: &str) -> Option<String> {
-        self.module.borrow().get_documentation(definition)
-    }
-
-    pub(crate) fn unreadable_name(&self) -> String {
-        "%-builtin-module-".to_string() + &self.module.borrow().name
-    }
-
-    /// Add a value to the module namespace. This value can be any legal SteelVal, or if you're explicitly attempting
-    /// to compile an program for later use and don't currently have access to the functions in memory, use `SteelVal::Void`
-    pub fn register_value(&mut self, name: &str, value: SteelVal) -> &mut Self {
-        self.register_value_inner(name, value)
-    }
-
-    pub fn register_value_with_doc(
-        &mut self,
-        name: &'static str,
-        value: SteelVal,
-        doc: DocTemplate<'static>,
-    ) -> &mut Self {
-        // self.values.insert(name.into(), value);
-        // self.register_doc(Cow::from(name), doc);
-        // self
-
-        self.module
-            .borrow_mut()
-            .register_value_with_doc(name, value, doc);
-        self
-    }
-
-    // This _will_ panic given an incorrect value. This will be tied together by macros only allowing legal entries
-    pub fn get(&self, name: String) -> SteelVal {
-        // self.values.get(name.as_str()).unwrap().clone()
-
-        self.module.borrow().get(name)
-    }
-
-    // When we're loading dylib, we won't know anything about it until _after_ it is loaded. We don't explicitly
-    // want to load it before we need it, since the compiler should be able to analyze a dylib without having to
-    // have the dylib built and loaded into memory to do so.
-    pub fn dylib_to_syntax<'a>(
-        dylib_name: &'a str,
-        names: impl Iterator<Item = &'a str>,
-        prefix: Option<&str>,
-    ) -> ExprKind {
-        let mut defines = names
-            .map(|x| {
-                // TODO: Consider a custom delimeter as well
-                // If we have a prefix, put the prefix at the front and append x
-                // Otherwise, just default to using the provided name
-                let name = prefix
-                    .map(|pre| pre.to_string() + x)
-                    .unwrap_or_else(|| x.to_string());
-
-                ExprKind::Define(Box::new(crate::parser::ast::Define::new(
-                    // TODO: Add the custom prefix here
-                    // Handling a more complex case of qualifying imports
-                    ExprKind::atom(name),
-                    ExprKind::List(crate::parser::ast::List::new(vec![
-                        ExprKind::atom(*MODULE_GET),
-                        ExprKind::List(crate::parser::ast::List::new(vec![
-                            ExprKind::atom(*GET_DYLIB),
-                            ExprKind::string_lit(dylib_name.to_string()),
-                        ])),
-                        ExprKind::Quote(Box::new(crate::parser::ast::Quote::new(
-                            ExprKind::atom(x.to_string()),
-                            SyntaxObject::default(TokenType::Quote),
-                        ))),
-                    ])),
-                    SyntaxObject::default(TokenType::Define),
-                )))
-            })
-            .collect::<Vec<_>>();
-
-        defines.push(ExprKind::List(crate::parser::ast::List::new(vec![
-            ExprKind::atom(*MODULE_GET),
-            ExprKind::atom("%-builtin-module-".to_string() + "steel/constants"),
-            ExprKind::Quote(Box::new(crate::parser::ast::Quote::new(
-                ExprKind::atom(*VOID),
-                SyntaxObject::default(TokenType::Quote),
-            ))),
-        ])));
-
-        ExprKind::Begin(crate::parser::ast::Begin::new(
-            defines,
-            SyntaxObject::default(TokenType::Begin),
-        ))
-    }
-
-    /// This does the boot strapping for bundling modules
-    /// Rather than expose a native hash-get, the built in module above should expose a raw
-    /// function to fetch a dependency. It will be a packaged #<BuiltInModule> with only a function to
-    /// fetch a function given its registered name. For instance:
-    ///
-    /// (##module-get## ##unreadable-module-name-core-lists## 'list)
-    ///
-    /// This puts the onus on the expansion of a primitive on the compiler, but now the language
-    /// is bootstrapped via syntax-rules and the kernel macro expansion, and other dependencies
-    /// are included via the usual macro expansion.
-    ///
-    /// In this way its always possible to refresh the native functions (and they don't disappear),
-    /// and bundles of functions from third parties don't get included immediately into the global namespace.
-    /// Scripts can choose to include these modules directly, or opt to not, and are not as risk of clobbering their
-    /// global namespace.
-    pub fn to_syntax(&self, prefix: Option<&str>) -> ExprKind {
-        self.module.borrow().to_syntax(prefix)
-    }
-}
-
-/// Documentation representation
-#[derive(Clone, Debug)]
-pub struct InternalDocumentation {
-    definitions: im_rc::HashMap<Cow<'static, str>, Documentation<'static>>,
-}
-
-impl InternalDocumentation {
-    pub fn new() -> Self {
-        Self {
-            definitions: im_rc::HashMap::new(),
-        }
-    }
-
-    pub fn register_doc(
-        &mut self,
-        definition: impl Into<Cow<'static, str>>,
-        description: Documentation<'static>,
-    ) {
-        self.definitions.insert(definition.into(), description);
-    }
-
-    pub fn get(&self, definition: &str) -> Option<&Documentation<'static>> {
-        self.definitions.get(definition)
-    }
-
-    pub fn definitions(&self) -> &im_rc::HashMap<Cow<'static, str>, Documentation<'static>> {
-        &self.definitions
-    }
-}
-
-// pub(crate) const LAST_DOC: &'static str = r#"
-
-// (last l) -> any/c
-
-//     l : list?
-
-// Returns the last element in the list.
-// Takes time proportional to the length of the list.
-
-// Example:
-//     > (last (list 1 2 3 4))
-//     4
-
-// "#;
-
-// TODO: We're gonna need an FFI safe variant of this as well
-#[derive(Debug, Clone, PartialEq)]
-pub enum Documentation<'a> {
-    Function(DocTemplate<'a>),
-    Module(ModuleDoc<'a>),
-    Value(ValueDoc<'a>),
-    Markdown(MarkdownDoc<'a>),
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct DocTemplate<'a> {
-    pub signature: &'a str,
-    pub params: &'a [&'a str],
-    pub description: &'a str,
-    pub examples: &'a [(&'a str, &'a str)],
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ModuleDoc<'a> {
-    pub name: &'a str,
-    pub description: &'a str,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct ValueDoc<'a> {
-    pub name: &'a str,
-    pub description: &'a str,
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct MarkdownDoc<'a>(pub &'a str);
-
-impl<'a> std::fmt::Display for MarkdownDoc<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        #[cfg(feature = "markdown")]
-        return write!(f, "{}", termimad::text(self.0));
-
-        #[cfg(not(feature = "markdown"))]
-        return write!(f, "{}", self.0);
-    }
-}
-
-impl<'a> std::fmt::Display for Documentation<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Documentation::Function(d) => write!(f, "{d}"),
-            Documentation::Module(d) => write!(f, "{d}"),
-            Documentation::Value(d) => write!(f, "{d}"),
-            Documentation::Markdown(d) => write!(f, "{d}"),
-        }
-    }
-}
-
-impl<'a> std::fmt::Display for DocTemplate<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f)?;
-        writeln!(f, "{}", self.signature)?;
-        writeln!(f)?;
-
-        for param in self.params {
-            writeln!(f, "   {param}")?
-        }
-
-        writeln!(f)?;
-        writeln!(f, "{}", self.description)?;
-        writeln!(f)?;
-        if !self.examples.is_empty() {
-            writeln!(f, "Examples:")?;
-            for (example, output) in self.examples {
-                writeln!(f, "   {example}")?;
-                writeln!(f, "   {output}")?;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl<'a> std::fmt::Display for ValueDoc<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f)?;
-        writeln!(f, "{}", self.name)?;
-        writeln!(f)?;
-        writeln!(f, "{}", self.description)
-    }
-}
-
-impl<'a> std::fmt::Display for ModuleDoc<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f)?;
-        writeln!(f, "{}", self.name)?;
-        writeln!(f)?;
-        writeln!(f, "{}", self.description)
-    }
-}
-
-impl<'a> From<DocTemplate<'a>> for Documentation<'a> {
-    fn from(val: DocTemplate<'a>) -> Self {
-        Documentation::Function(val)
-    }
-}
-
-impl<'a> From<ModuleDoc<'a>> for Documentation<'a> {
-    fn from(val: ModuleDoc<'a>) -> Self {
-        Documentation::Module(val)
-    }
-}
-
-impl<'a> From<ValueDoc<'a>> for Documentation<'a> {
-    fn from(val: ValueDoc<'a>) -> Self {
-        Documentation::Value(val)
-    }
-}
-
-impl<'a> From<MarkdownDoc<'a>> for Documentation<'a> {
-    fn from(val: MarkdownDoc<'a>) -> Self {
-        Documentation::Markdown(val)
-    }
-}
diff --git a/crates/steel-core/src/steel_vm/cache.rs b/crates/steel-core/src/steel_vm/cache.rs
deleted file mode 100644
index ce5588b22..000000000
--- a/crates/steel-core/src/steel_vm/cache.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use std::{collections::HashMap, rc::Weak};
-
-use im_lists::list::List;
-use weak_table::WeakKeyHashMap;
-
-use crate::{rvals::Custom, values::functions::ByteCodeLambda, SteelVal};
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-struct FunctionArgs {
-    function: SteelVal,
-    arguments: Vec<SteelVal>,
-}
-
-#[derive(Clone, Debug)]
-// For now this has... no capacity, and no eviction strategy
-pub struct MemoizationTable {
-    table: HashMap<FunctionArgs, SteelVal>,
-}
-
-impl MemoizationTable {
-    pub fn new() -> Self {
-        Self {
-            table: HashMap::default(),
-        }
-    }
-
-    pub fn insert(&mut self, function: SteelVal, arguments: Vec<SteelVal>, value: SteelVal) {
-        self.table.insert(
-            FunctionArgs {
-                function,
-                arguments,
-            },
-            value,
-        );
-    }
-
-    pub fn get(&self, function: SteelVal, arguments: Vec<SteelVal>) -> Option<SteelVal> {
-        self.table
-            .get(&FunctionArgs {
-                function,
-                arguments,
-            })
-            .cloned()
-    }
-}
-
-pub struct WeakMemoizationTable {
-    table: WeakKeyHashMap<Weak<ByteCodeLambda>, HashMap<List<SteelVal>, SteelVal>>,
-}
-
-impl WeakMemoizationTable {
-    pub fn new() -> Self {
-        Self {
-            table: WeakKeyHashMap::default(),
-        }
-    }
-
-    pub fn insert(
-        &mut self,
-        function: SteelVal,
-        arguments: List<SteelVal>,
-        value: SteelVal,
-    ) -> crate::rvals::Result<()> {
-        // println!("Inserting args: {:?}", arguments);
-
-        if let SteelVal::Closure(l) = function {
-            if let Some(map) = self.table.get_mut(&l) {
-                map.insert(arguments, value);
-            } else {
-                let mut map = HashMap::new();
-                map.insert(arguments, value);
-
-                self.table.insert(l.0, map);
-            }
-        } else {
-            stop!(TypeMismatch => "memoization table expected a function, found: {:?}", function);
-        }
-
-        Ok(())
-    }
-
-    pub fn get(
-        &self,
-        function: SteelVal,
-        arguments: List<SteelVal>,
-    ) -> crate::rvals::Result<Option<SteelVal>> {
-        if let SteelVal::Closure(l) = function {
-            Ok(self.table.get(&l).and_then(|x| x.get(&arguments)).cloned())
-        } else {
-            stop!(TypeMismatch => "memoization table expected a function, found: {:?}", function);
-        }
-    }
-}
-
-impl Custom for WeakMemoizationTable {}
diff --git a/crates/steel-core/src/steel_vm/const_evaluation.rs b/crates/steel-core/src/steel_vm/const_evaluation.rs
deleted file mode 100644
index cea145578..000000000
--- a/crates/steel-core/src/steel_vm/const_evaluation.rs
+++ /dev/null
@@ -1,953 +0,0 @@
-use crate::compiler::passes::reader::MultipleArityFunctions;
-use crate::rvals::{Result, SteelVal};
-use crate::{
-    compiler::compiler::OptLevel,
-    parser::{
-        ast::{Atom, Begin, Define, LambdaFunction, List, Quote},
-        span_visitor::get_span,
-        visitors::{ConsumingVisitor, VisitorMut},
-    },
-};
-use crate::{
-    parser::{
-        ast::{ExprKind, If},
-        interner::InternedString,
-        kernel::Kernel,
-        parser::SyntaxObject,
-        tokens::TokenType,
-        tryfrom_visitor::TryFromExprKindForSteelVal,
-    },
-    rerrs::ErrorKind,
-    SteelErr,
-};
-use std::{
-    cell::RefCell,
-    collections::HashSet,
-    convert::TryFrom,
-    rc::{Rc, Weak},
-};
-
-use im_rc::HashMap;
-
-use steel_parser::tokens::MaybeBigInt;
-
-use super::cache::MemoizationTable;
-
-type SharedEnv = Rc<RefCell<ConstantEnv>>;
-
-struct ConstantEnv {
-    bindings: HashMap<InternedString, SteelVal>,
-    used_bindings: HashSet<InternedString>,
-    non_constant_bound: HashSet<InternedString>,
-    parent: Option<Weak<RefCell<ConstantEnv>>>,
-}
-
-impl ConstantEnv {
-    fn root(bindings: HashMap<InternedString, SteelVal>) -> Self {
-        Self {
-            bindings,
-            used_bindings: HashSet::new(),
-            non_constant_bound: HashSet::new(),
-            parent: None,
-        }
-    }
-
-    fn new_subexpression(parent: Weak<RefCell<ConstantEnv>>) -> Self {
-        Self {
-            bindings: HashMap::new(),
-            used_bindings: HashSet::new(),
-            non_constant_bound: HashSet::new(),
-            parent: Some(parent),
-        }
-    }
-
-    fn bind(&mut self, ident: &InternedString, value: SteelVal) {
-        self.bindings.insert(*ident, value);
-    }
-
-    fn bind_non_constant(&mut self, ident: &InternedString) {
-        self.non_constant_bound.insert(*ident);
-    }
-
-    fn get(&mut self, ident: &InternedString) -> Option<SteelVal> {
-        if self.non_constant_bound.get(ident).is_some() {
-            return None;
-        }
-
-        let value = self.bindings.get(ident);
-        if value.is_none() {
-            self.parent
-                .as_ref()?
-                .upgrade()
-                .expect("Constant environment freed early")
-                .borrow_mut()
-                .get(ident)
-        } else {
-            self.used_bindings.insert(*ident);
-            value.cloned()
-        }
-    }
-
-    fn _set(&mut self, ident: &InternedString, value: SteelVal) -> Option<SteelVal> {
-        let output = self.bindings.get(ident);
-        if output.is_none() {
-            self.parent
-                .as_ref()?
-                .upgrade()
-                .expect("Constant environment freed early")
-                .borrow_mut()
-                ._set(ident, value)
-        } else {
-            self.bindings.insert(*ident, value)
-        }
-    }
-
-    fn unbind(&mut self, ident: &InternedString) -> Option<()> {
-        if self.bindings.get(ident).is_some() {
-            self.bindings.remove(ident);
-            self.used_bindings.insert(*ident);
-        } else {
-            self.parent
-                .as_ref()?
-                .upgrade()
-                .expect("Constant environment freed early")
-                .borrow_mut()
-                .unbind(ident);
-        }
-        Some(())
-    }
-}
-
-// Holds the global env that will eventually get passed down
-// Holds the arena for all environments to eventually be dropped together
-pub struct ConstantEvaluatorManager<'a> {
-    global_env: SharedEnv,
-    set_idents: HashSet<InternedString>,
-    pub(crate) changed: bool,
-    opt_level: OptLevel,
-    memoization_table: &'a mut MemoizationTable,
-    kernel: &'a mut Option<Kernel>,
-}
-
-impl<'a> ConstantEvaluatorManager<'a> {
-    pub fn new(
-        memoization_table: &'a mut MemoizationTable,
-        constant_bindings: HashMap<InternedString, SteelVal>,
-        opt_level: OptLevel,
-        kernel: &'a mut Option<Kernel>,
-    ) -> Self {
-        Self {
-            global_env: Rc::new(RefCell::new(ConstantEnv::root(constant_bindings))),
-            set_idents: HashSet::new(),
-            changed: false,
-            opt_level,
-            memoization_table,
-            kernel,
-        }
-    }
-
-    pub fn run(&mut self, input: Vec<ExprKind>) -> Result<Vec<ExprKind>> {
-        self.changed = false;
-
-        let mut expr_level_sets = Vec::with_capacity(input.len());
-
-        // Collect the set expressions, ignore them for the constant folding
-        for expr in &input {
-            let mut collector = CollectSet::new(&mut self.set_idents);
-
-            collector.visit(expr);
-
-            expr_level_sets.push(collector.expr_level_set_idents);
-        }
-
-        input
-            .into_iter()
-            .zip(expr_level_sets)
-            .map(|(x, set)| {
-                let mut eval = ConstantEvaluator::new(
-                    Rc::clone(&self.global_env),
-                    &self.set_idents,
-                    &set,
-                    self.opt_level,
-                    self.memoization_table,
-                    self.kernel,
-                );
-                let output = eval.visit(x);
-                self.changed = self.changed || eval.changed;
-                output
-            })
-            .collect()
-    }
-}
-
-struct ConstantEvaluator<'a> {
-    bindings: SharedEnv,
-    set_idents: &'a HashSet<InternedString>,
-    expr_level_set_idents: &'a HashSet<InternedString>,
-    changed: bool,
-    opt_level: OptLevel,
-    memoization_table: &'a mut MemoizationTable,
-    kernel: &'a mut Option<Kernel>,
-}
-
-fn steelval_to_atom(value: &SteelVal) -> Option<TokenType<InternedString>> {
-    match value {
-        SteelVal::BoolV(b) => Some(TokenType::BooleanLiteral(*b)),
-        SteelVal::NumV(n) => Some(TokenType::NumberLiteral(*n)),
-        SteelVal::CharV(c) => Some(TokenType::CharacterLiteral(*c)),
-        SteelVal::IntV(i) => Some(TokenType::IntegerLiteral(MaybeBigInt::Small(*i))),
-        SteelVal::StringV(s) => Some(TokenType::StringLiteral(s.to_string())),
-        _ => None,
-    }
-}
-
-impl<'a> ConstantEvaluator<'a> {
-    fn new(
-        bindings: Rc<RefCell<ConstantEnv>>,
-        set_idents: &'a HashSet<InternedString>,
-        expr_level_set_idents: &'a HashSet<InternedString>,
-        opt_level: OptLevel,
-        memoization_table: &'a mut MemoizationTable,
-        kernel: &'a mut Option<Kernel>,
-    ) -> Self {
-        Self {
-            bindings,
-            set_idents,
-            expr_level_set_idents,
-            changed: false,
-            opt_level,
-            memoization_table,
-            kernel,
-        }
-    }
-
-    fn to_constant(&self, expr: &ExprKind) -> Option<SteelVal> {
-        match expr {
-            ExprKind::Atom(Atom { syn, .. }) => self.eval_atom(syn),
-            ExprKind::Quote(q) => {
-                let inner = &q.expr;
-                TryFromExprKindForSteelVal::try_from_expr_kind(inner.clone()).ok()
-            }
-            _ => None,
-        }
-    }
-
-    fn eval_atom(&self, t: &SyntaxObject) -> Option<SteelVal> {
-        match &t.ty {
-            TokenType::BooleanLiteral(b) => Some((*b).into()),
-            TokenType::Identifier(s) => {
-                // If we found a set identifier, skip it
-                if self.set_idents.get(s).is_some() || self.expr_level_set_idents.contains(s) {
-                    return None;
-                };
-                self.bindings.borrow_mut().get(s)
-            }
-            TokenType::NumberLiteral(n) => Some(SteelVal::NumV(*n)),
-            TokenType::StringLiteral(s) => Some(SteelVal::StringV(s.clone().into())),
-            TokenType::CharacterLiteral(c) => Some(SteelVal::CharV(*c)),
-            TokenType::IntegerLiteral(MaybeBigInt::Small(n)) => Some(SteelVal::IntV(*n)),
-            _ => None,
-        }
-    }
-
-    fn all_to_constant(&self, exprs: &[ExprKind]) -> Option<Vec<SteelVal>> {
-        exprs.iter().map(|x| self.to_constant(x)).collect()
-    }
-
-    fn eval_kernel_function(
-        &mut self,
-        ident: InternedString,
-        func: ExprKind,
-        mut raw_args: Vec<ExprKind>,
-        args: &[SteelVal],
-    ) -> Result<ExprKind> {
-        // println!(
-        //     "Calling function: {} with args: {:?}",
-        //     ident.resolve(),
-        //     args
-        // );
-
-        // TODO: We should just bail immediately if this results in an error
-        let output = match self.kernel.as_mut().unwrap().call_function(&ident, args) {
-            Ok(v) => v,
-            Err(_) => {
-                // log::error!("{:?}", e);
-                raw_args.insert(0, func);
-                return Ok(ExprKind::List(List::new(raw_args)));
-            }
-        };
-
-        if let Some(new_token) = steelval_to_atom(&output) {
-            let atom = Atom::new(SyntaxObject::new(new_token, get_span(&func)));
-            // debug!(
-            //     "Const evaluation of a function resulted in an atom: {}",
-            //     atom
-            // );
-            self.changed = true;
-            Ok(ExprKind::Atom(atom))
-        } else if let Ok(lst) = ExprKind::try_from(&output) {
-            self.changed = true;
-            let output = ExprKind::Quote(Box::new(Quote::new(
-                lst,
-                SyntaxObject::new(TokenType::Quote, get_span(&func)),
-            )));
-            // debug!(
-            //     "Const evaluation of a function resulted in a quoted value: {}",
-            //     output
-            // );
-            Ok(output)
-        } else {
-            // debug!(
-            //     "Unable to convert constant-evalutable function output to value: {}",
-            //     func
-            // );
-            // Something went wrong
-            raw_args.insert(0, func);
-            Ok(ExprKind::List(List::new(raw_args)))
-        }
-
-        // todo!()
-    }
-
-    fn eval_function(
-        &mut self,
-        evaluated_func: SteelVal,
-        func: ExprKind,
-        mut raw_args: Vec<ExprKind>,
-        args: &[SteelVal],
-    ) -> Result<ExprKind> {
-        if evaluated_func.is_function() {
-            match evaluated_func {
-                SteelVal::MutFunc(f) => {
-                    let mut args = args.to_vec();
-
-                    let output = f(&mut args)
-                        .map_err(|e| e.set_span_if_none(func.atom_syntax_object().unwrap().span))?;
-
-                    self.handle_output(output, func, raw_args)
-                }
-                SteelVal::FuncV(f) => {
-                    // TODO: Clean this up - we shouldn't even enter this section of the code w/o having
-                    // the actual atom itself.
-                    let output = if let Some(output) = self
-                        .memoization_table
-                        .get(SteelVal::FuncV(f), args.to_vec())
-                    {
-                        output
-                    } else {
-                        let output = f(args).map_err(|e| {
-                            e.set_span_if_none(func.atom_syntax_object().unwrap().span)
-                        })?;
-
-                        self.memoization_table.insert(
-                            SteelVal::FuncV(f),
-                            args.to_vec(),
-                            output.clone(),
-                        );
-
-                        output
-                    };
-
-                    self.handle_output(output, func, raw_args)
-                }
-                _ => {
-                    // debug!(
-                    //     "Found a non-constant evaluatable function: {}",
-                    //     evaluated_func
-                    // );
-                    raw_args.insert(0, func);
-                    // Not a constant evaluatable function, just return the original input
-                    Ok(ExprKind::List(List::new(raw_args)))
-                }
-            }
-        } else {
-            raw_args.insert(0, func);
-            Ok(ExprKind::List(List::new(raw_args)))
-        }
-    }
-
-    fn handle_output(
-        &mut self,
-        output: SteelVal,
-        func: ExprKind,
-        // evaluated_func: &SteelVal,
-        mut raw_args: Vec<ExprKind>,
-    ) -> std::result::Result<ExprKind, crate::SteelErr> {
-        if let Some(new_token) = steelval_to_atom(&output) {
-            let atom = Atom::new(SyntaxObject::new(new_token, get_span(&func)));
-            // debug!(
-            //     "Const evaluation of a function resulted in an atom: {}",
-            //     atom
-            // );
-            self.changed = true;
-            Ok(ExprKind::Atom(atom))
-        } else if let Ok(lst) = ExprKind::try_from(&output) {
-            self.changed = true;
-            let output = ExprKind::Quote(Box::new(Quote::new(
-                lst,
-                SyntaxObject::new(TokenType::Quote, get_span(&func)),
-            )));
-            // debug!(
-            //     "Const evaluation of a function resulted in a quoted value: {}",
-            //     output
-            // );
-            Ok(output)
-        } else {
-            // debug!(
-            //     "Unable to convert constant-evalutable function output to value: {}",
-            //     evaluated_func
-            // );
-            // Something went wrong
-            raw_args.insert(0, func);
-            Ok(ExprKind::List(List::new(raw_args)))
-        }
-    }
-}
-
-impl<'a> ConsumingVisitor for ConstantEvaluator<'a> {
-    type Output = Result<ExprKind>;
-
-    fn visit_if(&mut self, f: Box<crate::parser::ast::If>) -> Self::Output {
-        // Visit the test expression
-        let test_expr = self.visit(f.test_expr)?;
-
-        if self.opt_level == OptLevel::Three {
-            if let Some(test_expr) = self.to_constant(&test_expr) {
-                self.changed = true;
-                if test_expr.is_truthy() {
-                    // debug!("Const evaluation resulted in taking the then branch");
-                    return self.visit(f.then_expr);
-                } else {
-                    // debug!("Const evaluation resulted in taking the else branch");
-                    return self.visit(f.else_expr);
-                }
-            }
-        }
-
-        // If we found a constant, we can elect to only take the truthy path
-        // if let Some(test_expr) = self.to_constant(&test_expr) {
-        //     self.changed = true;
-        //     if test_expr.is_truthy() {
-        //         self.visit(f.then_expr)
-        //     } else {
-        //         self.visit(f.else_expr)
-        //     }
-        // } else {
-        Ok(ExprKind::If(
-            If::new(
-                test_expr,
-                self.visit(f.then_expr)?,
-                self.visit(f.else_expr)?,
-                f.location,
-            )
-            .into(),
-        ))
-        // }
-    }
-
-    fn visit_define(&mut self, define: Box<crate::parser::ast::Define>) -> Self::Output {
-        let identifier = &define.name.atom_identifier_or_else(
-            throw!(BadSyntax => format!("Define expects an identifier, found: {}", define.name); define.location.span),
-        )?;
-
-        let body = self.visit(define.body)?;
-
-        if let Some(c) = self.to_constant(&body) {
-            self.bindings.borrow_mut().bind(identifier, c);
-        } else {
-            self.bindings.borrow_mut().bind_non_constant(identifier);
-        }
-
-        Ok(ExprKind::Define(
-            Define::new(define.name, body, define.location).into(),
-        ))
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        mut lambda_function: Box<crate::parser::ast::LambdaFunction>,
-    ) -> Self::Output {
-        let parent = Rc::clone(&self.bindings);
-        let mut new_env = ConstantEnv::new_subexpression(Rc::downgrade(&parent));
-
-        for arg in &lambda_function.args {
-            let identifier = arg.atom_identifier_or_else(
-                throw!(BadSyntax => format!("lambda expects an identifier for the arguments, found: {arg}"); lambda_function.location.span),
-            )?;
-            new_env.bind_non_constant(identifier);
-        }
-
-        self.bindings = Rc::new(RefCell::new(new_env));
-
-        lambda_function.body = self.visit(lambda_function.body)?;
-
-        self.bindings = parent;
-
-        Ok(ExprKind::LambdaFunction(lambda_function))
-    }
-
-    // TODO remove constants from the begins
-    fn visit_begin(&mut self, begin: crate::parser::ast::Begin) -> Self::Output {
-        Ok(ExprKind::Begin(Begin::new(
-            begin
-                .exprs
-                .into_iter()
-                .map(|x| self.visit(x))
-                .collect::<Result<Vec<_>>>()?,
-            begin.location,
-        )))
-    }
-
-    fn visit_return(&mut self, mut r: Box<crate::parser::ast::Return>) -> Self::Output {
-        r.expr = self.visit(r.expr)?;
-        Ok(ExprKind::Return(r))
-    }
-
-    fn visit_quote(&mut self, quote: Box<crate::parser::ast::Quote>) -> Self::Output {
-        Ok(ExprKind::Quote(quote))
-    }
-
-    fn visit_macro(&mut self, _m: Box<crate::parser::ast::Macro>) -> Self::Output {
-        stop!(Generic => "unexpected macro found in const evaluator");
-    }
-
-    fn visit_atom(&mut self, a: crate::parser::ast::Atom) -> Self::Output {
-        if let Some(inner) = self.eval_atom(&a.syn) {
-            // TODO Check this part - be able to propagate quoted values
-            if let Some(new_token) = steelval_to_atom(&inner) {
-                let atom = Atom::new(SyntaxObject::new(new_token, a.syn.span));
-                return Ok(ExprKind::Atom(atom));
-            }
-        }
-        Ok(ExprKind::Atom(a))
-    }
-
-    // Certainly the most complicated case: function application
-    // Check if its a function application, and go for it
-    fn visit_list(&mut self, l: crate::parser::ast::List) -> Self::Output {
-        if l.args.is_empty() {
-            stop!(BadSyntax => "empty function application"; get_span(&ExprKind::List(l)));
-        }
-
-        if l.args.len() == 1 {
-            let mut args_iter = l.args.into_iter();
-            let func_expr = args_iter.next().unwrap();
-            let func = self.visit(func_expr)?;
-
-            if let Some(evaluated_func) = self.to_constant(&func) {
-                // debug!("Attempting to evaluate: {}", &func);
-                return self.eval_function(evaluated_func, func, Vec::new(), &[]);
-            } else if let Some(ident) = func.atom_identifier().and_then(|x| {
-                // TODO: @Matt 4/24/23 - this condition is super ugly and I would prefer if we cleaned it up
-                if self.kernel.is_some() && self.kernel.as_ref().unwrap().is_constant(x) {
-                    Some(x)
-                } else {
-                    None
-                }
-            }) {
-                // log::debug!("Running kernel function!");
-
-                return self.eval_kernel_function(ident.clone(), func, Vec::new(), &[]);
-            } else {
-                if let ExprKind::LambdaFunction(f) = &func {
-                    if !f.args.is_empty() {
-                        stop!(ArityMismatch => format!("function expected {} arguments, found 0", f.args.len()))
-                    }
-
-                    // If the body is constant we can safely remove the application
-                    // Otherwise we can't eliminate the additional scope depth
-                    if self.to_constant(&f.body).is_some() {
-                        return Ok(f.body.clone());
-                    }
-                }
-
-                let new_expr = vec![func].into_iter().chain(args_iter).collect();
-
-                return Ok(ExprKind::List(List::new(new_expr)));
-            }
-        }
-
-        let mut args = l.args.into_iter();
-
-        let func_expr = args.next().expect("Function missing");
-        let mut args: Vec<_> = args.map(|x| self.visit(x)).collect::<Result<_>>()?;
-
-        // Resolve the arguments - if they're all constants, we have a chance to do constant evaluation
-        if let Some(arguments) = self.all_to_constant(&args) {
-            if let ExprKind::Atom(_) = &func_expr {
-                // let span = get_span(&func_expr);
-
-                if let Some(evaluated_func) = self.to_constant(&func_expr) {
-                    // println!(
-                    //     "Attempting to evaluate: {} with args: {:?}",
-                    //     &func_expr, arguments
-                    // );
-                    // TODO: This shouldn't fail here under normal circumstances! If the end result is an error, we should
-                    // just return the value that was originally passed in. Otherwise, this signals
-                    // an error in the dataflow, and it means we're checking a condition that isn't constant
-                    // before applying a check against a constant value (which probably means we're missing)
-                    // something in the constant evaluation check. In which case, we should probably
-                    // just not stop the execution just because we errored
-                    return self.eval_function(evaluated_func, func_expr, args, &arguments);
-                } else if let Some(ident) = func_expr.atom_identifier().and_then(|x| {
-                    // TODO: @Matt 4/24/23 - this condition is super ugly and I would prefer if we cleaned it up
-                    if self.kernel.is_some() && self.kernel.as_ref().unwrap().is_constant(x) {
-                        Some(x)
-                    } else {
-                        None
-                    }
-                }) {
-                    return self.eval_kernel_function(ident.clone(), func_expr, args, &arguments);
-                }
-                // return self.eval_function(func_expr, span, &arguments);
-            }
-        }
-
-        match &func_expr {
-            ExprKind::LambdaFunction(_) => {}
-            _ => {
-                let visited_func_expr = self.visit(func_expr)?;
-                args.insert(0, visited_func_expr);
-                return Ok(ExprKind::List(List::new(args)));
-            } // ExprKind::
-        }
-
-        if let ExprKind::LambdaFunction(mut l) = func_expr {
-            // It is possible at this point, that multi arity functions have not yet been expanded.
-            // We need to check if thats the case here
-            if !l.rest {
-                use crate::compiler::passes::Folder;
-
-                if let ExprKind::LambdaFunction(out_lambda) =
-                    MultipleArityFunctions::new().visit_lambda_function(l)
-                {
-                    l = out_lambda;
-                } else {
-                    unreachable!();
-                }
-            }
-
-            if l.args.len() != args.len() && !l.rest {
-                println!("{}", l);
-
-                let m = format!(
-                    "Anonymous function expected {} arguments, found {}",
-                    l.args.len(),
-                    args.len()
-                );
-                stop!(ArityMismatch => m; l.location.span);
-            }
-
-            let mut new_env = ConstantEnv::new_subexpression(Rc::downgrade(&self.bindings));
-
-            if l.rest {
-                if let Some((l_last, l_start)) = l.args.split_last() {
-                    let non_list_bindings = &args[0..l_start.len()];
-                    // let list_binding = &args[l_start.len()..];
-
-                    // If this is a rest arg, bind differently
-                    for (var, arg) in l_start.iter().zip(non_list_bindings) {
-                        let identifier = var.atom_identifier_or_else(
-                            throw!(BadSyntax => format!("lambda expects an identifier for the arguments: {var}"); l.location.span),
-                        )?;
-                        if let Some(c) = self.to_constant(arg) {
-                            new_env.bind(identifier, c);
-                        } else {
-                            new_env.bind_non_constant(identifier);
-                        }
-                    }
-
-                    let last_identifier = l_last.atom_identifier_or_else(
-                            throw!(BadSyntax => format!("lambda expects an identifier for the arguments: {l_last}"); l.location.span),
-                        )?;
-
-                    let mut rest_args = Vec::new();
-
-                    for arg in &args[l_start.len()..] {
-                        if let Some(c) = self.to_constant(arg) {
-                            rest_args.push(c);
-                        } else {
-                            new_env.bind_non_constant(last_identifier);
-                            break;
-                        }
-                    }
-
-                    // If the length is the same, we didn't need to break early, meaning
-                    // the whole list is constant values
-                    if rest_args.len() == args[l_start.len()..].len() {
-                        let list = SteelVal::ListV(rest_args.into());
-
-                        new_env.bind(last_identifier, list);
-                    }
-                }
-            } else {
-                // If this is a rest arg, bind differently
-                for (var, arg) in l.args.iter().zip(args.iter()) {
-                    let identifier = var.atom_identifier_or_else(
-                    throw!(BadSyntax => format!("lambda expects an identifier for the arguments: {var}"); l.location.span),
-                )?;
-                    if let Some(c) = self.to_constant(arg) {
-                        new_env.bind(identifier, c);
-                    } else {
-                        new_env.bind_non_constant(identifier);
-                    }
-                }
-            }
-
-            let parent = Rc::clone(&self.bindings);
-            self.bindings = Rc::new(RefCell::new(new_env));
-
-            let output = self.visit(l.body)?;
-
-            // Unwind the 'recursion'
-            // self.bindings = parent;
-
-            // Find which variables and arguments are actually used in the body of the function
-            let mut actually_used_variables = Vec::new();
-            let mut actually_used_arguments = Vec::new();
-
-            let mut non_constant_arguments = Vec::new();
-
-            let span = l.location.span;
-
-            for (var, arg) in l.args.iter().zip(args.iter()) {
-                let identifier = var.atom_identifier_or_else(
-                    throw!(BadSyntax => format!("lambda expects an identifier for the arguments: {var}"); span),
-                )?;
-
-                // If the argument/variable is used internally, keep it
-                // Also, if the argument is _not_ a constant
-                if self.bindings.borrow().used_bindings.contains(identifier) {
-                    // if self.to_constant(arg).is_none() {
-                    // println!("FOUND ARGUMENT: {}", identifier);
-                    actually_used_variables.push(var.clone());
-                    actually_used_arguments.push(arg.clone());
-                    // }
-                } else if self.to_constant(arg).is_none() {
-                    // actually_used_variables.push(var.clone());
-                    // println!("Found a non constant argument: {}", arg);
-                    non_constant_arguments.push(arg.clone());
-                }
-            }
-
-            // Found no arguments are there are no non constant arguments
-            if actually_used_arguments.is_empty() && non_constant_arguments.is_empty() {
-                // debug!("Found no used arguments or non constant arguments, returning the body");
-
-                // Unwind the recursion before we bail out
-                self.bindings = parent;
-
-                self.changed = true;
-                return Ok(output);
-            }
-
-            // if actually_used_arguments.is_empty() {
-            //     non_constant_arguments.push(output);
-            //     return Ok(ExprKind::Begin(Begin::new(
-            //         non_constant_arguments,
-            //         l.location,
-            //     )));
-            // }
-
-            // TODO only do this if all of the args are constant as well
-            // Find a better way to do this
-            if let Some(value_output) = self.to_constant(&output) {
-                let mut non_constant_arguments: Vec<_> = args
-                    .into_iter()
-                    .filter(|x| self.to_constant(x).is_none())
-                    .collect();
-
-                // debug!("Found a constant output from the body");
-
-                self.changed = true;
-                self.bindings = parent;
-                if non_constant_arguments.is_empty() {
-                    // println!("Returning here!");
-                    return ExprKind::try_from(&value_output)
-                        .map_err(|x| SteelErr::new(ErrorKind::Generic, x.to_string()))
-                        .map(|x| {
-                            ExprKind::Quote(Box::new(Quote::new(
-                                x,
-                                SyntaxObject::default(TokenType::Quote),
-                            )))
-                        });
-                } else {
-                    non_constant_arguments.push(output);
-                    // TODO come up witih a better location
-                    return Ok(ExprKind::Begin(Begin::new(
-                        non_constant_arguments,
-                        l.location,
-                    )));
-                }
-            }
-
-            // Unwind the 'recursion'
-            self.bindings = parent;
-
-            // let constructed_func = ExprKind::LambdaFunction(
-            //     LambdaFunction::new(actually_used_variables, output, l.location).into(),
-            // );
-
-            let func = if l.rest {
-                LambdaFunction::new_with_rest_arg(l.args, output, l.location)
-            } else {
-                LambdaFunction::new(l.args, output, l.location)
-            };
-
-            let constructed_func = ExprKind::LambdaFunction(func.into());
-
-            // Insert the visited function at the beginning of the args
-            args.insert(0, constructed_func);
-            // actually_used_arguments.insert(0, constructed_func);
-
-            Ok(ExprKind::List(List::new(args)))
-            // return Ok(ExprKind::List(List::new(actually_used_arguments)));
-
-            // unimplemented!()
-        } else {
-            unreachable!();
-        }
-    }
-
-    fn visit_syntax_rules(&mut self, _l: Box<crate::parser::ast::SyntaxRules>) -> Self::Output {
-        stop!(Generic => "unexpected syntax rules in const evaluator");
-    }
-
-    fn visit_set(&mut self, s: Box<crate::parser::ast::Set>) -> Self::Output {
-        let identifier = &s.variable.atom_identifier_or_else(
-            throw!(BadSyntax => "set expects an identifier"; s.location.span),
-        )?;
-
-        self.bindings.borrow_mut().unbind(identifier);
-
-        Ok(ExprKind::Set(s))
-    }
-
-    fn visit_require(&mut self, _s: crate::parser::ast::Require) -> Self::Output {
-        stop!(Generic => "unexpected require - require is only allowed at the top level");
-    }
-
-    // TODO come back to this
-    fn visit_let(&mut self, l: Box<crate::parser::ast::Let>) -> Self::Output {
-        // panic!("---------------------------Visiting let!--------------------");
-
-        // let mut visited_bindings = Vec::new();
-
-        // for (binding, expr) in l.bindings {
-        //     visited_bindings.push((self.visit(binding)?, self.visit(expr)?));
-        // }
-
-        // l.bindings = visited_bindings;
-        // l.body_expr = self.visit(l.body_expr)?;
-
-        Ok(ExprKind::Let(l))
-    }
-}
-
-// TODO: If the value is local, we need to exclude it:
-// entering and exiting a scope should push and pop it off.
-struct CollectSet<'a> {
-    set_idents: &'a mut HashSet<InternedString>,
-    scopes: quickscope::ScopeSet<InternedString>,
-    pub expr_level_set_idents: HashSet<InternedString>,
-}
-
-impl<'a> CollectSet<'a> {
-    fn new(set_idents: &'a mut HashSet<InternedString>) -> Self {
-        Self {
-            set_idents,
-            scopes: quickscope::ScopeSet::default(),
-            expr_level_set_idents: HashSet::new(),
-        }
-    }
-}
-
-impl<'a> VisitorMut for CollectSet<'a> {
-    type Output = ();
-
-    fn visit_if(&mut self, f: &If) -> Self::Output {
-        self.visit(&f.test_expr);
-        self.visit(&f.then_expr);
-        self.visit(&f.else_expr);
-    }
-
-    fn visit_define(&mut self, define: &Define) -> Self::Output {
-        self.visit(&define.name);
-        self.visit(&define.body);
-    }
-
-    fn visit_lambda_function(&mut self, lambda_function: &LambdaFunction) -> Self::Output {
-        self.scopes.push_layer();
-
-        for arg in &lambda_function.args {
-            if let Some(ident) = arg.atom_identifier() {
-                self.scopes.define(*ident);
-            }
-        }
-
-        self.visit(&lambda_function.body);
-
-        self.scopes.pop_layer();
-    }
-
-    fn visit_begin(&mut self, begin: &Begin) -> Self::Output {
-        for expr in &begin.exprs {
-            self.visit(expr);
-        }
-    }
-
-    fn visit_return(&mut self, r: &crate::parser::ast::Return) -> Self::Output {
-        self.visit(&r.expr);
-    }
-
-    fn visit_quote(&mut self, _quote: &Quote) -> Self::Output {}
-
-    fn visit_macro(&mut self, _m: &crate::parser::ast::Macro) -> Self::Output {}
-
-    fn visit_atom(&mut self, _a: &Atom) -> Self::Output {}
-
-    fn visit_list(&mut self, l: &List) -> Self::Output {
-        for expr in &l.args {
-            self.visit(expr);
-        }
-    }
-
-    fn visit_syntax_rules(&mut self, _l: &crate::parser::ast::SyntaxRules) -> Self::Output {}
-
-    fn visit_set(&mut self, s: &crate::parser::ast::Set) -> Self::Output {
-        if let Ok(identifier) = s.variable.atom_identifier_or_else(
-            throw!(BadSyntax => "set expects an identifier"; s.location.span),
-        ) {
-            if !self.scopes.contains(identifier) {
-                // println!("NOT IN SCOPE: {}", identifier.resolve());
-
-                self.set_idents.insert(*identifier);
-            } else {
-                self.expr_level_set_idents.insert(*identifier);
-
-                // println!("IN SCOPE: {}", identifier.resolve());
-            }
-
-            // self.set_idents.insert(*identifier);
-        }
-
-        self.visit(&s.expr);
-    }
-
-    fn visit_require(&mut self, _s: &crate::parser::ast::Require) -> Self::Output {}
-
-    fn visit_let(&mut self, l: &crate::parser::ast::Let) -> Self::Output {
-        self.scopes.push_layer();
-        l.bindings.iter().for_each(|x| self.visit(&x.1));
-
-        for (arg, _) in &l.bindings {
-            if let Some(ident) = arg.atom_identifier() {
-                self.scopes.define(*ident);
-            }
-        }
-
-        self.visit(&l.body_expr);
-
-        self.scopes.pop_layer();
-    }
-}
diff --git a/crates/steel-core/src/steel_vm/contract_checker.rs b/crates/steel-core/src/steel_vm/contract_checker.rs
deleted file mode 100644
index 72405e521..000000000
--- a/crates/steel-core/src/steel_vm/contract_checker.rs
+++ /dev/null
@@ -1,760 +0,0 @@
-/*
-
-#![allow(unused)]
-use std::collections::{BTreeSet, HashMap};
-
-use quickscope::ScopeMap;
-
-use crate::{
-    compiler::passes::VisitorMutUnitRef,
-    parser::{tokens::TokenType, visitors::VisitorMut},
-};
-use crate::{parser::ast::ExprKind, rvals::Result};
-
-/*
-(define applesauce
-    (bind/c
-        (make-function/c
-            (make/c int? 'int?)
-            (make/c int? 'int?)
-            (make/c int? 'int?)
-            (make/c int? 'int?))
-        (lambda (x y z) (begin (+ x y z)))
-    applesauce))
-
-(define dummy
-    (bind/c
-        (make-function/c
-            (make/c string? string?)
-            (make/c integer? integer?)
-            (make/c
-                (make-function/c
-                    (make/c string? string?)
-                    (make/c string? string?))
-            (make-function/c
-                (make/c string? string?)
-                (make/c string? string?))))
-    (lambda (foo bar)
-        (begin (list (int->string bar) foo))) dummy))
-
-
-*/
-
-// Corresponds to a concrete type, referenced by a contract
-// For instance, this should be coerced from the contract type given the inference
-// integer? -> Int
-// string? -> String
-// UnknownStruct? -> Other("UnknownStruct?")
-
-#[derive(Debug, PartialEq, PartialOrd)]
-pub enum BaseTypeKind<'a> {
-    Any,
-    Int,
-    String,
-    Float,
-    Boolean,
-    Character,
-    Symbol,
-    Void,
-    Other(&'a str),
-}
-
-impl<'a> BaseTypeKind<'a> {
-    // TODO -> don't have this just refer directly to unknown
-    fn to_type_info(&self) -> TypeInfo {
-        match self {
-            BaseTypeKind::Any => TypeInfo::Any,
-            BaseTypeKind::Int => TypeInfo::Int,
-            BaseTypeKind::String => TypeInfo::String,
-            BaseTypeKind::Float => TypeInfo::Float,
-            BaseTypeKind::Boolean => TypeInfo::Boolean,
-            BaseTypeKind::Character => TypeInfo::Char,
-            BaseTypeKind::Void => TypeInfo::Void,
-            BaseTypeKind::Symbol => TypeInfo::Symbol,
-            BaseTypeKind::Other(_) => TypeInfo::Unknown,
-        }
-    }
-
-    fn from_str(input: &'a str) -> BaseTypeKind<'a> {
-        match input {
-            "int?" | "integer?" => BaseTypeKind::Int,
-            "string?" => BaseTypeKind::String,
-            _ => BaseTypeKind::Other(input),
-        }
-    }
-}
-
-// Concrete, inferred type
-#[derive(Debug)]
-enum Type {
-    Int,
-    Bool,
-    List(Box<Type>),
-    Func(Vec<Type>, Box<Type>),
-}
-
-pub enum BuiltInFunctionContract {
-    // Things that have a fixed arity
-    FixedArity(Vec<BaseTypeKind<'static>>, BaseTypeKind<'static>),
-    // Things that match any number of arity in the precondition but all match
-    // For instance, addition accepts all numbers in the precondition
-    AnyArity(BaseTypeKind<'static>, BaseTypeKind<'static>),
-}
-
-// Generate the bindings for the built in functions
-pub fn built_in_contract_map() -> HashMap<&'static str, TypeInfo> {
-    use TypeInfo::*;
-    let mut map = HashMap::new();
-
-    map.insert(
-        "+",
-        AnyArityFunction(
-            Box::new(UnionOf(
-                vec![TypeInfo::Int, TypeInfo::Float].into_iter().collect(),
-            )),
-            Box::new(UnionOf(
-                vec![TypeInfo::Int, TypeInfo::Float].into_iter().collect(),
-            )),
-        ),
-    );
-    map.insert(
-        "-",
-        AnyArityFunction(Box::new(TypeInfo::Int), Box::new(TypeInfo::Int)),
-    );
-    map.insert(
-        "int->string",
-        FixedArityFunction(vec![TypeInfo::Int], Box::new(TypeInfo::String)),
-    );
-
-    map.insert(
-        "list",
-        DependentFunction(|args: Vec<TypeInfo>| {
-            TypeInfo::UnionOf(
-                args.into_iter()
-                    .chain(std::iter::once(TypeInfo::Any))
-                    .collect(),
-            )
-        }),
-    );
-
-    map
-}
-
-#[derive(Debug, PartialEq, PartialOrd)]
-pub enum StaticContract<'a> {
-    Atom(BaseTypeKind<'a>),
-    ListOf(Box<StaticContract<'a>>),
-    UnionOf(Vec<StaticContract<'a>>),
-    IntersectionOf(Vec<StaticContract<'a>>),
-    Function(Vec<StaticContract<'a>>, Box<StaticContract<'a>>),
-    // For now just unify the internal representation of built ins vs not
-    AnyArityFunction(Box<StaticContract<'static>>, Box<StaticContract<'static>>),
-}
-
-impl<'a> StaticContract<'a> {
-    fn to_type_info(&self) -> TypeInfo {
-        match self {
-            StaticContract::Atom(a) => a.to_type_info(),
-            StaticContract::ListOf(l) => TypeInfo::ListOf(Box::new(l.to_type_info())),
-            StaticContract::Function(pre, post) => TypeInfo::FixedArityFunction(
-                pre.iter().map(|x| x.to_type_info()).collect(),
-                Box::new(post.to_type_info()),
-            ),
-            StaticContract::AnyArityFunction(pre, post) => TypeInfo::AnyArityFunction(
-                Box::new(pre.to_type_info()),
-                Box::new(post.to_type_info()),
-            ),
-            StaticContract::UnionOf(u) => {
-                TypeInfo::UnionOf(u.iter().map(|x| x.to_type_info()).collect())
-            }
-            StaticContract::IntersectionOf(u) => {
-                TypeInfo::IntersectionOf(u.iter().map(|x| x.to_type_info()).collect())
-            }
-        }
-    }
-
-    fn from_exprkind(expr: &'a ExprKind) -> Result<StaticContract<'a>> {
-        match expr {
-            ExprKind::Atom(a) => {
-                let name = BaseTypeKind::from_str(a.ident().unwrap()); // TODO -> clean up this error handling
-
-                Ok(StaticContract::Atom(name))
-            }
-            ExprKind::List(l) => match l.first_ident() {
-                Some("listof") => {
-                    let body = l.get(1).unwrap();
-
-                    Ok(StaticContract::ListOf(Box::new(Self::from_exprkind(body)?)))
-                }
-                Some("make/c") => {
-                    // Just recur on the actual contract here
-                    Self::from_exprkind(l.get(1).unwrap())
-                }
-                Some("make-function/c") => {
-                    // Pre conditions of the function contract
-                    let pre_conditions = &l.args[1..l.args.len() - 1];
-                    // Post condition of the function contract
-                    let post_condition = &l.args[l.args.len() - 1];
-
-                    let pre_condition_contracts = pre_conditions
-                        .iter()
-                        .map(Self::from_exprkind)
-                        .collect::<Result<Vec<_>>>()?;
-
-                    let post_condition_contract = Self::from_exprkind(post_condition)?;
-
-                    Ok(StaticContract::Function(
-                        pre_condition_contracts,
-                        Box::new(post_condition_contract),
-                    ))
-                }
-                _ => {
-                    println!("{expr}");
-                    stop!(Generic => "Unexpected contract combinator")
-                }
-            },
-            _ => {
-                stop!(BadSyntax => "contracts can either be atoms or lists")
-            }
-        }
-    }
-}
-
-pub type TypeId = usize;
-
-// This is a contract bound to the body expression
-#[derive(Debug)]
-pub struct BoundContract<'a> {
-    body: &'a ExprKind,
-    contract: StaticContract<'a>,
-}
-
-impl<'a> BoundContract<'a> {
-    // TODO make this resiliant to syntax errors
-    pub fn new(contract: StaticContract<'a>, body: &'a ExprKind) -> Self {
-        // if body.lambda_function().unwrap().args
-        if let StaticContract::Function(pre_conditions, _) = &contract {
-            assert_eq!(
-                body.lambda_function().unwrap().args.len(),
-                pre_conditions.len(),
-                "The arguments and contracts must be of matching lengths"
-            );
-        }
-
-        BoundContract { body, contract }
-    }
-}
-
-// Is this expression referring to a contract (is this a bind/c instance)
-fn is_contract(expr: &ExprKind) -> bool {
-    fn is_contract_option(expr: &ExprKind) -> Option<bool> {
-        expr.list()?.first_ident().map(|x| x == "bind/c")
-    }
-
-    if let Some(inner) = is_contract_option(expr) {
-        inner
-    } else {
-        false
-    }
-}
-
-// Is this bind/c instance referring to a make-function/c instance
-fn function_contract(expr: &ExprKind) -> Option<Result<StaticContract>> {
-    let body = expr.list()?;
-
-    if body.first_ident()? == "bind/c" {
-        let make_function = body.get(1)?;
-
-        if make_function.list()?.first_ident()? == "make-function/c" {
-            // This just deconstructs the (bind/c into a individual struct for access)
-            // return Some(BindContract::new(make_function, body.get(2)?));
-
-            return Some(StaticContract::from_exprkind(make_function));
-        }
-    }
-
-    None
-}
-
-#[derive(Default, Debug)]
-pub struct GlobalContractCollector<'a> {
-    contracts: HashMap<String, StaticContract<'a>>,
-    built_ins: HashMap<&'static str, TypeInfo>,
-}
-
-impl<'a> GlobalContractCollector<'a> {
-    pub fn collect_contracts(exprs: impl IntoIterator<Item = &'a ExprKind>) -> Self {
-        let mut collector = GlobalContractCollector {
-            // TODO: Attach the built-ins here
-            built_ins: built_in_contract_map(),
-            ..Default::default()
-        };
-
-        exprs.into_iter().for_each(|x| collector.visit(x));
-        collector
-    }
-
-    pub fn get(&self, ident: &str) -> Option<TypeInfo> {
-        self.contracts
-            .get(ident)
-            .map(|x| x.to_type_info())
-            .or_else(|| self.built_ins.get(ident).cloned())
-    }
-}
-
-impl<'a> VisitorMutUnitRef<'a> for GlobalContractCollector<'a> {
-    fn visit_define(&mut self, define: &'a crate::parser::ast::Define) {
-        if let Some(contract) = function_contract(&define.body) {
-            // If we try to collect contracts on something thats not expanded, we'll have problems anyway
-            self.contracts.insert(
-                define.name.atom_identifier().unwrap().to_string(),
-                contract.unwrap(),
-            );
-        }
-    }
-}
-
-pub struct ContractChecker<'a> {
-    global_contract_info: GlobalContractCollector<'a>,
-    scope_map: ScopeMap<String, TypeInfo>,
-    inferred_globals: HashMap<String, TypeInfo>,
-}
-
-impl<'a> std::fmt::Debug for ContractChecker<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ContractChecker")
-            .field("global_contract_info", &self.global_contract_info)
-            .field(
-                "scope_map",
-                &self.scope_map.iter_top().collect::<HashMap<_, _>>(),
-            )
-            .finish()
-    }
-}
-
-impl<'a> ContractChecker<'a> {
-    pub fn new(global_contract_info: GlobalContractCollector<'a>) -> Self {
-        ContractChecker {
-            global_contract_info,
-            scope_map: ScopeMap::default(),
-            inferred_globals: HashMap::default(),
-        }
-    }
-
-    pub fn check(&mut self, exprs: impl IntoIterator<Item = &'a ExprKind>) -> Result<()> {
-        for expr in exprs {
-            let type_checked = self.visit(expr)?;
-            println!("{type_checked:#?}");
-        }
-        Ok(())
-    }
-
-    // TODO -> have a way to make sure that inferred globals can be refined in some capacity if
-    // more information can be applied to them
-    pub fn get_ident(&self, ident: &str) -> Option<TypeInfo> {
-        self.scope_map
-            .get(ident)
-            .cloned()
-            .or_else(|| self.global_contract_info.get(ident))
-            .or_else(|| self.inferred_globals.get(ident).cloned())
-    }
-
-    pub fn local_ident_exists(&self, ident: &str) -> bool {
-        self.scope_map.get(ident).is_some()
-    }
-}
-
-#[derive(Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
-pub enum TypeInfo {
-    // We don't have enough information to say what this type is
-    // Either, the function has come externally or it was unable to be inferred for some reason
-    Unknown,
-    Any,
-    Void,
-    Int,
-    Float,
-    Boolean,
-    Char,
-    String,
-    Symbol,
-    ListOf(Box<TypeInfo>),
-    // Basic function usage, this has some fixed number of arguments with contracts attached
-    FixedArityFunction(Vec<TypeInfo>, Box<TypeInfo>),
-    // This is something like addition, which has a contract with any arity in the preconditions
-    AnyArityFunction(Box<TypeInfo>, Box<TypeInfo>),
-
-    // Function where the input type directly creates the output type in some fashion
-    DependentFunction(fn(Vec<TypeInfo>) -> TypeInfo),
-
-    // If a function can return multiple things, or the return value can satisfy multiple contracts (or/c)
-    UnionOf(BTreeSet<TypeInfo>),
-    // If the return value of a function must satisfy multiple contracts (and/c)
-    IntersectionOf(BTreeSet<TypeInfo>),
-}
-
-impl std::fmt::Debug for TypeInfo {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Self::Unknown => write!(f, "Unknown"),
-            Self::Any => write!(f, "Any"),
-            Self::Void => write!(f, "Void"),
-            Self::Int => write!(f, "Int"),
-            Self::Float => write!(f, "Float"),
-            Self::Boolean => write!(f, "Boolean"),
-            Self::Char => write!(f, "Char"),
-            Self::String => write!(f, "String"),
-            Self::Symbol => write!(f, "Symbol"),
-            Self::ListOf(arg0) => f.debug_tuple("ListOf").field(arg0).finish(),
-            Self::FixedArityFunction(arg0, arg1) => f
-                .debug_tuple("FixedArityFunction")
-                .field(arg0)
-                .field(arg1)
-                .finish(),
-            Self::AnyArityFunction(arg0, arg1) => f
-                .debug_tuple("AnyArityFunction")
-                .field(arg0)
-                .field(arg1)
-                .finish(),
-            Self::DependentFunction(_) => f
-                .debug_tuple("DependentFunction")
-                .field(&"<#function>".to_string())
-                .finish(),
-            Self::UnionOf(arg0) => f.debug_tuple("UnionOf").field(arg0).finish(),
-            Self::IntersectionOf(arg0) => f.debug_tuple("IntersectionOf").field(arg0).finish(),
-        }
-    }
-}
-
-impl TypeInfo {
-    // TODO -> this is almost assuredly wrong
-    pub fn is_compatible_with(&self, other: &TypeInfo) -> bool {
-        match (self, other) {
-            (TypeInfo::Any, _) | (_, TypeInfo::Any) => true,
-            // TODO -> there might be a better way of doing this
-            (TypeInfo::UnionOf(l), TypeInfo::UnionOf(r)) => {
-                l.is_subset(r) || l.contains(&TypeInfo::Any) || r.contains(&TypeInfo::Any)
-
-                // l == r
-            }
-            (value, TypeInfo::UnionOf(set)) => set.contains(value) || set.contains(&TypeInfo::Any),
-            (TypeInfo::UnionOf(set), value) => set.contains(value) || set.contains(&TypeInfo::Any),
-            (TypeInfo::Unknown, _) | (_, TypeInfo::Unknown) => true,
-            (TypeInfo::ListOf(l), TypeInfo::ListOf(r)) => l.is_compatible_with(r),
-            (left, right) => left == right,
-        }
-    }
-}
-
-#[test]
-fn test_list_composition() {
-    let left = TypeInfo::ListOf(Box::new(TypeInfo::UnionOf(
-        vec![TypeInfo::Any].into_iter().collect(),
-    )));
-
-    let right = TypeInfo::ListOf(Box::new(TypeInfo::UnionOf(
-        vec![TypeInfo::Any, TypeInfo::String].into_iter().collect(),
-    )));
-
-    println!("{}", left.is_compatible_with(&right));
-
-    let left = TypeInfo::ListOf(Box::new(TypeInfo::String));
-
-    let right = TypeInfo::ListOf(Box::new(TypeInfo::UnionOf(
-        vec![TypeInfo::Any, TypeInfo::String].into_iter().collect(),
-    )));
-
-    println!("{}", left.is_compatible_with(&right));
-}
-
-impl<'a> VisitorMut for ContractChecker<'a> {
-    type Output = Result<TypeInfo>;
-
-    fn visit_if(&mut self, f: &crate::parser::ast::If) -> Self::Output {
-        self.visit(&f.test_expr)?;
-
-        let then_expr = self.visit(&f.then_expr)?;
-        let else_expr = self.visit(&f.else_expr)?;
-
-        if then_expr == else_expr {
-            Ok(else_expr)
-        } else {
-            Ok(TypeInfo::UnionOf([then_expr, else_expr].into()))
-        }
-    }
-
-    fn visit_define(&mut self, define: &crate::parser::ast::Define) -> Self::Output {
-        // self.visit(&define.name)?;
-
-        self.visit(&define.body)
-    }
-
-    fn visit_lambda_function(
-        &mut self,
-        lambda_function: &crate::parser::ast::LambdaFunction,
-    ) -> Self::Output {
-        self.scope_map.push_layer();
-
-        for arg in lambda_function
-            .args
-            .iter()
-            .map(|x| x.atom_identifier().unwrap())
-        {
-            self.scope_map.define(arg.to_string(), TypeInfo::Unknown);
-        }
-
-        let return_value = self.visit(&lambda_function.body)?;
-
-        // Ideally, by the time we get back to this position in the type checking, we've propagated information upwards given what we know about
-        // the usage of the arguments. If these conflict with the type given to the function, this can be
-        let args = lambda_function
-            .args
-            .iter()
-            .map(|x| self.get_ident(x.atom_identifier().unwrap()).unwrap())
-            .collect::<Vec<_>>();
-
-        // We've exited the scope, we're done
-        self.scope_map.pop_layer();
-
-        Ok(TypeInfo::FixedArityFunction(args, Box::new(return_value)))
-    }
-
-    fn visit_begin(&mut self, begin: &crate::parser::ast::Begin) -> Self::Output {
-        let mut last = TypeInfo::Void;
-        for expr in &begin.exprs {
-            last = self.visit(expr)?;
-        }
-        Ok(last)
-    }
-
-    // TODO -> return should mark the return value
-    fn visit_return(&mut self, r: &crate::parser::ast::Return) -> Self::Output {
-        self.visit(&r.expr)
-    }
-
-    // TODO -> eval quote to get value
-    fn visit_quote(&mut self, quote: &crate::parser::ast::Quote) -> Self::Output {
-        match &quote.expr {
-            ExprKind::Atom(a) => match a.syn.ty {
-                TokenType::StringLiteral(_) => Ok(TypeInfo::String),
-                TokenType::IntegerLiteral(_) => Ok(TypeInfo::Int),
-                TokenType::NumberLiteral(_) => Ok(TypeInfo::Float),
-                TokenType::CharacterLiteral(_) => Ok(TypeInfo::Char),
-                TokenType::BooleanLiteral(_) => Ok(TypeInfo::Boolean),
-                TokenType::Identifier(_) => Ok(TypeInfo::Symbol),
-                _ => stop!(Generic => format!("ICE: Not sure what to do here: {}", a.syn.ty)),
-            },
-            // If we get back a generic quoted list, it can be any valid program
-            // which is effectively the union of all constants
-            // TODO -> this can also accept the list of any constants, which then
-            // makes the type definition recursive...
-            ExprKind::List(_) => Ok(TypeInfo::ListOf(Box::new(TypeInfo::UnionOf({
-                let mut hs = BTreeSet::new();
-                hs.insert(TypeInfo::String);
-                hs.insert(TypeInfo::Int);
-                hs.insert(TypeInfo::Float);
-                hs.insert(TypeInfo::Char);
-                hs.insert(TypeInfo::Boolean);
-                hs.insert(TypeInfo::Symbol);
-                // This _should_ be a recursive case on the list of self
-                // but I don't currently have a way to resolve recursive type references
-                hs.insert(TypeInfo::ListOf(Box::new(TypeInfo::Any)));
-                hs
-            })))),
-            _ => stop!(TypeMismatch => "this shouldn't work"),
-        }
-    }
-
-    fn visit_macro(&mut self, _m: &crate::parser::ast::Macro) -> Self::Output {
-        panic!("Unexpected macro")
-    }
-
-    // TODO - resolve identifiers with a scope map
-    fn visit_atom(&mut self, a: &crate::parser::ast::Atom) -> Self::Output {
-        match &a.syn.ty {
-            TokenType::Identifier(a) => Ok(self.get_ident(a.as_str()).unwrap_or(TypeInfo::Unknown)),
-            TokenType::StringLiteral(_) => Ok(TypeInfo::String),
-            TokenType::IntegerLiteral(_) => Ok(TypeInfo::Int),
-            TokenType::NumberLiteral(_) => Ok(TypeInfo::Float),
-            TokenType::CharacterLiteral(_) => Ok(TypeInfo::Char),
-            TokenType::BooleanLiteral(_) => Ok(TypeInfo::Boolean),
-            _ => stop!(TypeMismatch => "Unexpected token type"),
-        }
-    }
-
-    fn visit_list(&mut self, l: &crate::parser::ast::List) -> Self::Output {
-        let function_type = self.visit(&l.args[0])?;
-        let expected_arity = l.args.len() - 1;
-
-        println!("Type checking this expression: {l}");
-        println!("Function type: {function_type:?}");
-
-        match &function_type {
-            TypeInfo::Unknown => {
-                // If we're in this situation we don't know what this function is
-                // we can attempt to infer what the corresponding type is based on the types of the argument
-                let argument_types = l.args[1..]
-                    .iter()
-                    .map(|x| self.visit(x))
-                    .collect::<Result<Vec<_>>>()?;
-
-                // In the case where we are calling a function with an unknown return type, propagate an unknown
-                // to try to continue inference
-                let return_type = TypeInfo::Unknown;
-
-                // Inferred function type at this node
-                // TODO -> this should be registered into the inferred globals if necessary
-                let inferred_type =
-                    TypeInfo::FixedArityFunction(argument_types, Box::new(return_type.clone()));
-
-                // TODO: this won't work given out set! works...
-                // might have to come up with some sort of scheme to allow set! type checking if theres a way to
-                // unify the usage with a dummy type var
-                if let Some(ident) = &l.args[0].atom_identifier() {
-                    if let Some(local) = self.scope_map.get_mut(*ident) {
-                        log::debug!(
-                            "Inferring local var: {} with type {:?} - old type: {:?}",
-                            ident,
-                            inferred_type,
-                            local
-                        );
-
-                        *local = inferred_type;
-                    } else {
-                        log::debug!(
-                            "Inferring global var: {} with type {:?}",
-                            ident,
-                            inferred_type
-                        );
-
-                        // TODO ->
-
-                        // self.inferred_globals
-                        //     .insert(ident.to_string(), inferred_type);
-                    }
-                }
-
-                Ok(return_type)
-            }
-
-            TypeInfo::DependentFunction(func) => {
-                let argument_types = l.args[1..]
-                    .iter()
-                    .map(|x| self.visit(x))
-                    .collect::<Result<Vec<_>>>()?;
-
-                let return_type = func(argument_types);
-
-                Ok(return_type)
-            }
-
-            TypeInfo::AnyArityFunction(pre, post) => {
-                if l.args.len() == 1 {
-                    return Ok(*(post.clone()));
-                }
-
-                // Visit the children in order
-                for expr in &l.args[1..] {
-                    let mut found = self.visit(expr)?;
-
-                    // If we've found an unknown, we don't necessarily have enough information
-                    // to say what this type is. We attempt to resolve it by the inferring that the type
-                    // is the type expected by the function call. Later, this will be rejected if there is a
-                    // a mismatch.
-                    if matches!(found, TypeInfo::Unknown) {
-                        if let Some(ident) = expr.atom_identifier() {
-                            if let Some(local) = self.scope_map.get_mut(ident) {
-                                *local = *(pre.clone());
-                            } else {
-                                log::warn!("Unable to resolve reference to variable: {}", ident);
-                            }
-                            found = *(pre.clone());
-                        }
-                    }
-
-                    if !pre.is_compatible_with(&found) {
-                        stop!(ContractViolation => format!("type mismatch: expected {pre:?}, found {found:?}"))
-                    }
-                }
-
-                Ok(*(post.clone()))
-            }
-            TypeInfo::FixedArityFunction(pre, post) => {
-                let found_arity = pre.len();
-                if expected_arity != found_arity {
-                    stop!(ArityMismatch => format!("Function application mismatched with expected - function expected {found_arity} arguments but found {expected_arity}"))
-                }
-
-                if l.args.len() == 1 {
-                    return Ok(*(post.clone()));
-                }
-
-                let visited = l.args[1..]
-                    .iter()
-                    .map(|x| self.visit(x))
-                    .collect::<Result<Vec<_>>>()?;
-
-                for ((expected, mut found), unvisited) in
-                    pre.iter().zip(visited).zip(l.args[1..].iter())
-                {
-                    println!("Found argument type: {found:?}");
-
-                    // If we've found an unknown, we don't necessarily have enough information
-                    // to say what this type is. We attempt to resolve it by the inferring that the type
-                    // is the type expected by the function call. Later, this will be rejected if there is a
-                    // a mismatch.
-                    if matches!(found, TypeInfo::Unknown) {
-                        if let Some(ident) = unvisited.atom_identifier() {
-                            if let Some(local) = self.scope_map.get_mut(ident) {
-                                *local = expected.clone();
-                            } else {
-                                log::warn!("Unable to resolve reference to variable: {}", ident);
-                            }
-                            found = expected.clone();
-                        }
-                    }
-
-                    if !expected.is_compatible_with(&found) {
-                        stop!(ContractViolation => format!("type mismatch: expected {expected:?}, found {found:?}"))
-                    }
-                }
-
-                Ok(*(post.clone()))
-            }
-            _ => {
-                stop!(TypeMismatch => format!("Function application not a procedure, expected a function, found: {function_type:?}"))
-            }
-        }
-    }
-
-    fn visit_syntax_rules(&mut self, _l: &crate::parser::ast::SyntaxRules) -> Self::Output {
-        panic!("Unexpected syntax rules")
-    }
-
-    fn visit_set(&mut self, s: &crate::parser::ast::Set) -> Self::Output {
-        let var_type = self.visit(&s.variable)?;
-        let assignment_type = self.visit(&s.expr)?;
-
-        // In the case of (set! x 10)
-        // x might have been defined to be any other type
-        //
-        if !assignment_type.is_compatible_with(&var_type) {
-            stop!(TypeMismatch => "set! expression is incompatible with type");
-        }
-
-        Ok(assignment_type)
-    }
-
-    fn visit_require(&mut self, _s: &crate::parser::ast::Require) -> Self::Output {
-        panic!("Unexpected require")
-    }
-
-    fn visit_let(&mut self, l: &crate::parser::ast::Let) -> Self::Output {
-        for binding in &l.bindings {
-            self.visit(&binding.1)?;
-        }
-
-        self.visit(&l.body_expr)
-    }
-}
-
-*/
diff --git a/crates/steel-core/src/steel_vm/dylib.rs b/crates/steel-core/src/steel_vm/dylib.rs
deleted file mode 100644
index 80e5d6c09..000000000
--- a/crates/steel-core/src/steel_vm/dylib.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-#![allow(non_camel_case_types)]
-use std::{
-    cell::RefCell,
-    collections::HashMap,
-    path::{Path, PathBuf},
-    rc::Rc,
-    sync::{Arc, Mutex},
-};
-
-use abi_stable::{
-    library::{LibraryError, RootModule},
-    package_version_strings,
-    sabi_types::VersionStrings,
-    std_types::RBox,
-    StableAbi,
-};
-use once_cell::sync::Lazy;
-
-use crate::rvals::{IntoSteelVal, SteelString, SteelVal};
-
-use super::{builtin::BuiltInModule, ffi::FFIModule};
-
-// The new and improved loading of modules
-static LOADED_MODULES: Lazy<Arc<Mutex<Vec<(String, GenerateModule_Ref)>>>> =
-    Lazy::new(|| Arc::new(Mutex::new(Vec::new())));
-
-thread_local! {
-    static BUILT_DYLIBS: Rc<RefCell<HashMap<String, BuiltInModule>>> = Rc::new(RefCell::new(HashMap::new()));
-}
-
-#[repr(C)]
-#[derive(StableAbi)]
-#[sabi(kind(Prefix(prefix_ref = GenerateModule_Ref)))]
-#[sabi(missing_field(panic))]
-pub struct GenerateModule {
-    pub generate_module: extern "C" fn() -> RBox<FFIModule>,
-}
-
-/// The RootModule trait defines how to load the root module of a library.
-impl RootModule for GenerateModule_Ref {
-    abi_stable::declare_root_module_statics! {GenerateModule_Ref}
-
-    const BASE_NAME: &'static str = "generate_module";
-    const NAME: &'static str = "generate_module";
-    const VERSION_STRINGS: VersionStrings = package_version_strings!();
-}
-
-// Load from the directory
-pub fn load_root_module_in_directory(file: &Path) -> Result<GenerateModule_Ref, LibraryError> {
-    GenerateModule_Ref::load_from_file(file)
-}
-
-#[derive(Clone)]
-pub(crate) struct DylibContainers {}
-
-#[steel_derive::function(name = "#%get-dylib")]
-pub fn load_module(target: &SteelString) -> crate::rvals::Result<SteelVal> {
-    match DylibContainers::load_module(target.clone()) {
-        Some(container) => container.into_steelval(),
-        None => {
-            stop!(Generic => format!("dylib not found: {} or dylibs are not enabled for this instance of the steel runtime", target))
-        }
-    }
-}
-
-impl DylibContainers {
-    pub fn new() -> Self {
-        Self {
-            // containers: Arc::new(Mutex::new(Vec::new())),
-        }
-    }
-
-    // home should... probably just be $STEEL_HOME?
-    pub fn load_module(target: SteelString) -> Option<BuiltInModule> {
-        #[cfg(not(feature = "dylibs"))]
-        {
-            None // TODO: This _should_ just error instead!
-        }
-
-        #[cfg(feature = "dylibs")]
-        {
-            if let Some(module) = BUILT_DYLIBS.with(|x| x.borrow().get(target.as_str()).cloned()) {
-                return Some(module);
-            }
-
-            let home = std::env::var("STEEL_HOME").ok();
-
-            if let Some(home) = home {
-                // let guard = LOADED_DYLIBS.lock().unwrap();
-                let mut module_guard = LOADED_MODULES.lock().unwrap();
-
-                let mut home = PathBuf::from(home);
-                home.push("native");
-
-                if home.exists() {
-                    let paths = std::fs::read_dir(home).unwrap();
-
-                    for path in paths {
-                        // println!("{:?}", path);
-
-                        let path = path.unwrap().path();
-
-                        if path.extension().unwrap() != "so" && path.extension().unwrap() != "dylib"
-                        {
-                            continue;
-                        }
-
-                        let path_name = path
-                            .file_stem()
-                            // .file_name()
-                            .and_then(|x| x.to_str())
-                            .unwrap();
-                        log::info!(target: "dylibs", "Loading dylib: {}", path_name);
-
-                        // Didn't match! skip it
-                        if path_name != target.as_str() {
-                            continue;
-                        }
-
-                        let module_name = path_name.to_string();
-
-                        if module_guard.iter().find(|x| x.0 == path_name).is_some() {
-                            continue;
-                        }
-
-                        // Load the module in
-                        let container = load_root_module_in_directory(&path).unwrap();
-
-                        let dylib_module = container.generate_module()();
-
-                        module_guard.push((module_name, container));
-
-                        let external_module =
-                            crate::steel_vm::ffi::FFIWrappedModule::new(dylib_module)
-                                .expect("dylib failed to load!")
-                                .build();
-
-                        BUILT_DYLIBS.with(|x| {
-                            x.borrow_mut()
-                                .insert(target.to_string(), external_module.clone())
-                        });
-
-                        log::info!(target: "dylibs", "Registering dylib: {} - {}", path_name, target);
-
-                        return Some(external_module);
-                    }
-                } else {
-                    log::warn!(target: "dylibs", "$STEEL_HOME/native directory does not exist")
-                }
-            } else {
-                log::warn!(target: "dylibs", "STEEL_HOME variable missing - unable to read shared dylibs")
-            }
-
-            None
-        }
-    }
-}
diff --git a/crates/steel-core/src/steel_vm/engine.rs b/crates/steel-core/src/steel_vm/engine.rs
deleted file mode 100644
index 5bcd75001..000000000
--- a/crates/steel-core/src/steel_vm/engine.rs
+++ /dev/null
@@ -1,2161 +0,0 @@
-#![allow(unused)]
-
-use super::{
-    builtin::{BuiltInModule, FunctionSignatureMetadata},
-    primitives::{register_builtin_modules, register_builtin_modules_without_io, CONSTANTS},
-    vm::SteelThread,
-};
-
-#[cfg(feature = "dylibs")]
-use super::{ffi::FFIModule, ffi::FFIWrappedModule};
-
-#[cfg(feature = "dylibs")]
-use super::dylib::DylibContainers;
-
-use crate::{
-    compiler::{
-        compiler::{Compiler, SerializableCompiler},
-        map::SymbolMap,
-        modules::{CompiledModule, PRELUDE_WITHOUT_BASE},
-        program::{Executable, RawProgramWithSymbols, SerializableRawProgramWithSymbols},
-    },
-    containers::RegisterValue,
-    core::{instructions::Instruction, labels::Expr},
-    gc::unsafe_erased_pointers::{
-        BorrowedObject, CustomReference, OpaqueReferenceNursery, ReadOnlyBorrowedObject,
-        ReferenceMarker,
-    },
-    parser::{
-        ast::ExprKind,
-        expander::SteelMacro,
-        interner::{get_interner, take_interner, InternedString},
-        parser::SYNTAX_OBJECT_ID,
-    },
-    parser::{
-        kernel::{fresh_kernel_image, Kernel},
-        parser::{ParseError, Parser, Sources},
-    },
-    rerrs::{back_trace, back_trace_to_string},
-    rvals::{
-        cycles::{install_printer, print_in_engine, PRINT_IN_ENGINE_DEFINITION},
-        FromSteelVal, IntoSteelVal, Result, SteelVal,
-    },
-    steel_vm::register_fn::RegisterFn,
-    stop, throw,
-    values::functions::BoxedDynFunction,
-    SteelErr,
-};
-use std::{
-    cell::{Cell, RefCell},
-    collections::{HashMap, HashSet},
-    path::PathBuf,
-    rc::Rc,
-    sync::Arc,
-};
-
-use im_rc::HashMap as ImmutableHashMap;
-use lasso::ThreadedRodeo;
-use serde::{Deserialize, Serialize};
-use steel_gen::OpCode;
-use steel_parser::{
-    parser::{SourceId, SyntaxObject},
-    tokens::{MaybeBigInt, TokenType},
-};
-
-use crate::parser::ast::IteratorExtensions;
-
-thread_local! {
-    static KERNEL_BIN_FILE: Cell<Option<&'static [u8]>> = Cell::new(None);
-}
-
-// Install the binary file to be used during bootup
-// pub fn install_bin_file(bin: &'static [u8]) {
-//     KERNEL_BIN_FILE.with(|x| x.set(Some(bin)));
-// }
-
-pub trait ModuleResolver {
-    fn resolve(&self, name: &str) -> Option<BuiltInModule>;
-}
-
-#[derive(Clone, Default)]
-pub struct ModuleContainer {
-    modules: ImmutableHashMap<Rc<str>, BuiltInModule>,
-    // For modules that don't exist in memory. This could be useful for a world
-    // in which a builtin module exists BUT we'd like to resolve the module for
-    // inference purposes.
-    unresolved_modules: Option<Rc<dyn ModuleResolver>>,
-}
-
-impl ModuleContainer {
-    pub fn insert(&mut self, key: Rc<str>, value: BuiltInModule) {
-        self.modules.insert(key, value);
-    }
-
-    pub fn get_doc(&self, key: &str) -> Option<String> {
-        for module in self.modules.values() {
-            let maybe_doc = module.get_documentation(key);
-
-            if maybe_doc.is_some() {
-                return maybe_doc;
-            }
-        }
-
-        None
-    }
-
-    pub fn get_metadata_by_name(&self, key: &str) -> Option<FunctionSignatureMetadata> {
-        for module in self.modules.values() {
-            let maybe_meta = module.search_by_name(key);
-
-            if maybe_meta.is_some() {
-                return maybe_meta;
-            }
-        }
-
-        None
-    }
-
-    pub fn get(&mut self, key: &str) -> Option<BuiltInModule> {
-        self.modules.get(key).cloned().or_else(|| {
-            self.unresolved_modules
-                .as_ref()
-                .and_then(|x| x.resolve(key))
-        })
-    }
-
-    pub fn inner(&self) -> &ImmutableHashMap<Rc<str>, BuiltInModule> {
-        &self.modules
-    }
-
-    pub(crate) fn inner_mut(&mut self) -> &mut ImmutableHashMap<Rc<str>, BuiltInModule> {
-        &mut self.modules
-    }
-
-    pub fn with_resolver<T: ModuleResolver + 'static>(&mut self, resolver: T) {
-        self.unresolved_modules = Some(Rc::new(resolver));
-    }
-}
-
-#[derive(Debug)]
-pub struct EngineStatistics {
-    pub rooted_count: usize,
-    pub constants_count: usize,
-    pub sources_size: usize,
-}
-
-#[derive(Clone)]
-pub struct Engine {
-    virtual_machine: SteelThread,
-    compiler: Compiler,
-    constants: Option<ImmutableHashMap<InternedString, SteelVal>>,
-    modules: ModuleContainer,
-    sources: Sources,
-    #[cfg(feature = "dylibs")]
-    dylibs: DylibContainers,
-}
-
-impl Default for Engine {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-// Pre-parsed ASTs along with the global state to set before we start any further processing
-#[derive(Serialize, Deserialize)]
-struct BootstrapImage {
-    interner: Arc<ThreadedRodeo>,
-    syntax_object_id: usize,
-    sources: Sources,
-    programs: Vec<Vec<ExprKind>>,
-}
-
-// Pre compiled programs along with the global state to set before we start any further processing
-#[derive(Serialize, Deserialize)]
-struct StartupBootstrapImage {
-    syntax_object_id: usize,
-    function_id: usize,
-    sources: Sources,
-    pre_kernel_programs: Vec<SerializableRawProgramWithSymbols>,
-    post_kernel_programs: Vec<SerializableRawProgramWithSymbols>,
-    kernel: Option<KernelImage>,
-    compiler: Option<SerializableCompiler>,
-}
-
-#[derive(Serialize, Deserialize)]
-struct KernelImage {
-    // Kernel macros
-    compiler: SerializableCompiler,
-    sources: Sources,
-    kernel_source: SerializableRawProgramWithSymbols,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct NonInteractiveProgramImage {
-    sources: Sources,
-    program: SerializableRawProgramWithSymbols,
-}
-
-impl NonInteractiveProgramImage {
-    pub fn write_bytes_to_file(&self, out: &PathBuf) {
-        let mut f = std::fs::File::create(out).unwrap();
-        bincode::serialize_into(&mut f, self).unwrap();
-    }
-
-    pub fn from_bytes(bytes: &[u8]) -> Self {
-        bincode::deserialize(&bytes).unwrap()
-    }
-}
-
-// fn steel_create_bootstrap() {
-//     Engine::create_bootstrap_from_programs("src/boot/bootstrap.bin".into());
-// }
-
-pub struct LifetimeGuard<'a> {
-    engine: &'a mut Engine,
-}
-
-impl<'a> Drop for LifetimeGuard<'a> {
-    fn drop(&mut self) {
-        crate::gc::unsafe_erased_pointers::OpaqueReferenceNursery::free_all();
-    }
-}
-
-impl<'a> LifetimeGuard<'a> {
-    pub fn with_immutable_reference<
-        'b: 'a,
-        T: CustomReference + 'b,
-        EXT: CustomReference + 'static,
-    >(
-        self,
-        obj: &'a T,
-    ) -> Self
-    where
-        T: ReferenceMarker<'b, Static = EXT>,
-    {
-        assert_eq!(
-            crate::gc::unsafe_erased_pointers::type_id::<T>(),
-            std::any::TypeId::of::<EXT>()
-        );
-
-        crate::gc::unsafe_erased_pointers::OpaqueReferenceNursery::allocate_ro_object::<T, EXT>(
-            obj,
-        );
-
-        self
-    }
-
-    pub fn with_mut_reference<'b: 'a, T: CustomReference + 'b, EXT: CustomReference + 'static>(
-        self,
-        obj: &'a mut T,
-    ) -> Self
-    where
-        T: ReferenceMarker<'b, Static = EXT>,
-    {
-        assert_eq!(
-            crate::gc::unsafe_erased_pointers::type_id::<T>(),
-            std::any::TypeId::of::<EXT>()
-        );
-        crate::gc::unsafe_erased_pointers::OpaqueReferenceNursery::allocate_rw_object::<T, EXT>(
-            obj,
-        );
-
-        self
-    }
-
-    pub fn consume<T>(self, mut thunk: impl FnMut(&mut Engine, Vec<SteelVal>) -> T) -> T {
-        let values =
-            crate::gc::unsafe_erased_pointers::OpaqueReferenceNursery::drain_weak_references_to_steelvals();
-
-        thunk(self.engine, values)
-    }
-
-    pub fn consume_once<T>(self, mut thunk: impl FnOnce(&mut Engine, Vec<SteelVal>) -> T) -> T {
-        let values =
-            crate::gc::unsafe_erased_pointers::OpaqueReferenceNursery::drain_weak_references_to_steelvals();
-
-        thunk(self.engine, values)
-    }
-}
-
-impl RegisterValue for Engine {
-    fn register_value_inner(&mut self, name: &str, value: SteelVal) -> &mut Self {
-        let idx = self.compiler.register(name);
-        self.virtual_machine.insert_binding(idx, value);
-        self
-    }
-}
-
-#[steel_derive::function(name = "#%get-dylib")]
-fn load_module_noop(target: &crate::rvals::SteelString) -> crate::rvals::Result<SteelVal> {
-    stop!(Generic => "This engine has not been given the capability to load dylibs")
-}
-
-macro_rules! time {
-    ($target:expr, $label:expr, $e:expr) => {{
-        let now = std::time::Instant::now();
-
-        let e = $e;
-
-        log::debug!(target: $target, "{}: {:?}", $label, now.elapsed());
-
-        e
-    }};
-}
-
-thread_local! {
-    pub(crate) static DEFAULT_PRELUDE_MACROS: RefCell<HashMap<InternedString, SteelMacro>> = RefCell::new(HashMap::new());
-
-    pub(crate) static DEFAULT_DOC_MACROS: RefCell<HashMap<InternedString, SteelMacro>> = RefCell::new(
-        HashMap::new());
-}
-
-impl Engine {
-    /// Function to access a kernel level execution environment
-    /// Has access to primitives and syntax rules, but will not defer to a child
-    /// kernel in the compiler
-    pub(crate) fn new_kernel() -> Self {
-        log::debug!(target:"kernel", "Instantiating a new kernel");
-        let mut now = std::time::Instant::now();
-
-        let mut vm = Engine {
-            virtual_machine: SteelThread::new(),
-            compiler: Compiler::default(),
-            constants: None,
-            modules: ModuleContainer::default(),
-            sources: Sources::new(),
-            #[cfg(feature = "dylibs")]
-            dylibs: DylibContainers::new(),
-        };
-
-        time!(
-            "engine-creation",
-            "Registering builtin modules",
-            register_builtin_modules(&mut vm)
-        );
-
-        time!(
-            "engine-creation",
-            "Loading the all modules prelude code",
-            vm.compile_and_run_raw_program(crate::steel_vm::primitives::ALL_MODULES)
-                .unwrap()
-        );
-
-        log::debug!(target: "kernel", "Registered modules in the kernel!: {:?}", now.elapsed());
-
-        let mut now = std::time::Instant::now();
-
-        let core_libraries = [crate::stdlib::PRELUDE];
-
-        for core in core_libraries.into_iter() {
-            vm.compile_and_run_raw_program(core).unwrap();
-        }
-
-        // vm.compile_and_run_raw_program(
-        //     r#"
-
-        // (define-syntax @doc
-        //     (syntax-rules ()
-        //         [(@doc comment expression)
-        //         expression]))
-        //     "#,
-        // )
-        // .unwrap();
-
-        // let at_doc = "@doc".into();
-
-        // DEFAULT_DOC_MACROS.with(|x| {
-        //     x.borrow_mut()
-        //         .insert(at_doc, vm.in_scope_macros_mut().remove(&at_doc).unwrap())
-        // });
-
-        // Initialize the global macro environment with the default one. This way
-        // values won't leak when top level macros are defined - and modules can clone from
-        // this to begin seeding their environment.
-        DEFAULT_PRELUDE_MACROS.with(|x| {
-            let mut guard = x.borrow_mut();
-
-            *guard = vm.in_scope_macros().clone();
-        });
-
-        log::debug!(target: "kernel", "Loaded prelude in the kernel!: {:?}", now.elapsed());
-
-        vm
-    }
-
-    /// Register a module resolver. This is used for creating references to modules
-    /// that don't exist within the compiler. Without this, you wouldn't be able to
-    /// pre-compile or analyze code that is run within another host application, without
-    /// exposing some kind of compiler from that hosts runtime. The requirement then
-    /// is to expose some kind of module artifact that we can then consume.
-    pub fn register_module_resolver<T: ModuleResolver + 'static>(&mut self, resolver: T) {
-        self.modules.with_resolver(resolver);
-    }
-
-    pub fn builtin_modules(&self) -> &ModuleContainer {
-        &self.modules
-    }
-
-    #[doc(hidden)]
-    pub fn disallow_dylib_loading(&mut self) -> &mut Self {
-        let module = self.modules.inner_mut();
-
-        // TODO: This should actually just clone the whole module, and then add this definition
-        // in. That way it has its own unique module loader.
-        if let Some(builtin_module) = module.get_mut("steel/meta") {
-            builtin_module.register_native_fn_definition(LOAD_MODULE_NOOP_DEFINITION);
-        }
-
-        self
-    }
-
-    /// Function to access a kernel level execution environment
-    /// Has access to primitives and syntax rules, but will not defer to a child
-    /// kernel in the compiler
-    pub(crate) fn new_bootstrap_kernel() -> Self {
-        // if !install_drop_handler() {
-        //     panic!("Unable to install the drop handler!");
-        // }
-
-        // If the interner has already been initialized, it most likely means that either:
-        // 1) Tests are being run
-        // 2) The parser was used in a standalone fashion, somewhere, which invalidates the bootstrap
-        //    process
-        //
-        // There are a few solutions to this - one would probably be to not use a static interner,
-        // however given that its a huge chore to pass around the interner everywhere there are strings,
-        // its probably inevitable we have that.
-        if get_interner().is_some() {
-            return Engine::new_kernel();
-        }
-
-        if matches!(option_env!("STEEL_BOOTSTRAP"), Some("false") | None) {
-            let mut vm = Engine::new_kernel();
-
-            let sources = vm.sources.clone();
-
-            vm.register_fn("report-error!", move |error: SteelErr| {
-                raise_error(&sources, error);
-            });
-
-            return vm;
-        }
-
-        log::debug!(target:"kernel", "Instantiating a new kernel");
-
-        let mut vm = Engine {
-            virtual_machine: SteelThread::new(),
-            compiler: Compiler::default(),
-            constants: None,
-            modules: ModuleContainer::default(),
-            sources: Sources::new(),
-            #[cfg(feature = "dylibs")]
-            dylibs: DylibContainers::new(),
-        };
-
-        if let Some(programs) = Engine::load_from_bootstrap(&mut vm) {
-            register_builtin_modules(&mut vm);
-
-            for program in programs {
-                vm.compiler.constant_map = program.constant_map.clone();
-                vm.virtual_machine.constant_map = program.constant_map.clone();
-
-                vm.run_raw_program(program).unwrap();
-            }
-
-            log::debug!(target: "kernel", "Loaded prelude in the kernel!");
-
-            let sources = vm.sources.clone();
-
-            vm.register_fn("report-error!", move |error: SteelErr| {
-                raise_error(&sources, error);
-            });
-
-            vm
-        } else {
-            let mut vm = Engine::new_kernel();
-
-            let sources = vm.sources.clone();
-
-            vm.register_fn("report-error!", move |error: SteelErr| {
-                raise_error(&sources, error);
-            });
-
-            vm
-        }
-    }
-
-    // fn load_from_bootstrap(vm: &mut Engine) -> Option<Vec<Vec<ExprKind>>> {
-    //     let bootstrap: BootstrapImage =
-    //         bincode::deserialize(include_bytes!("../boot/bootstrap.bin")).unwrap();
-
-    //     // Set the syntax object id to be AFTER the previous items have been parsed
-    //     SYNTAX_OBJECT_ID.store(
-    //         bootstrap.syntax_object_id,
-    //         std::sync::atomic::Ordering::Relaxed,
-    //     );
-
-    //     // Set up the interner to have this latest state
-    //     if crate::parser::interner::initialize_with(bootstrap.interner).is_err() {
-    //         return None;
-    //     }
-
-    //     vm.sources = bootstrap.sources;
-
-    //     Some(bootstrap.programs)
-    // }
-
-    fn load_from_bootstrap(vm: &mut Engine) -> Option<Vec<RawProgramWithSymbols>> {
-        if matches!(option_env!("STEEL_BOOTSTRAP"), Some("false") | None) {
-            return None;
-        } else {
-            println!("LOADING A KERNEL FROM THE BIN FILE");
-        }
-
-        let bootstrap: StartupBootstrapImage =
-            bincode::deserialize(KERNEL_BIN_FILE.with(|x| x.get())?).unwrap();
-
-        // Set the syntax object id to be AFTER the previous items have been parsed
-        SYNTAX_OBJECT_ID.store(
-            bootstrap.syntax_object_id,
-            std::sync::atomic::Ordering::Relaxed,
-        );
-
-        crate::compiler::code_gen::FUNCTION_ID
-            .store(bootstrap.function_id, std::sync::atomic::Ordering::Relaxed);
-
-        vm.sources = bootstrap.sources;
-        // vm.compiler.macro_env = bootstrap.macros;
-
-        todo!();
-
-        Some(
-            bootstrap
-                .pre_kernel_programs
-                .into_iter()
-                .map(SerializableRawProgramWithSymbols::into_raw_program)
-                .collect(),
-        )
-    }
-
-    /// Creates a statically linked program ready to deserialize
-    pub fn create_non_interactive_program_image(
-        expr: &str,
-        path: PathBuf,
-    ) -> Result<NonInteractiveProgramImage> {
-        let mut engine = Engine::new();
-
-        engine
-            .emit_raw_program(expr, path)?
-            .into_serializable_program()
-            .map(|program| NonInteractiveProgramImage {
-                sources: engine.sources.clone(),
-                program,
-            })
-    }
-
-    // Execute from a statically linked non interactive program
-    pub fn execute_non_interactive_program_image(
-        program: NonInteractiveProgramImage,
-    ) -> Result<()> {
-        // This _has_ to match the as the creation of the program above
-        let mut engine = Engine::new();
-        engine.sources = program.sources;
-        let raw_program = SerializableRawProgramWithSymbols::into_raw_program(program.program);
-        let results = engine.run_raw_program(raw_program);
-
-        if let Err(e) = results {
-            raise_error(&engine.sources, e);
-        }
-
-        Ok(())
-    }
-
-    // Create kernel bootstrap
-    pub fn create_kernel_bootstrap_from_programs(output_path: PathBuf) {
-        let mut vm = Engine {
-            virtual_machine: SteelThread::new(),
-            compiler: Compiler::default(),
-            constants: None,
-            modules: ModuleContainer::default(),
-            sources: Sources::new(),
-            #[cfg(feature = "dylibs")]
-            dylibs: DylibContainers::new(),
-        };
-
-        register_builtin_modules(&mut vm);
-
-        let mut programs = Vec::new();
-
-        let bootstrap_sources = [
-            crate::steel_vm::primitives::ALL_MODULES,
-            crate::stdlib::PRELUDE,
-        ];
-
-        for source in bootstrap_sources {
-            let raw_program = vm.emit_raw_program_no_path(source).unwrap();
-            programs.push(raw_program.clone());
-            vm.run_raw_program(raw_program).unwrap();
-        }
-
-        // Grab the last value of the offset
-        let syntax_object_id = SYNTAX_OBJECT_ID.load(std::sync::atomic::Ordering::Relaxed);
-        let function_id =
-            crate::compiler::code_gen::FUNCTION_ID.load(std::sync::atomic::Ordering::Relaxed);
-
-        let bootstrap = StartupBootstrapImage {
-            syntax_object_id,
-            function_id,
-            sources: vm.sources,
-            pre_kernel_programs: programs
-                .into_iter()
-                .map(RawProgramWithSymbols::into_serializable_program)
-                .collect::<Result<_>>()
-                .unwrap(),
-            // macros: vm.compiler.macro_env,
-            post_kernel_programs: Vec::new(),
-            kernel: None,
-            compiler: None,
-        };
-
-        // Encode to something implementing `Write`
-        let mut f = std::fs::File::create(output_path).unwrap();
-        bincode::serialize_into(&mut f, &bootstrap).unwrap();
-    }
-
-    pub fn create_new_engine_from_bootstrap(output_path: PathBuf) {
-        let mut vm = Engine {
-            virtual_machine: SteelThread::new(),
-            compiler: Compiler::default(),
-            constants: None,
-            modules: ModuleContainer::default(),
-            sources: Sources::new(),
-            #[cfg(feature = "dylibs")]
-            dylibs: DylibContainers::new(),
-        };
-
-        register_builtin_modules(&mut vm);
-
-        let mut pre_kernel_programs = Vec::new();
-
-        let bootstrap_sources = [
-            crate::steel_vm::primitives::ALL_MODULES,
-            crate::stdlib::PRELUDE,
-        ];
-
-        for source in bootstrap_sources {
-            let raw_program = vm.emit_raw_program_no_path(source).unwrap();
-            pre_kernel_programs.push(raw_program.clone());
-            vm.run_raw_program(raw_program).unwrap();
-        }
-
-        // This will be our new top level engine
-        let mut top_level_engine = vm.clone();
-
-        let sources = vm.sources.clone();
-
-        vm.register_fn("report-error!", move |error: SteelErr| {
-            raise_error(&sources, error);
-        });
-
-        let (kernel, kernel_program) = Kernel::bootstrap(vm);
-
-        // Create kernel for the compiler for the top level vm
-        top_level_engine.compiler.kernel = Some(kernel);
-
-        let builtin_modules =
-            ["(require \"#%private/steel/contract\" (for-syntax \"#%private/steel/contract\"))"];
-
-        let mut post_kernel_programs = Vec::new();
-
-        for source in builtin_modules {
-            let raw_program = top_level_engine.emit_raw_program_no_path(source).unwrap();
-            post_kernel_programs.push(raw_program.clone());
-            top_level_engine.run_raw_program(raw_program).unwrap();
-        }
-
-        // Grab the last value of the offset
-        let syntax_object_id = SYNTAX_OBJECT_ID.load(std::sync::atomic::Ordering::Relaxed);
-        let function_id =
-            crate::compiler::code_gen::FUNCTION_ID.load(std::sync::atomic::Ordering::Relaxed);
-
-        let kernel_sources = top_level_engine
-            .compiler
-            .kernel
-            .as_ref()
-            .unwrap()
-            .engine
-            .sources
-            .clone();
-        let bootstrap = StartupBootstrapImage {
-            syntax_object_id,
-            function_id,
-            sources: top_level_engine.sources,
-            pre_kernel_programs: pre_kernel_programs
-                .into_iter()
-                .map(RawProgramWithSymbols::into_serializable_program)
-                .collect::<Result<_>>()
-                .unwrap(),
-            post_kernel_programs: post_kernel_programs
-                .into_iter()
-                .map(RawProgramWithSymbols::into_serializable_program)
-                .collect::<Result<_>>()
-                .unwrap(),
-            kernel: Some(KernelImage {
-                compiler: top_level_engine
-                    .compiler
-                    .kernel
-                    .take()
-                    .unwrap()
-                    .engine
-                    .compiler
-                    .into_serializable_compiler()
-                    .unwrap(),
-                sources: kernel_sources,
-                kernel_source: kernel_program.into_serializable_program().unwrap(),
-            }),
-            compiler: Some(
-                top_level_engine
-                    .compiler
-                    .into_serializable_compiler()
-                    .unwrap(),
-            ),
-        };
-
-        // Encode to something implementing `Write`
-        let mut f = std::fs::File::create(output_path).unwrap();
-        bincode::serialize_into(&mut f, &bootstrap).unwrap();
-    }
-
-    pub fn top_level_load_from_bootstrap(bin: &[u8]) -> Engine {
-        let bootstrap: StartupBootstrapImage = bincode::deserialize(bin).unwrap();
-
-        // This is going to be the kernel
-        let mut vm = Engine {
-            virtual_machine: SteelThread::new(),
-            compiler: Compiler::default(),
-            constants: None,
-            modules: ModuleContainer::default(),
-            sources: Sources::new(),
-            #[cfg(feature = "dylibs")]
-            dylibs: DylibContainers::new(),
-        };
-
-        // Register the modules
-        register_builtin_modules(&mut vm);
-
-        // Set the syntax object id to be AFTER the previous items have been parsed
-        SYNTAX_OBJECT_ID.store(
-            bootstrap.syntax_object_id,
-            std::sync::atomic::Ordering::Relaxed,
-        );
-
-        crate::compiler::code_gen::FUNCTION_ID
-            .store(bootstrap.function_id, std::sync::atomic::Ordering::Relaxed);
-
-        let bootstrap_kernel = bootstrap.kernel.unwrap();
-
-        vm.sources = bootstrap_kernel.sources;
-        vm.compiler = bootstrap_kernel.compiler.into_compiler();
-
-        // TODO: Only need to bring around the last constant map
-        for program in bootstrap
-            .pre_kernel_programs
-            .into_iter()
-            .map(SerializableRawProgramWithSymbols::into_raw_program)
-        {
-            vm.compiler.constant_map = program.constant_map.clone();
-            vm.virtual_machine.constant_map = program.constant_map.clone();
-
-            vm.run_raw_program(program).unwrap();
-        }
-
-        log::debug!(target: "kernel", "Loaded prelude in the kernel!");
-
-        let sources = vm.sources.clone();
-
-        vm.register_fn("report-error!", move |error: SteelErr| {
-            raise_error(&sources, error);
-        });
-
-        // Now we're going to set up the top level environment
-        let mut kernel = Kernel::initialize_post_bootstrap(vm.clone());
-
-        kernel
-            .engine
-            .run_raw_program(bootstrap_kernel.kernel_source.into_raw_program())
-            .unwrap();
-
-        vm.sources = bootstrap.sources;
-        vm.compiler = bootstrap.compiler.unwrap().into_compiler();
-        vm.compiler.kernel = Some(kernel);
-
-        for program in bootstrap
-            .post_kernel_programs
-            .into_iter()
-            .map(SerializableRawProgramWithSymbols::into_raw_program)
-        {
-            vm.compiler.constant_map = program.constant_map.clone();
-            vm.virtual_machine.constant_map = program.constant_map.clone();
-
-            vm.run_raw_program(program).unwrap();
-        }
-
-        vm
-    }
-
-    fn create_bootstrap() {
-        let mut vm = Engine {
-            virtual_machine: SteelThread::new(),
-            compiler: Compiler::default(),
-            constants: None,
-            modules: ModuleContainer::default(),
-            sources: Sources::new(),
-            #[cfg(feature = "dylibs")]
-            dylibs: DylibContainers::new(),
-        };
-
-        register_builtin_modules(&mut vm);
-
-        let mut asts = Vec::new();
-
-        let bootstrap_sources = [
-            crate::steel_vm::primitives::ALL_MODULES,
-            crate::stdlib::PRELUDE,
-        ];
-
-        for source in bootstrap_sources {
-            let id = vm.sources.add_source(source.to_string(), None);
-
-            // Could fail here
-            let parsed: Vec<ExprKind> = Parser::new(source, Some(id))
-                .collect::<std::result::Result<_, _>>()
-                .unwrap();
-
-            asts.push(parsed.clone());
-
-            vm.run_raw_program_from_exprs(parsed).unwrap();
-        }
-
-        // Grab the last value of the offset
-        let syntax_object_id = SYNTAX_OBJECT_ID.load(std::sync::atomic::Ordering::Relaxed);
-
-        let bootstrap = BootstrapImage {
-            interner: take_interner(),
-            syntax_object_id,
-            sources: vm.sources,
-            programs: asts,
-        };
-
-        // Encode to something implementing `Write`
-        let mut f = std::fs::File::create("src/boot/bootstrap.bin").unwrap();
-        bincode::serialize_into(&mut f, &bootstrap).unwrap();
-    }
-
-    /// Instantiates a raw engine instance. Includes no primitives or prelude.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// let mut vm = Engine::new_raw();
-    /// assert!(vm.run("(+ 1 2 3").is_err()); // + is a free identifier
-    /// ```
-    pub fn new_raw() -> Self {
-        Engine {
-            virtual_machine: SteelThread::new(),
-            compiler: Compiler::default_with_kernel(),
-            constants: None,
-            modules: ModuleContainer::default(),
-            sources: Sources::new(),
-            #[cfg(feature = "dylibs")]
-            dylibs: DylibContainers::new(),
-        }
-    }
-
-    pub fn report_engine_stats(&self) -> EngineStatistics {
-        EngineStatistics {
-            rooted_count: self.globals().len(),
-            constants_count: self.compiler.constant_map.len(),
-            sources_size: self.sources.size_in_bytes(),
-        }
-    }
-
-    /// Registers a steel module
-    pub fn register_steel_module(&mut self, module_name: String, text: String) {
-        self.compiler.register_builtin(module_name, text);
-    }
-
-    /// Instantiates a new engine instance with all primitive functions enabled.
-    /// This excludes the prelude and contract files.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// let mut vm = Engine::new_base();
-    /// // map is found in the prelude, so this will fail
-    /// assert!(vm.run(r#"(map (lambda (x) 10) (list 1 2 3 4 5))"#).is_err());
-    /// ```
-    #[inline]
-    pub fn new_base() -> Self {
-        let mut vm = Engine::new_raw();
-        // Embed any primitives that we want to use
-
-        register_builtin_modules(&mut vm);
-
-        vm.compile_and_run_raw_program(crate::steel_vm::primitives::ALL_MODULES)
-            .unwrap();
-
-        // vm.dylibs.load_modules(&mut vm);
-
-        vm
-    }
-
-    /// Turn contracts on in the VM
-    pub fn with_contracts(&mut self, contracts: bool) -> &mut Self {
-        self.virtual_machine.with_contracts(contracts);
-        self
-    }
-
-    #[inline]
-    pub fn new_sandboxed() -> Self {
-        let mut vm = Engine::new_raw();
-
-        register_builtin_modules_without_io(&mut vm);
-
-        vm.compile_and_run_raw_program(crate::steel_vm::primitives::SANDBOXED_MODULES)
-            .unwrap();
-
-        let core_libraries = [crate::stdlib::PRELUDE];
-
-        for core in core_libraries.into_iter() {
-            vm.compile_and_run_raw_program(core).unwrap();
-        }
-
-        vm
-    }
-
-    /// Call the print method within the VM
-    pub fn call_printing_method_in_context(&mut self, argument: SteelVal) -> Result<SteelVal> {
-        let function = self.extract_value("displayln")?;
-        self.call_function_with_args(function, vec![argument])
-    }
-
-    /// Internal API for calling a function directly
-    pub fn call_function_with_args(
-        &mut self,
-        function: SteelVal,
-        arguments: Vec<SteelVal>,
-    ) -> Result<SteelVal> {
-        self.virtual_machine
-            .call_function(self.compiler.constant_map.clone(), function, arguments)
-    }
-
-    /// Call a function by name directly within the target environment
-    pub fn call_function_by_name_with_args(
-        &mut self,
-        function: &str,
-        arguments: Vec<SteelVal>,
-    ) -> Result<SteelVal> {
-        self.extract_value(function).and_then(|function| {
-            self.virtual_machine.call_function(
-                self.compiler.constant_map.clone(),
-                function,
-                arguments,
-            )
-        })
-    }
-
-    /// Nothing fancy, just run it
-    pub fn run(&mut self, input: &str) -> Result<Vec<SteelVal>> {
-        self.compile_and_run_raw_program(input)
-    }
-
-    pub fn with_immutable_reference<
-        'a,
-        'b: 'a,
-        T: CustomReference + 'b,
-        EXT: CustomReference + 'static,
-    >(
-        &'a mut self,
-        obj: &'a T,
-    ) -> LifetimeGuard<'a>
-    where
-        T: ReferenceMarker<'b, Static = EXT>,
-    {
-        assert_eq!(
-            crate::gc::unsafe_erased_pointers::type_id::<T>(),
-            std::any::TypeId::of::<EXT>()
-        );
-
-        crate::gc::unsafe_erased_pointers::OpaqueReferenceNursery::allocate_ro_object::<T, EXT>(
-            obj,
-        );
-
-        LifetimeGuard { engine: self }
-    }
-
-    pub fn with_mut_reference<'a, 'b: 'a, T: CustomReference + 'b, EXT: CustomReference + 'static>(
-        &'a mut self,
-        obj: &'a mut T,
-    ) -> LifetimeGuard<'a>
-    where
-        T: ReferenceMarker<'b, Static = EXT>,
-    {
-        assert_eq!(
-            crate::gc::unsafe_erased_pointers::type_id::<T>(),
-            std::any::TypeId::of::<EXT>()
-        );
-
-        crate::gc::unsafe_erased_pointers::OpaqueReferenceNursery::allocate_rw_object::<T, EXT>(
-            obj,
-        );
-
-        LifetimeGuard { engine: self }
-    }
-
-    // Tie the lifetime of this object to the scope of this execution
-    pub fn run_with_reference<'a, 'b: 'a, T: CustomReference + 'b, EXT: CustomReference + 'static>(
-        &'a mut self,
-        obj: &'a mut T,
-        bind_to: &'a str,
-        script: &'a str,
-    ) -> Result<SteelVal>
-    where
-        T: ReferenceMarker<'b, Static = EXT>,
-    {
-        self.with_mut_reference(obj).consume(|engine, args| {
-            let mut args = args.into_iter();
-
-            engine.register_value(bind_to, args.next().unwrap());
-
-            let res = engine.compile_and_run_raw_program(script);
-
-            engine.register_value(bind_to, SteelVal::Void);
-
-            res.map(|x| x.into_iter().next().unwrap())
-        })
-    }
-
-    pub fn run_with_reference_from_path<
-        'a,
-        'b: 'a,
-        T: CustomReference + 'b,
-        EXT: CustomReference + 'static,
-    >(
-        &'a mut self,
-        obj: &'a mut T,
-        bind_to: &'a str,
-        script: &'a str,
-        path: PathBuf,
-    ) -> Result<SteelVal>
-    where
-        T: ReferenceMarker<'b, Static = EXT>,
-    {
-        self.with_mut_reference(obj).consume(move |engine, args| {
-            let mut args = args.into_iter();
-
-            engine.register_value(bind_to, args.next().unwrap());
-
-            let res = engine.compile_and_run_raw_program_with_path(script, path.clone());
-
-            engine.register_value(bind_to, SteelVal::Void);
-
-            res.map(|x| x.into_iter().next().unwrap())
-        })
-    }
-
-    pub fn run_thunk_with_reference<
-        'a,
-        'b: 'a,
-        T: CustomReference + 'b,
-        EXT: CustomReference + 'static,
-    >(
-        &'a mut self,
-        obj: &'a mut T,
-        mut thunk: impl FnMut(&mut Engine, SteelVal) -> Result<SteelVal>,
-    ) -> Result<SteelVal>
-    where
-        T: ReferenceMarker<'b, Static = EXT>,
-    {
-        self.with_mut_reference(obj).consume(|engine, args| {
-            let mut args = args.into_iter();
-
-            thunk(engine, args.into_iter().next().unwrap())
-        })
-    }
-
-    pub fn run_thunk_with_ro_reference<
-        'a,
-        'b: 'a,
-        T: CustomReference + 'b,
-        EXT: CustomReference + 'static,
-    >(
-        &'a mut self,
-        obj: &'a T,
-        mut thunk: impl FnMut(&mut Engine, SteelVal) -> Result<SteelVal>,
-    ) -> Result<SteelVal>
-    where
-        T: ReferenceMarker<'b, Static = EXT>,
-    {
-        self.with_immutable_reference(obj).consume(|engine, args| {
-            let mut args = args.into_iter();
-
-            thunk(engine, args.into_iter().next().unwrap())
-        })
-    }
-
-    /// Instantiates a new engine instance with all the primitive functions enabled.
-    /// This is the most general engine entry point, and includes both the contract and
-    /// prelude files in the root.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// let mut vm = Engine::new();
-    /// vm.run(r#"(+ 1 2 3)"#).unwrap();
-    /// ```
-    pub fn new() -> Self {
-        let mut engine = fresh_kernel_image();
-
-        engine.compiler.kernel = Some(Kernel::new());
-
-        let now = std::time::Instant::now();
-
-        if let Err(e) = engine.run(PRELUDE_WITHOUT_BASE) {
-            raise_error(&engine.sources, e);
-            panic!("This shouldn't happen!");
-        }
-
-        log::info!(target: "engine-creation", "Engine Creation: {:?}", now.elapsed());
-
-        engine
-    }
-
-    pub(crate) fn new_printer() -> Self {
-        let mut engine = fresh_kernel_image();
-
-        engine.compiler.kernel = Some(Kernel::new());
-
-        engine
-    }
-
-    /// Consumes the current `Engine` and emits a new `Engine` with the prelude added
-    /// to the environment. The prelude won't work unless the primitives are also enabled.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// let mut vm = Engine::new_base().with_prelude().unwrap();
-    /// vm.run("(+ 1 2 3)").unwrap();
-    /// ```
-    pub fn with_prelude(mut self) -> Result<Self> {
-        let core_libraries = &[crate::stdlib::PRELUDE];
-
-        for core in core_libraries {
-            self.compile_and_run_raw_program(core)?;
-        }
-
-        Ok(self)
-    }
-
-    /// Registers the prelude to the environment of the given Engine.
-    /// The prelude won't work unless the primitives are also enabled.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// let mut vm = Engine::new_base();
-    /// vm.register_prelude().unwrap();
-    /// vm.run("(+ 1 2 3)").unwrap();
-    /// ```
-    pub fn register_prelude(&mut self) -> Result<&mut Self> {
-        let core_libraries = &[crate::stdlib::PRELUDE];
-
-        for core in core_libraries {
-            self.compile_and_run_raw_program(core)?;
-        }
-
-        Ok(self)
-    }
-
-    // Registers the given module into the virtual machine
-    pub fn register_module(&mut self, module: BuiltInModule) -> &mut Self {
-        // Add the module to the map
-        self.modules.insert(module.name(), module.clone());
-        // Register the actual module itself as a value to make the virtual machine capable of reading from it
-        self.register_value(
-            module.unreadable_name().as_str(),
-            module.into_steelval().unwrap(),
-        );
-
-        self
-    }
-
-    #[cfg(feature = "dylibs")]
-    pub fn register_external_module(
-        &mut self,
-        module: abi_stable::std_types::RBox<FFIModule>,
-    ) -> Result<&mut Self> {
-        let external_module = FFIWrappedModule::new(module)?.build();
-
-        self.modules
-            .insert(external_module.name(), external_module.clone());
-
-        self.register_value(
-            external_module.unreadable_name().as_str(),
-            external_module.into_steelval().unwrap(),
-        );
-
-        Ok(self)
-    }
-
-    // /// Emits a program with path information embedded for error messaging.
-    // pub fn emit_program_with_path(&mut self, expr: &str, path: PathBuf) -> Result<Program> {
-    //     let constants = self.constants();
-    //     self.compiler.compile_program(expr, Some(path), constants)
-    // }
-
-    /// Emits a program for a given `expr` directly without providing any error messaging for the path.
-    // pub fn emit_program(&mut self, expr: &str) -> Result<Program> {
-    //     let constants = self.constants();
-    //     self.compiler.compile_program(expr, None, constants)
-    // }
-
-    pub fn emit_raw_program_no_path(&mut self, expr: &str) -> Result<RawProgramWithSymbols> {
-        let constants = self.constants();
-        self.compiler.compile_executable(
-            expr,
-            None,
-            constants,
-            self.modules.clone(),
-            &mut self.sources,
-        )
-    }
-
-    pub fn emit_raw_program(&mut self, expr: &str, path: PathBuf) -> Result<RawProgramWithSymbols> {
-        let constants = self.constants();
-        self.compiler.compile_executable(
-            expr,
-            Some(path),
-            constants,
-            self.modules.clone(),
-            &mut self.sources,
-        )
-    }
-
-    pub fn debug_print_build(
-        &mut self,
-        name: String,
-        program: RawProgramWithSymbols,
-    ) -> Result<()> {
-        program.debug_build(name, &mut self.compiler.symbol_map)
-    }
-
-    pub fn globals(&self) -> &Vec<InternedString> {
-        self.compiler.symbol_map.values()
-    }
-
-    // pub fn get_exported_module_functions(&self, path: PathBuf) -> impl Iterator<Item = InternedString> {
-
-    // }
-
-    // Attempts to disassemble the given expression into a series of bytecode dumps
-    // pub fn disassemble(&mut self, expr: &str) -> Result<String> {
-    //     let constants = self.constants();
-    //     self.compiler
-    //         .emit_debug_instructions(expr, constants)
-    //         .map(|x| {
-    //             x.into_iter()
-    //                 .map(|i| crate::core::instructions::disassemble(&i))
-    //                 .join("\n\n")
-    //         })
-    // }
-
-    // pub fn execute_without_callbacks(
-    //     &mut self,
-    //     bytecode: Rc<[DenseInstruction]>,
-    //     constant_map: &ConstantMap,
-    // ) -> Result<SteelVal> {
-    //     self.virtual_machine
-    //         .execute::<DoNotUseCallback>(bytecode, constant_map, &[])
-    // }
-
-    /// Execute bytecode with a constant map directly.
-    // pub fn execute(
-    //     &mut self,
-    //     bytecode: Rc<[DenseInstruction]>,
-    //     constant_map: ConstantMap,
-    // ) -> Result<SteelVal> {
-    //     self.virtual_machine
-    //         .execute(bytecode, constant_map, Rc::from([]))
-    // }
-
-    /// Emit the bytecode directly, with a path provided.
-    // pub fn emit_instructions_with_path(
-    //     &mut self,
-    //     exprs: &str,
-    //     path: PathBuf,
-    // ) -> Result<Vec<Vec<DenseInstruction>>> {
-    //     let constants = self.constants();
-    //     self.compiler
-    //         .emit_instructions(exprs, Some(path), constants)
-    // }
-
-    // /// Emit instructions directly, without a path for error messaging.
-    // pub fn emit_instructions(&mut self, exprs: &str) -> Result<Vec<Vec<DenseInstruction>>> {
-    //     let constants = self.constants();
-    //     self.compiler.emit_instructions(exprs, None, constants)
-    // }
-
-    /// Execute a program directly, returns a vector of `SteelVal`s corresponding to each expr in the `Program`.
-    // pub fn execute_program(&mut self, program: Program) -> Result<Vec<SteelVal>> {
-    //     self.virtual_machine
-    //         .execute_program::<UseCallback, ApplyContract>(program)
-    // }
-
-    // Generate dynamically linked files, containing all of the necessary information
-    // This means - compiling all macros as well.
-    fn load_raw_program(&mut self, mut program: RawProgramWithSymbols) {
-        fn eval_atom(t: &SyntaxObject) -> Result<SteelVal> {
-            match &t.ty {
-                TokenType::BooleanLiteral(b) => Ok((*b).into()),
-                TokenType::NumberLiteral(n) => Ok(SteelVal::NumV(*n)),
-                TokenType::StringLiteral(s) => Ok(SteelVal::StringV(s.into())),
-                TokenType::CharacterLiteral(c) => Ok(SteelVal::CharV(*c)),
-                TokenType::IntegerLiteral(steel_parser::tokens::MaybeBigInt::Small(n)) => {
-                    Ok(SteelVal::IntV(*n))
-                }
-                TokenType::IntegerLiteral(MaybeBigInt::Big(b)) => b.clone().into_steelval(),
-                // TODO: Keywords shouldn't be misused as an expression - only in function calls are keywords allowed
-                TokenType::Keyword(k) => Ok(SteelVal::SymbolV(k.clone().into())),
-                what => {
-                    // println!("getting here in the eval_atom - code_gen");
-                    stop!(UnexpectedToken => what; t.span)
-                }
-            }
-        }
-
-        for expr in &mut program.instructions {
-            // Reform the program to conform to the current state of _this_ engine.
-            for i in 0..expr.len() {
-                let instruction = &mut expr[i];
-
-                match instruction {
-                    Instruction {
-                        op_code: OpCode::PUSHCONST,
-                        contents: Some(Expr::Atom(constant_value)),
-                        ..
-                    } => {
-                        let value =
-                            eval_atom(&constant_value).expect("This must be a constant value");
-
-                        instruction.payload_size = self.compiler.constant_map.add_or_get(value);
-                    }
-
-                    Instruction {
-                        op_code: OpCode::PUSHCONST,
-                        contents: Some(Expr::List(expression)),
-                        ..
-                    } => {
-                        let value = SteelVal::try_from(expression.clone())
-                            .expect("This conversion must work");
-
-                        instruction.payload_size = self.compiler.constant_map.add_or_get(value);
-                    }
-
-                    _ => {
-                        todo!()
-                    }
-                }
-            }
-        }
-    }
-
-    // TODO -> clean up this API a lot
-    pub fn compile_and_run_raw_program_with_path(
-        &mut self,
-        exprs: &str,
-        path: PathBuf,
-    ) -> Result<Vec<SteelVal>> {
-        let constants = self.constants();
-        let program = self.compiler.compile_executable(
-            exprs,
-            Some(path),
-            constants,
-            self.modules.clone(),
-            &mut self.sources,
-        )?;
-
-        // program.profile_instructions();
-
-        self.run_raw_program(program)
-    }
-
-    pub(crate) fn run_raw_program_from_exprs(
-        &mut self,
-        exprs: Vec<ExprKind>,
-    ) -> Result<Vec<SteelVal>> {
-        let constants = self.constants();
-        let program = self.compiler.compile_executable_from_expressions(
-            exprs,
-            self.modules.clone(),
-            constants,
-            &mut self.sources,
-        )?;
-        self.run_raw_program(program)
-    }
-
-    pub fn compile_and_run_raw_program(&mut self, exprs: &str) -> Result<Vec<SteelVal>> {
-        let constants = self.constants();
-        let program = self.compiler.compile_executable(
-            exprs,
-            None,
-            constants,
-            self.modules.clone(),
-            &mut self.sources,
-        )?;
-
-        self.run_raw_program(program)
-    }
-
-    pub fn raw_program_to_executable(
-        &mut self,
-        program: RawProgramWithSymbols,
-    ) -> Result<Executable> {
-        let symbol_map_offset = self.compiler.symbol_map.len();
-
-        let result = program.build("TestProgram".to_string(), &mut self.compiler.symbol_map);
-
-        // Revisit if we need to do this at all?
-        if result.is_err() {
-            self.compiler.symbol_map.roll_back(symbol_map_offset);
-        }
-
-        result
-    }
-
-    pub fn run_raw_program(&mut self, program: RawProgramWithSymbols) -> Result<Vec<SteelVal>> {
-        let executable = self.raw_program_to_executable(program)?;
-        self.virtual_machine.run_executable(&executable)
-    }
-
-    pub fn run_executable(&mut self, executable: &Executable) -> Result<Vec<SteelVal>> {
-        self.virtual_machine.run_executable(executable)
-    }
-
-    /// Directly emit the expanded ast
-    pub fn emit_expanded_ast(
-        &mut self,
-        expr: &str,
-        path: Option<PathBuf>,
-    ) -> Result<Vec<ExprKind>> {
-        let constants = self.constants();
-        self.compiler.emit_expanded_ast(
-            expr,
-            constants,
-            path,
-            &mut self.sources,
-            self.modules.clone(),
-        )
-    }
-
-    pub fn emit_expanded_ast_without_optimizations(
-        &mut self,
-        expr: &str,
-        path: Option<PathBuf>,
-    ) -> Result<Vec<ExprKind>> {
-        let constants = self.constants();
-        self.compiler.emit_expanded_ast_without_optimizations(
-            expr,
-            constants,
-            path,
-            &mut self.sources,
-            self.modules.clone(),
-        )
-    }
-
-    /// Emit the unexpanded AST
-    pub fn emit_ast_to_string(expr: &str) -> Result<String> {
-        let parsed: std::result::Result<Vec<ExprKind>, ParseError> =
-            Parser::new(expr, None).collect();
-        let parsed = parsed?;
-        Ok(parsed.into_iter().map(|x| x.to_pretty(60)).join("\n\n"))
-    }
-
-    /// Emit the fully expanded AST as a pretty printed string
-    pub fn emit_fully_expanded_ast_to_string(
-        &mut self,
-        expr: &str,
-        path: Option<PathBuf>,
-    ) -> Result<String> {
-        let constants = self.constants();
-        Ok(self
-            .compiler
-            .emit_expanded_ast(
-                expr,
-                constants,
-                path,
-                &mut self.sources,
-                self.modules.clone(),
-            )?
-            .into_iter()
-            .map(|x| x.to_pretty(60))
-            .join("\n\n"))
-    }
-
-    /// Emits the fully expanded AST directly.
-    pub fn emit_fully_expanded_ast(
-        &mut self,
-        expr: &str,
-        path: Option<PathBuf>,
-    ) -> Result<Vec<ExprKind>> {
-        let constants = self.constants();
-        self.compiler.emit_expanded_ast(
-            expr,
-            constants,
-            path,
-            &mut self.sources,
-            self.modules.clone(),
-        )
-    }
-
-    /// Registers an external value of any type as long as it implements [`FromSteelVal`](crate::rvals::FromSteelVal) and
-    /// [`IntoSteelVal`](crate::rvals::IntoSteelVal). This method does the coercion to embed the type into the `Engine`'s
-    /// environment with the name `name`. This function can fail only if the conversion from `T` to [`SteelVal`](crate::rvals::SteelVal) fails.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// let mut vm = Engine::new();
-    /// let external_value = "hello-world".to_string();
-    /// vm.register_external_value("hello-world", external_value).unwrap();
-    /// vm.run("hello-world").unwrap(); // Will return the string
-    /// ```
-    pub fn register_external_value<T: FromSteelVal + IntoSteelVal>(
-        &mut self,
-        name: &str,
-        value: T,
-    ) -> Result<&mut Self> {
-        let converted = value.into_steelval()?;
-        Ok(self.register_value(name, converted))
-    }
-
-    /// Registers a [`SteelVal`](crate::rvals::SteelVal) under the name `name` in the `Engine`'s internal environment.
-    ///
-    /// # Examples
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// use steel::rvals::SteelVal;
-    ///
-    /// let mut vm = Engine::new();
-    /// let external_value = SteelVal::StringV("hello-world".to_string().into());
-    /// vm.register_value("hello-world", external_value);
-    /// vm.run("hello-world").unwrap(); // Will return the string
-    /// ```
-    pub fn register_value(&mut self, name: &str, value: SteelVal) -> &mut Self {
-        self.register_value_inner(name, value)
-
-        // let idx = self.compiler.register(name);
-        // self.virtual_machine.insert_binding(idx, value);
-        // self
-    }
-
-    /// Registers multiple values at once
-    pub fn register_values(
-        &mut self,
-        values: impl Iterator<Item = (String, SteelVal)>,
-    ) -> &mut Self {
-        for (name, value) in values {
-            self.register_value(name.as_str(), value);
-        }
-        self
-    }
-
-    /// Registers a predicate for a given type. When embedding external values, it is convenient
-    /// to be able to have a predicate to test if the given value is the specified type.
-    /// In order to be registered, a type must implement [`FromSteelVal`](crate::rvals::FromSteelVal)
-    /// and [`IntoSteelVal`](crate::rvals::IntoSteelVal)
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// use steel::steel_vm::register_fn::RegisterFn;
-    /// fn foo() -> usize {
-    ///    10
-    /// }
-    ///
-    /// let mut vm = Engine::new();
-    /// vm.register_fn("foo", foo);
-    ///
-    /// vm.run(r#"(foo)"#).unwrap(); // Returns vec![10]
-    /// ```
-    pub fn register_type<T: FromSteelVal + IntoSteelVal>(
-        &mut self,
-        predicate_name: &'static str,
-    ) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected 1 argument, got {}", predicate_name, args.len()));
-            }
-
-            assert!(args.len() == 1);
-
-            Ok(SteelVal::BoolV(T::from_steelval(&args[0]).is_ok()))
-        };
-
-        self.register_value(
-            predicate_name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(predicate_name),
-                Some(1),
-            ))),
-        )
-    }
-
-    // /// Registers a callback function. If registered, this callback will be called on every instruction
-    // /// Allows for the introspection of the currently running process. The callback here takes as an argument the current instruction number.
-    // ///
-    // /// # Examples
-    // ///
-    // /// ```
-    // /// # extern crate steel;
-    // /// # use steel::steel_vm::engine::Engine;
-    // /// let mut vm = Engine::new();
-    // /// vm.on_progress(|count| {
-    // ///     // parameter is 'usize' - number of instructions performed up to this point
-    // ///     if count % 1000 == 0 {
-    // ///         // print out a progress log every 1000 operations
-    // ///         println!("Number of instructions up to this point: {}", count);
-    // ///         // Returning false here would quit the evaluation of the function
-    // ///         return true;
-    // ///     }
-    // ///     true
-    // /// });
-    // /// // This should end with "Number of instructions up to this point: 12000"
-    // /// vm.run(
-    // ///     r#"
-    // ///     (define (loop x)
-    // ///         (if (equal? x 1000)
-    // ///             x
-    // ///             (loop (+ x 1))))
-    // ///     (loop 0)
-    // /// "#,
-    // /// )
-    // /// .unwrap();
-    // /// ```
-    // pub fn on_progress<FN: Fn(usize) -> bool + 'static>(&mut self, _callback: FN) -> &mut Self {
-    //     // self.virtual_machine.on_progress(callback);
-    //     self
-    // }
-
-    /// Extracts a value with the given identifier `name` from the internal environment.
-    /// If a script calculated some series of bound values, then it can be extracted this way.
-    /// This will return the [`SteelVal`](crate::rvals::SteelVal), not the underlying data.
-    /// To unwrap the value, use the [`extract`](crate::steel_vm::engine::Engine::extract) method and pass the type parameter.
-    ///
-    /// The function will return an error if the `name` is not currently bound in the `Engine`'s internal environment.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// use steel::rvals::SteelVal;
-    /// let mut vm = Engine::new();
-    /// vm.run("(define a 10)").unwrap();
-    /// assert_eq!(vm.extract_value("a").unwrap(), SteelVal::IntV(10));
-    /// ```
-    pub fn extract_value(&self, name: &str) -> Result<SteelVal> {
-        let idx = self.compiler.get_idx(name).ok_or_else(throw!(
-            Generic => format!("free identifier: {name} - identifier given cannot be found in the global environment")
-        ))?;
-
-        self.virtual_machine.extract_value(idx)
-            .ok_or_else(throw!(
-                Generic => format!("free identifier: {name} - identifier given cannot be found in the global environment")
-            ))
-    }
-
-    /// Extracts a value with the given identifier `name` from the internal environment, and attempts to coerce it to the
-    /// given type. This will return an error if the `name` is not currently bound in the `Engine`'s internal environment, or
-    /// if the type passed in does not match the value (and thus the coercion using [`FromSteelVal`](crate::rvals::FromSteelVal) fails)
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// let mut vm = Engine::new();
-    /// vm.run("(define a 10)").unwrap();
-    /// assert_eq!(vm.extract::<usize>("a").unwrap(), 10);
-    /// ```
-    pub fn extract<T: FromSteelVal>(&self, name: &str) -> Result<T> {
-        T::from_steelval(&self.extract_value(name)?)
-    }
-
-    /// Raise the error within the stack trace
-    pub fn raise_error(&self, error: SteelErr) {
-        raise_error(&self.sources, error)
-    }
-
-    /// Emit an error string reporing, the back trace.
-    pub fn raise_error_to_string(&self, error: SteelErr) -> Option<String> {
-        raise_error_to_string(&self.sources, error)
-    }
-
-    /// Execute a program given as the `expr`, and computes a `Vec<SteelVal>` corresponding to the output of each expression given.
-    /// This method contains no path information used for error reporting, and simply runs the expression as is. Modules will be
-    /// imported with the root directory as wherever the executable was started.
-    /// Any parsing, compilation, or runtime error will be reflected here, ideally with span information as well. The error will not
-    /// be reported automatically.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # extern crate steel;
-    /// # use steel::steel_vm::engine::Engine;
-    /// use steel::rvals::SteelVal;
-    /// let mut vm = Engine::new();
-    /// let output = vm.run("(+ 1 2) (* 5 5) (- 10 5)").unwrap();
-    /// assert_eq!(output, vec![SteelVal::IntV(3), SteelVal::IntV(25), SteelVal::IntV(5)]);
-    /// ```
-    // pub fn run(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
-    //     let constants = self.constants();
-    //     let program = self.compiler.compile_program(expr, None, constants)?;
-    //     self.virtual_machine.execute_program(program)
-    // }
-
-    /// Execute a program, however do not run any callbacks as registered with `on_progress`.
-    // pub fn run_without_callbacks(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
-    //     let constants = self.constants();
-    //     let program = self.compiler.compile_program(expr, None, constants)?;
-    //     self.virtual_machine
-    //         .execute_program::<DoNotUseCallback, ApplyContract>(program)
-    // }
-
-    // TODO: Come back to this
-    /*
-    // / Execute a program (as per [`run`](crate::steel_vm::engine::Engine::run)), however do not enforce any contracts. Any contracts that are added are not
-    // / enforced.
-    // /
-    // / # Examples
-    // /
-    // / ```
-    // / # extern crate steel;
-    // / # use steel::steel_vm::engine::Engine;
-    // / use steel::rvals::SteelVal;
-    // / let mut vm = Engine::new();
-    // / let output = vm.run_without_contracts(r#"
-    // /        (define/contract (foo x)
-    // /           (->/c integer? any/c)
-    // /           "hello world")
-    // /
-    // /        (foo "bad-input")
-    // / "#).unwrap();
-    // / ```
-    // pub fn run_without_contracts(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
-    //     let constants = self.constants();
-    //     let program = self.compiler.compile_program(expr, None, constants)?;
-    //     self.virtual_machine.execute_program::<UseCallback>(program)
-    // }
-     */
-
-    /// Execute a program without invoking any callbacks, or enforcing any contract checking
-    // pub fn run_without_callbacks_or_contracts(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
-    //     let constants = self.constants();
-    //     let program = self.compiler.compile_program(expr, None, constants)?;
-    //     self.virtual_machine
-    //         .execute_program::<DoNotUseCallback, DoNotApplyContracts>(program)
-    // }
-
-    /// Similar to [`run`](crate::steel_vm::engine::Engine::run), however it includes path information
-    /// for error reporting purposes.
-    // pub fn run_with_path(&mut self, expr: &str, path: PathBuf) -> Result<Vec<SteelVal>> {
-    //     let constants = self.constants();
-    //     let program = self.compiler.compile_program(expr, Some(path), constants)?;
-    //     self.virtual_machine.execute_program(program)
-    // }
-
-    // pub fn compile_and_run_raw_program(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
-    //     let constants = self.constants();
-    //     let program = self.compiler.compile_program(expr, None, constants)?;
-    //     self.virtual_machine.execute_program(program)
-    // }
-
-    // pub fn compile_and_run_raw_program(&mut self, expr: &str) -> Result<Vec<SteelVal>> {
-    //     self.compile_and_run_raw_program(expr)
-    // }
-
-    // Read in the file from the given path and execute accordingly
-    // Loads all the functions in from the given env
-    // pub fn parse_and_execute_from_path<P: AsRef<Path>>(
-    //     &mut self,
-    //     path: P,
-    // ) -> Result<Vec<SteelVal>> {
-    //     let mut file = std::fs::File::open(path)?;
-    //     let mut exprs = String::new();
-    //     file.read_to_string(&mut exprs)?;
-    //     self.compile_and_run_raw_program(exprs.as_str(), )
-    // }
-
-    // pub fn parse_and_execute_from_path<P: AsRef<Path>>(
-    //     &mut self,
-    //     path: P,
-    // ) -> Result<Vec<SteelVal>> {
-    //     let path_buf = PathBuf::from(path.as_ref());
-    //     let mut file = std::fs::File::open(path)?;
-    //     let mut exprs = String::new();
-    //     file.read_to_string(&mut exprs)?;
-    //     self.run_with_path(exprs.as_str(), path_buf)
-    // }
-
-    // TODO this does not take into account the issues with
-    // people registering new functions that shadow the original one
-    fn constants(&mut self) -> ImmutableHashMap<InternedString, SteelVal> {
-        // TODO: The constants need to be invalidated, if any of them are redefined within
-        // the scope of execution.
-
-        if let Some(hm) = &mut self.constants {
-            if !hm.is_empty() {
-                for constant in CONSTANTS {
-                    let value = self
-                        .compiler
-                        .get_idx(constant)
-                        .ok_or_else(throw!(
-                            Generic => format!("unreachable")
-                        ))
-                        .and_then(|idx| {
-                            self.virtual_machine.extract_value(idx).ok_or_else(throw!(
-                                Generic => "unreachable"
-                            ))
-                        });
-
-                    if let Ok(v) = value {
-                        hm.insert((*constant).into(), v);
-                    }
-                }
-            }
-        }
-
-        let mut hm = ImmutableHashMap::new();
-        for constant in CONSTANTS {
-            if let Ok(v) = self.extract_value(constant) {
-                hm.insert((*constant).into(), v);
-            }
-        }
-        self.constants = Some(hm.clone());
-
-        hm
-    }
-
-    pub fn add_module(&mut self, path: String) -> Result<()> {
-        self.compiler
-            .compile_module(path.into(), &mut self.sources, self.modules.clone())
-    }
-
-    pub fn modules(&self) -> &HashMap<PathBuf, CompiledModule> {
-        self.compiler.modules()
-    }
-
-    pub fn global_exists(&self, ident: &str) -> bool {
-        let spur = if let Some(spur) = InternedString::try_get(ident) {
-            spur
-        } else {
-            return false;
-        };
-
-        self.compiler.symbol_map.get(&spur).is_ok()
-    }
-
-    pub fn symbol_map(&self) -> &SymbolMap {
-        &self.compiler.symbol_map
-    }
-
-    pub fn in_scope_macros(&self) -> &HashMap<InternedString, SteelMacro> {
-        &self.compiler.macro_env
-    }
-
-    pub fn in_scope_macros_mut(&mut self) -> &mut HashMap<InternedString, SteelMacro> {
-        &mut self.compiler.macro_env
-    }
-
-    pub fn get_module(&self, path: PathBuf) -> Result<SteelVal> {
-        let module_path =
-            "__module-mangler".to_string() + path.as_os_str().to_str().unwrap() + "__%#__";
-
-        self.extract_value(&module_path)
-    }
-
-    pub fn get_source_id(&self, path: &PathBuf) -> Option<SourceId> {
-        self.sources.get_source_id(path)
-    }
-
-    pub fn get_path_for_source_id(&self, source_id: &SourceId) -> Option<PathBuf> {
-        self.sources.get_path(source_id)
-    }
-
-    pub fn get_source(&self, source_id: &SourceId) -> Option<String> {
-        self.sources
-            .sources
-            .lock()
-            .unwrap()
-            .get(*source_id)
-            .cloned()
-    }
-}
-
-// #[cfg(test)]
-// mod on_progress_tests {
-//     use super::*;
-//     use std::cell::Cell;
-//     use std::rc::Rc;
-
-//     // TODO: At the moment the on progress business is turned off
-
-//     // #[test]
-//     // fn count_every_thousand() {
-//     //     let mut vm = Engine::new();
-
-//     //     let external_count = Rc::new(Cell::new(0));
-//     //     let embedded_count = Rc::clone(&external_count);
-
-//     //     vm.on_progress(move |count| {
-//     //         // parameter is 'usize' - number of instructions performed up to this point
-//     //         if count % 1000 == 0 {
-//     //             // print out a progress log every 1000 operations
-//     //             println!("Number of instructions up to this point: {}", count);
-//     //             embedded_count.set(embedded_count.get() + 1);
-
-//     //             // Returning false here would quit the evaluation of the function
-//     //             return true;
-//     //         }
-//     //         true
-//     //     });
-
-//     //     // This should end with "Number of instructions up to this point: 4000"
-//     //     vm.run(
-//     //         r#"
-//     //         (define (loop x)
-//     //             (if (equal? x 1000)
-//     //                 x
-//     //                 (loop (+ x 1))))
-//     //         (displayln (loop 0))
-//     //     "#,
-//     //     )
-//     //     .unwrap();
-
-//     //     assert_eq!(external_count.get(), 4);
-//     // }
-// }
-
-fn raise_error(sources: &Sources, error: SteelErr) {
-    if let Some(span) = error.span() {
-        if let Some(source_id) = span.source_id() {
-            let sources = sources.sources.lock().unwrap();
-
-            let file_name = sources.get_path(&source_id);
-
-            if let Some(file_content) = sources.get(source_id) {
-                // Build stack trace if we have it:
-                if let Some(trace) = error.stack_trace() {
-                    // TODO: Flatten recursive calls into the same stack trace
-                    // and present the count
-                    for dehydrated_context in trace.trace().iter().take(20) {
-                        // Report a call stack with whatever we actually have,
-                        if let Some(span) = dehydrated_context.span() {
-                            if let Some(id) = span.source_id() {
-                                if let Some(source) = sources.get(id) {
-                                    let trace_line_file_name = sources.get_path(&id);
-
-                                    let resolved_file_name = trace_line_file_name
-                                        .as_ref()
-                                        .and_then(|x| x.to_str())
-                                        .unwrap_or_default();
-
-                                    back_trace(&resolved_file_name, &source, *span);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                let resolved_file_name = file_name.unwrap_or_default();
-
-                error.emit_result(resolved_file_name.to_str().unwrap(), &file_content);
-                return;
-            }
-        }
-    }
-
-    println!("Unable to locate source and span information for this error: {error}");
-}
-
-// If we are to construct an error object, emit that
-pub(crate) fn raise_error_to_string(sources: &Sources, error: SteelErr) -> Option<String> {
-    if let Some(span) = error.span() {
-        if let Some(source_id) = span.source_id() {
-            let sources = sources.sources.lock().unwrap();
-
-            let file_name = sources.get_path(&source_id);
-
-            if let Some(file_content) = sources.get(source_id) {
-                let mut back_traces = Vec::with_capacity(20);
-
-                // Build stack trace if we have it:
-                if let Some(trace) = error.stack_trace() {
-                    // TODO: Flatten recursive calls into the same stack trace
-                    // and present the count
-                    for dehydrated_context in trace.trace().iter().take(20) {
-                        // Report a call stack with whatever we actually have,
-                        if let Some(span) = dehydrated_context.span() {
-                            // Missing the span, its not particularly worth reporting?
-                            if span.start == 0 && span.end == 0 {
-                                continue;
-                            }
-
-                            if let Some(id) = span.source_id() {
-                                if let Some(source) = sources.get(id) {
-                                    let trace_line_file_name = sources.get_path(&id);
-
-                                    let resolved_file_name = trace_line_file_name
-                                        .as_ref()
-                                        .and_then(|x| x.to_str())
-                                        .unwrap_or_default();
-
-                                    let bt =
-                                        back_trace_to_string(&resolved_file_name, &source, *span);
-                                    back_traces.push(bt);
-                                }
-                            }
-                        }
-                    }
-                }
-
-                let resolved_file_name = file_name.unwrap_or_default();
-
-                let final_error = error
-                    .emit_result_to_string(resolved_file_name.to_str().unwrap(), &file_content);
-
-                back_traces.push(final_error);
-
-                return Some(back_traces.join("\n"));
-            }
-        }
-    }
-
-    // println!("Unable to locate source and span information for this error: {error}");
-
-    None
-}
-
-#[cfg(test)]
-mod engine_api_tests {
-    use crate::custom_reference;
-
-    use super::*;
-
-    struct ReferenceStruct {
-        value: usize,
-    }
-
-    impl ReferenceStruct {
-        pub fn get_value(&mut self) -> usize {
-            self.value
-        }
-
-        pub fn get_value_immutable(&self) -> usize {
-            self.value
-        }
-    }
-
-    impl CustomReference for ReferenceStruct {}
-    custom_reference!(ReferenceStruct);
-
-    #[test]
-    fn test_references_in_engine() {
-        let mut engine = Engine::new();
-        let mut external_object = ReferenceStruct { value: 10 };
-
-        engine.register_fn("external-get-value", ReferenceStruct::get_value);
-
-        {
-            let res = engine
-                .run_with_reference::<ReferenceStruct, ReferenceStruct>(
-                    &mut external_object,
-                    "*external*",
-                    "(external-get-value *external*)",
-                )
-                .unwrap();
-
-            assert_eq!(res, SteelVal::IntV(10));
-        }
-    }
-
-    #[test]
-    fn test_references_in_engine_get_removed_after_lifetime() {
-        let mut engine = Engine::new();
-        let mut external_object = ReferenceStruct { value: 10 };
-
-        engine.register_fn("external-get-value", ReferenceStruct::get_value);
-
-        let res = engine
-            .run_with_reference::<ReferenceStruct, ReferenceStruct>(
-                &mut external_object,
-                "*external*",
-                "(external-get-value *external*)",
-            )
-            .unwrap();
-
-        assert_eq!(res, SteelVal::IntV(10));
-
-        // Afterwards, the value should be gone
-        assert_eq!(engine.extract_value("*external*").unwrap(), SteelVal::Void);
-    }
-
-    #[test]
-    fn test_immutable_references_in_engine_get_removed_after_lifetime() {
-        let mut engine = Engine::new();
-        let external_object = ReferenceStruct { value: 10 };
-
-        engine.register_fn("external-get-value", ReferenceStruct::get_value);
-
-        engine.register_fn(
-            "external-get-value-imm",
-            ReferenceStruct::get_value_immutable,
-        );
-
-        let res = engine
-            .run_thunk_with_ro_reference::<ReferenceStruct, ReferenceStruct>(
-                &external_object,
-                |mut engine, value| {
-                    engine.register_value("*external*", value);
-                    engine
-                        .compile_and_run_raw_program("(external-get-value-imm *external*)")
-                        .map(|x| x.into_iter().next().unwrap())
-                },
-            )
-            .unwrap();
-
-        assert_eq!(res, SteelVal::IntV(10));
-
-        // This absolutely has to fail, otherwise we're in trouble.
-        assert!(engine
-            .compile_and_run_raw_program("(external-get-value-imm *external*)")
-            .is_err());
-    }
-}
diff --git a/crates/steel-core/src/steel_vm/ffi.rs b/crates/steel-core/src/steel_vm/ffi.rs
deleted file mode 100644
index 73a2cd2f9..000000000
--- a/crates/steel-core/src/steel_vm/ffi.rs
+++ /dev/null
@@ -1,1009 +0,0 @@
-use std::{
-    borrow::Cow,
-    cell::{Ref, RefCell, RefMut},
-    marker::PhantomData,
-    rc::Rc,
-    sync::{Arc, Mutex},
-};
-
-use crate::{
-    gc::{unsafe_erased_pointers::OpaqueReference, Gc},
-    rerrs::ErrorKind,
-    rvals::{
-        as_underlying_type, Custom, CustomType, FutureResult, IntoSteelVal, Result, SRef,
-        SteelHashMap, SteelVal,
-    },
-    values::functions::{BoxedDynFunction, StaticOrRcStr},
-    SteelErr,
-};
-
-use abi_stable::{
-    std_types::{RBoxError, RCowStr, RHashMap, RResult, RSlice, RStr, RString, RVec, Tuple2},
-    StableAbi,
-};
-use futures_util::FutureExt;
-
-pub use async_ffi::{FfiFuture, FutureExt as FfiFutureExt};
-
-#[macro_export]
-macro_rules! ffi_try {
-    ($result:expr) => {
-        match $result {
-            RResult::ROk(v) => v,
-            RResult::RErr(e) => return RResult::RErr(e),
-        }
-    };
-}
-
-/// This creates an external module this is _mostly_ safe.
-#[repr(C)]
-#[derive(StableAbi, Debug)]
-pub struct FFIModule {
-    // Name of the module - let this be set by the dylib
-    name: RString,
-    values: RHashMap<RString, FFIValue>,
-    docs: RBox<FFIInternalDocumentation>,
-}
-
-impl FFIModule {
-    pub fn new<T: Into<RString>>(name: T) -> Self {
-        Self {
-            name: name.into(),
-            values: RHashMap::default(),
-            docs: RBox::new(FFIInternalDocumentation::new()),
-        }
-    }
-
-    pub fn register_value<T: Into<FFIValue>>(&mut self, name: &str, value: T) -> &mut Self {
-        self.values.insert(RString::from(name), value.into());
-        self
-    }
-}
-
-// TODO: Wrap FFI Objects with this trait, have the object we pass around just be a normal one?
-// Making sure that we are not referencing static things (or memory accessed in the other one?)
-
-#[repr(C)]
-#[derive(Clone)]
-pub struct OpaqueFFIValue {
-    pub name: RString,
-    pub inner: Gc<RefCell<Box<dyn CustomType>>>,
-}
-
-impl Custom for OpaqueFFIValue {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("#<{}>", self.name)))
-    }
-}
-
-// Unfortunately we'll have to wrap the incoming reference in multiple layers of indirection
-#[repr(C)]
-#[derive(Clone)]
-pub struct OpaqueFFIReference {
-    pub name: RString,
-    pub inner: OpaqueReference<'static>,
-}
-
-// Probably need to merge these together?
-impl Custom for OpaqueFFIReference {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("#<{}>", self.name)))
-    }
-}
-
-use crate::steel_vm::register_fn::SendSyncStatic;
-
-pub trait RegisterFFIFn<FN, ARGS, RET> {
-    fn register_fn(&mut self, name: &str, func: FN) -> &mut Self;
-}
-
-pub trait IntoFFIVal: Sized {
-    fn into_ffi_val(self) -> RResult<FFIValue, RBoxError>;
-}
-
-// Probably can do a blanket impl here?
-pub trait FromFFIVal: Sized {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError>;
-}
-
-fn ffi_error(message: Cow<'static, str>) -> RBoxError {
-    let error: Box<dyn std::error::Error + Send + Sync> = message.into();
-
-    RBoxError::from_box(error)
-}
-
-// FFI Conversions for primitives
-macro_rules! conversion_error {
-    ($name:tt, $val:expr) => {
-        RResult::RErr(ffi_error(
-            format!("Value unable to be converted to $name: {:?}", $val).into(),
-        ))
-    };
-}
-
-impl<T: IntoFFIVal, E: IntoFFIVal> IntoFFIVal for std::result::Result<T, E> {
-    fn into_ffi_val(self) -> RResult<FFIValue, RBoxError> {
-        match self {
-            Ok(v) => v.into_ffi_val(),
-            Err(e) => {
-                let error: Box<dyn std::error::Error + Send + Sync> =
-                    format!("{:?}", ffi_try!(e.into_ffi_val())).into();
-
-                RResult::RErr(RBoxError::from_box(error))
-            }
-        }
-    }
-}
-
-impl<T: IntoFFIVal> IntoFFIVal for Option<T> {
-    fn into_ffi_val(self) -> RResult<FFIValue, RBoxError> {
-        match self {
-            Some(value) => value.into_ffi_val(),
-            None => RResult::ROk(FFIValue::BoolV(false)),
-        }
-    }
-}
-
-impl FromFFIVal for bool {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError> {
-        if let FFIValue::BoolV(b) = val {
-            RResult::ROk(b)
-        } else {
-            conversion_error!(boolean, val)
-        }
-    }
-}
-
-impl From<bool> for FFIValue {
-    fn from(value: bool) -> Self {
-        FFIValue::BoolV(value)
-    }
-}
-
-// Blanket implementation
-impl<T: Into<FFIValue>> IntoFFIVal for T {
-    fn into_ffi_val(self) -> RResult<FFIValue, RBoxError> {
-        RResult::ROk(self.into())
-    }
-}
-
-// use async_ffi::FutureExt as FFIFutureExt;
-// impl<F: Future<Output = FFIValue>> IntoFFIVal for F {
-//     fn into_ffi_val(self) -> RResult<FFIValue, RBoxError> {
-//         RResult::ROk(FFIValue::Future {
-//             fut: self.into_ffi(),
-//         })
-//     }
-// }
-
-// impl<T: IntoFFIVal, F: Future<Output = T>> From<F> for FFIValue {
-//     fn from(value: F) -> FFIValue {
-//         todo!()
-//     }
-// }
-
-impl From<FfiFuture<RResult<FFIValue, RBoxError>>> for FFIValue {
-    fn from(value: FfiFuture<RResult<FFIValue, RBoxError>>) -> Self {
-        FFIValue::Future { fut: value }
-    }
-}
-
-impl FromFFIVal for String {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError> {
-        if let FFIValue::StringV(s) = val {
-            RResult::ROk(s.into_string())
-        } else {
-            conversion_error!(string, val)
-        }
-    }
-}
-
-impl From<String> for FFIValue {
-    fn from(value: String) -> Self {
-        FFIValue::StringV(RString::from(value))
-    }
-}
-
-impl FromFFIVal for f64 {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError> {
-        if let FFIValue::NumV(n) = val {
-            RResult::ROk(n)
-        } else {
-            conversion_error!(f64, val)
-        }
-    }
-}
-
-impl From<f64> for FFIValue {
-    fn from(value: f64) -> Self {
-        FFIValue::NumV(value)
-    }
-}
-
-// This is super spooky...
-impl FromFFIVal for usize {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError> {
-        if let FFIValue::IntV(i) = val {
-            RResult::ROk(i as usize)
-        } else {
-            conversion_error!(isize, val)
-        }
-    }
-}
-
-impl FromFFIVal for isize {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError> {
-        if let FFIValue::IntV(i) = val {
-            RResult::ROk(i)
-        } else {
-            conversion_error!(isize, val)
-        }
-    }
-}
-
-impl From<isize> for FFIValue {
-    fn from(value: isize) -> Self {
-        FFIValue::IntV(value)
-    }
-}
-
-impl FromFFIVal for () {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError> {
-        if let FFIValue::Void = val {
-            RResult::ROk(())
-        } else {
-            conversion_error!((), val)
-        }
-    }
-}
-
-impl From<()> for FFIValue {
-    fn from(_: ()) -> Self {
-        FFIValue::Void
-    }
-}
-
-impl<T: FromFFIVal> FromFFIVal for Vec<T> {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError> {
-        if let FFIValue::Vector(v) = val {
-            let mut collected = Vec::with_capacity(v.len());
-
-            for value in v {
-                match T::from_ffi_val(value) {
-                    RResult::ROk(v) => collected.push(v),
-                    RResult::RErr(r) => return RResult::RErr(r),
-                }
-            }
-
-            RResult::ROk(collected)
-        } else {
-            conversion_error!(Vec, val)
-        }
-    }
-}
-
-// TODO: I think we can get rid of the unnecessary cloning... maybe?
-impl<T: Custom + Clone + 'static> FromFFIVal for T {
-    fn from_ffi_val(val: FFIValue) -> RResult<Self, RBoxError> {
-        if let FFIValue::Custom { custom } = &val {
-            if let Some(underlying) = as_underlying_type::<T>(custom.inner.borrow().as_ref()) {
-                return RResult::ROk(underlying.clone());
-            }
-        }
-        conversion_error!(Opaque, val)
-    }
-}
-
-// Convert this directly to the type we want on the way out
-impl<T: CustomType + 'static> From<T> for FFIValue {
-    fn from(value: T) -> Self {
-        let name = RString::from(value.name());
-
-        FFIValue::Custom {
-            custom: OpaqueFFIValue {
-                name,
-                inner: Gc::new(RefCell::new(Box::new(value))),
-            },
-        }
-    }
-}
-
-pub struct Wrapper<ARGS>(PhantomData<ARGS>);
-pub struct WrapperRef<ARGS>(PhantomData<ARGS>);
-pub struct WrapperMut<ARGS>(PhantomData<ARGS>);
-pub struct WrapperMutRef<ARGS>(PhantomData<ARGS>);
-
-pub trait AsRefFFIVal: Sized {
-    type Nursery: Default;
-
-    fn as_ref<'b, 'a: 'b>(
-        val: &'a FFIValue,
-        _nursery: &'a mut Self::Nursery,
-    ) -> RResult<SRef<'b, Self>, RBoxError>;
-
-    fn as_mut_ref<'b, 'a: 'b>(val: &'a FFIValue) -> RResult<RefMut<'b, Self>, RBoxError>;
-}
-
-impl<T: CustomType + 'static> AsRefFFIVal for T {
-    type Nursery = ();
-
-    fn as_ref<'b, 'a: 'b>(
-        val: &'a FFIValue,
-        _nursery: &'a mut Self::Nursery,
-    ) -> RResult<SRef<'b, Self>, RBoxError> {
-        if let FFIValue::Custom { custom } = val {
-            let res = Ref::map(custom.inner.borrow(), |x| x.as_any_ref());
-
-            if res.is::<T>() {
-                return RResult::ROk(SRef::Owned(Ref::map(res, |x| {
-                    x.downcast_ref::<T>().unwrap()
-                })));
-            }
-        }
-
-        return conversion_error!(OpaqueFFIValue, val);
-    }
-
-    fn as_mut_ref<'b, 'a: 'b>(val: &'a FFIValue) -> RResult<RefMut<'b, Self>, RBoxError> {
-        if let FFIValue::Custom { custom } = val {
-            let res = RefMut::map(custom.inner.borrow_mut(), |x| x.as_any_ref_mut());
-
-            if res.is::<T>() {
-                return RResult::ROk(RefMut::map(res, |x| x.downcast_mut::<T>().unwrap()));
-            }
-        }
-
-        return conversion_error!(OpaqueFFIValue, val);
-    }
-}
-
-impl From<RVec<FFIValue>> for FFIValue {
-    fn from(value: RVec<FFIValue>) -> Self {
-        FFIValue::Vector(value)
-    }
-}
-
-impl<T: IntoFFIVal> IntoFFIVal for Vec<T> {
-    fn into_ffi_val(self) -> RResult<FFIValue, RBoxError> {
-        let mut output = RVec::with_capacity(self.len());
-
-        for value in self {
-            output.push(ffi_try!(value.into_ffi_val()));
-        }
-
-        RResult::ROk(FFIValue::Vector(output))
-    }
-}
-
-impl IntoFFIVal for RResult<FFIValue, RBoxError> {
-    fn into_ffi_val(self) -> RResult<FFIValue, RBoxError> {
-        self
-    }
-}
-
-// Implementing FFI value conversion layers...
-impl<RET: IntoFFIVal, SELF: AsRefFFIVal, FN: Fn(&SELF) -> RET + SendSyncStatic>
-    RegisterFFIFn<FN, WrapperRef<(SELF,)>, RET> for FFIModule
-{
-    fn register_fn(&mut self, name: &str, func: FN) -> &mut Self {
-        let f = move |args: RVec<FFIValue>| -> RResult<FFIValue, RBoxError> {
-            if args.len() != 1 {
-                let error: Box<dyn std::error::Error + Send + Sync> = "arity mismatch".into();
-
-                let rbox = RBoxError::from_box(error);
-
-                return RResult::RErr(rbox);
-            }
-
-            let mut arg_iter = args.into_iter();
-            let rarg1 = arg_iter.next().unwrap();
-            let mut nursery = <SELF::Nursery>::default();
-
-            let arg1 = ffi_try!(<SELF>::as_ref(&rarg1, &mut nursery));
-
-            let res = func(&arg1);
-
-            res.into_ffi_val()
-        };
-
-        self.register_value(
-            name,
-            FFIValue::BoxedFunction(FFIBoxedDynFunction {
-                name: RString::from(name),
-                arity: 0,
-                function: Arc::new(f),
-            }),
-        );
-
-        self
-    }
-}
-
-macro_rules! impl_register_fn_ffi {
-    ($arg_count:expr => $($param:ident: $idx:expr),*) => {
-        impl<
-            $($param: FromFFIVal,)*
-            FN: Fn($($param),*) -> RET + SendSyncStatic,
-            RET: IntoFFIVal
-        > RegisterFFIFn<FN, Wrapper<($($param,)*)>, RET> for FFIModule {
-            fn register_fn(&mut self, name: &str, func: FN) -> &mut Self {
-                let f = move |args: RVec<FFIValue>| -> RResult<FFIValue, RBoxError> {
-                    if args.len() != $arg_count {
-                        let error: Box<dyn std::error::Error + Send + Sync> = "arity mismatch".into();
-
-                        let rbox = RBoxError::from_box(error);
-
-                        return RResult::RErr(rbox);
-                    }
-
-                    let mut arg_iter = args.into_iter();
-                    let res = func($(ffi_try!(<$param>::from_ffi_val(arg_iter.next().unwrap())),)*);
-
-                    // let res = func($({
-                    //     ffi_try!(<$param>::from_ffi_val());
-                    // },)*);
-
-                    res.into_ffi_val()
-                };
-
-                self.register_value(
-                    name,
-                    FFIValue::BoxedFunction(FFIBoxedDynFunction {
-                        name: RString::from(name),
-                        arity: 0,
-                        function: Arc::new(f),
-                    }),
-                );
-
-                self
-            }
-        }
-
-
-        impl<RET: IntoFFIVal, SELF: AsRefFFIVal, $($param: FromFFIVal,)* FN: Fn(&mut SELF, $($param),*) -> RET + SendSyncStatic>
-            RegisterFFIFn<FN, WrapperMutRef<(SELF, $($param,)*)>, RET> for FFIModule
-        {
-            fn register_fn(&mut self, name: &str, func: FN) -> &mut Self {
-                let f = move |args: RVec<FFIValue>| -> RResult<FFIValue, RBoxError> {
-                    if  args.len() != $arg_count + 1 {
-                        let error: Box<dyn std::error::Error + Send + Sync> = "arity mismatch".into();
-
-                        let rbox = RBoxError::from_box(error);
-
-                        return RResult::RErr(rbox);
-                    }
-
-                    let mut arg_iter = args.into_iter();
-                    let rarg1 = arg_iter.next().unwrap();
-
-                    let mut arg1 = ffi_try!(<SELF>::as_mut_ref(&rarg1));
-
-                    let res = func(&mut arg1, $(ffi_try!(<$param>::from_ffi_val(arg_iter.next().unwrap())),)*);
-
-                    res.into_ffi_val()
-                };
-
-                self.register_value(
-                    name,
-                    FFIValue::BoxedFunction(FFIBoxedDynFunction {
-                        name: RString::from(name),
-                        arity: 0,
-                        function: Arc::new(f),
-                    }),
-                );
-
-                self
-            }
-        }
-    }
-}
-
-impl_register_fn_ffi!(1 => A:0);
-impl_register_fn_ffi!(2 => A:0, B:1);
-impl_register_fn_ffi!(3 => A:0, B:1, C:2);
-impl_register_fn_ffi!(4 => A:0, B:1, C:2, D:3);
-impl_register_fn_ffi!(5 => A:0, B:1, C:2, D:3, E:4);
-impl_register_fn_ffi!(6 => A:0, B:1, C:2, D:3, E:4, F:5);
-impl_register_fn_ffi!(7 => A:0, B:1, C:2, D:3, E:4, F:5, G:6);
-impl_register_fn_ffi!(8 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7);
-impl_register_fn_ffi!(9 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8);
-impl_register_fn_ffi!(10 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9);
-impl_register_fn_ffi!(11 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10);
-impl_register_fn_ffi!(12 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11);
-impl_register_fn_ffi!(13 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12);
-impl_register_fn_ffi!(14 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 13);
-impl_register_fn_ffi!(15 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 13, O: 14);
-impl_register_fn_ffi!(16 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 14, O: 14, P: 15);
-
-// Looks like we can dispatch on the &mut SELF vs &SELF if the Wrapper type is different!
-impl<RET: IntoFFIVal, SELF: AsRefFFIVal, FN: Fn(&mut SELF) -> RET + SendSyncStatic>
-    RegisterFFIFn<FN, WrapperMut<(SELF,)>, RET> for FFIModule
-{
-    fn register_fn(&mut self, name: &str, func: FN) -> &mut Self {
-        let f = move |args: RVec<FFIValue>| -> RResult<FFIValue, RBoxError> {
-            if args.len() != 1 {
-                let error: Box<dyn std::error::Error + Send + Sync> = "arity mismatch".into();
-
-                let rbox = RBoxError::from_box(error);
-
-                return RResult::RErr(rbox);
-            }
-
-            let mut arg_iter = args.into_iter();
-            let rarg1 = arg_iter.next().unwrap();
-
-            let mut arg1 = ffi_try!(<SELF>::as_mut_ref(&rarg1));
-
-            let res = func(&mut arg1);
-
-            res.into_ffi_val()
-        };
-
-        self.register_value(
-            name,
-            FFIValue::BoxedFunction(FFIBoxedDynFunction {
-                name: RString::from(name),
-                arity: 0,
-                function: Arc::new(f),
-            }),
-        );
-
-        self
-    }
-}
-
-// Implementing FFI value conversion layers...
-impl<RET: IntoFFIVal, FN: Fn() -> RET + SendSyncStatic> RegisterFFIFn<FN, Wrapper<()>, RET>
-    for FFIModule
-{
-    fn register_fn(&mut self, name: &str, func: FN) -> &mut Self {
-        let f = move |args: RVec<FFIValue>| -> RResult<FFIValue, RBoxError> {
-            if !args.is_empty() {
-                let error: Box<dyn std::error::Error + Send + Sync> = "arity mismatch".into();
-
-                let rbox = RBoxError::from_box(error);
-
-                return RResult::RErr(rbox);
-            }
-
-            let res = func();
-
-            res.into_ffi_val()
-        };
-
-        self.register_value(
-            name,
-            FFIValue::BoxedFunction(FFIBoxedDynFunction {
-                name: RString::from(name),
-                arity: 0,
-                function: Arc::new(f),
-            }),
-        );
-
-        self
-    }
-}
-
-pub use abi_stable::std_types::RBox;
-pub use abi_stable::{export_root_module, prefix_type::PrefixTypeTrait, sabi_extern_fn};
-
-use super::builtin::BuiltInModule;
-
-#[macro_export]
-macro_rules! declare_module {
-    ($module_function:expr) => {
-        #[::steel::steel_vm::ffi::export_root_module]
-        pub fn get_library() -> ::steel::steel_vm::dylib::GenerateModule_Ref {
-            use ::steel::steel_vm::ffi::PrefixTypeTrait;
-            ::steel::steel_vm::dylib::GenerateModule { generate_module }.leak_into_prefix()
-        }
-
-        #[::steel::steel_vm::ffi::sabi_extern_fn]
-        fn generate_module() -> ::steel::steel_vm::ffi::RBox<FFIModule> {
-            ::steel::steel_vm::ffi::RBox::new($module_function())
-        }
-    };
-}
-
-/// Values that are safe to cross the FFI Boundary.
-#[repr(C)]
-#[derive(StableAbi)]
-pub enum FFIValue {
-    BoxedFunction(FFIBoxedDynFunction),
-    BoolV(bool),
-    NumV(f64),
-    IntV(isize),
-    Void,
-    StringV(RString),
-    Vector(RVec<FFIValue>),
-
-    CharV {
-        #[sabi(unsafe_opaque_field)]
-        c: char,
-    },
-    // TODO: This is super dangerous, BUT it could work... restricting CustomType to have
-    // the StableAbi is a bit of a deal breaker in terms of its application. With certain restrictions on the
-    // generation of dylibs, this might be totally fine.
-    Custom {
-        #[sabi(unsafe_opaque_field)]
-        custom: OpaqueFFIValue,
-    },
-    HashMap(RHashMap<FFIValue, FFIValue>),
-    Future {
-        #[sabi(unsafe_opaque_field)]
-        fut: FfiFuture<RResult<FFIValue, RBoxError>>,
-    }, // Future(Pin<RBox<dyn Future<Output = RResult<FFIValue, RBoxError>>>>),
-}
-
-impl std::hash::Hash for FFIValue {
-    fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {
-        todo!()
-    }
-}
-
-impl PartialEq for FFIValue {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::NumV(l), Self::NumV(r)) => l == r,
-            (Self::BoolV(l), Self::BoolV(r)) => l == r,
-            (Self::IntV(l), Self::IntV(r)) => l == r,
-            (Self::StringV(l), Self::StringV(r)) => l == r,
-            (Self::CharV { c: l }, Self::CharV { c: r }) => l == r,
-            (Self::Void, Self::Void) => true,
-            (Self::Vector(l), Self::Vector(r)) => l == r,
-            (Self::HashMap(l), Self::HashMap(r)) => l == r,
-            (_, _) => false,
-        }
-    }
-}
-
-impl Eq for FFIValue {}
-
-impl std::fmt::Debug for FFIValue {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            FFIValue::BoxedFunction(func) => write!(f, "{:?}", func),
-            FFIValue::Custom { .. } => write!(f, "#<OpaqueFFIValue>"),
-            FFIValue::BoolV(b) => write!(f, "{:?}", b),
-            FFIValue::NumV(n) => write!(f, "{:?}", n),
-            FFIValue::IntV(i) => write!(f, "{:?}", i),
-            FFIValue::CharV { c } => write!(f, "{}", c),
-            FFIValue::Void => write!(f, "#<void>"),
-            FFIValue::StringV(s) => write!(f, "{}", s),
-            FFIValue::Vector(v) => write!(f, "{:?}", v),
-            FFIValue::HashMap(h) => write!(f, "{:?}", h),
-            FFIValue::Future { .. } => write!(f, "#<future>"),
-        }
-    }
-}
-
-impl FFIValue {
-    pub fn as_steelval(&self) -> Result<SteelVal> {
-        match self {
-            Self::BoxedFunction(b) => {
-                Ok(SteelVal::BoxedFunction(Rc::new(b.as_boxed_dyn_function())))
-            }
-            Self::BoolV(b) => Ok(SteelVal::BoolV(*b)),
-            Self::NumV(n) => Ok(SteelVal::NumV(*n)),
-            Self::IntV(i) => Ok(SteelVal::IntV(*i)),
-            Self::CharV { c } => Ok(SteelVal::CharV(*c)),
-            Self::Void => Ok(SteelVal::Void),
-            // TODO: I think this might clone the string, its also a little suspect
-            Self::StringV(s) => Ok(SteelVal::StringV(s.to_string().into())),
-            Self::Vector(v) => v
-                .into_iter()
-                .map(|x| x.as_steelval())
-                .collect::<Result<_>>()
-                .map(SteelVal::ListV),
-
-            Self::HashMap(h) => h
-                .into_iter()
-                .map(|kv| {
-                    let k = kv.0;
-                    let v = kv.1;
-
-                    let k = k.as_steelval()?;
-                    let v = v.as_steelval()?;
-
-                    Ok((k, v))
-                })
-                .collect::<Result<im_rc::HashMap<_, _>>>()
-                .map(Gc::new)
-                .map(SteelHashMap::from)
-                .map(SteelVal::HashMapV),
-            // FFIValue::Future { fut } => Ok(SteelVal::FutureV(Gc::new(Sharedfut.map(|x| {
-            //     match x {
-            //         RResult::ROk(v) => {
-            //             v.
-            //         }
-            //         RResult::RErr(_) => {
-            //             todo!()
-            //         }
-            //     }
-            // })))
-            _v => {
-                todo!("Missing enum variant not accounted for during FFIValue -> SteelVal conversion!")
-            }
-        }
-    }
-}
-
-impl IntoSteelVal for FFIValue {
-    fn into_steelval(self) -> Result<SteelVal> {
-        match self {
-            Self::BoxedFunction(b) => Ok(SteelVal::BoxedFunction(Rc::new(b.into()))),
-            Self::Custom { custom } => {
-                Ok(SteelVal::Custom(Gc::new(RefCell::new(Box::new(custom)))))
-            }
-            Self::BoolV(b) => Ok(SteelVal::BoolV(b)),
-            Self::NumV(n) => Ok(SteelVal::NumV(n)),
-            Self::IntV(i) => Ok(SteelVal::IntV(i)),
-            Self::CharV { c } => Ok(SteelVal::CharV(c)),
-            Self::Void => Ok(SteelVal::Void),
-            // TODO: I think this might clone the string, its also a little suspect
-            Self::StringV(s) => Ok(SteelVal::StringV(s.into_string().into())),
-            Self::Vector(v) => v
-                .into_iter()
-                .map(|x| x.into_steelval())
-                .collect::<Result<_>>()
-                .map(SteelVal::ListV),
-
-            Self::HashMap(h) => h
-                .into_iter()
-                .map(|kv| {
-                    let k = kv.0;
-                    let v = kv.1;
-
-                    let k = k.into_steelval()?;
-                    let v = v.into_steelval()?;
-
-                    Ok((k, v))
-                })
-                .collect::<Result<im_rc::HashMap<_, _>>>()
-                .map(Gc::new)
-                .map(SteelHashMap::from)
-                .map(SteelVal::HashMapV),
-
-            // Attempt to move this across the FFI Boundary... We'll see how successful it is.
-            FFIValue::Future { fut } => Ok(SteelVal::FutureV(Gc::new(FutureResult::new(
-                Box::pin(async {
-                    fut.map(|x| match x {
-                        RResult::ROk(v) => v.into_steelval(),
-                        RResult::RErr(e) => Err(SteelErr::new(ErrorKind::Generic, e.to_string())),
-                    })
-                    .await
-                }),
-            )))),
-        }
-    }
-}
-
-#[repr(C)]
-#[derive(StableAbi, Clone)]
-pub struct FFIBoxedDynFunction {
-    pub name: RString,
-    pub arity: usize,
-    // TODO: See if theres a better option here
-    #[sabi(unsafe_opaque_field)]
-    pub function:
-        Arc<dyn Fn(RVec<FFIValue>) -> RResult<FFIValue, RBoxError> + Send + Sync + 'static>,
-}
-
-impl std::fmt::Debug for FFIBoxedDynFunction {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "#<{}:{}:{:p}>", self.name, self.arity, self.function)
-    }
-}
-
-pub fn as_ffi_value(value: &SteelVal) -> Result<FFIValue> {
-    match value {
-        SteelVal::BoolV(b) => Ok(FFIValue::BoolV(*b)),
-        SteelVal::IntV(i) => Ok(FFIValue::IntV(*i)),
-        SteelVal::NumV(n) => Ok(FFIValue::NumV(*n)),
-        SteelVal::CharV(c) => Ok(FFIValue::CharV { c: *c }),
-        SteelVal::Void => Ok(FFIValue::Void),
-        // We can really only look at values that were made from the FFI boundary.
-        SteelVal::Custom(c) => {
-            if let Some(c) = as_underlying_type::<OpaqueFFIValue>(c.borrow().as_ref()) {
-                Ok(FFIValue::Custom { custom: c.clone() })
-            } else {
-                stop!(TypeMismatch => "This opaque type did not originate from an FFI boundary, and thus cannot be passed across it: {:?}", value);
-            }
-        }
-        SteelVal::HashMapV(h) => h
-            .iter()
-            .map(|(key, value)| {
-                let key = as_ffi_value(key)?;
-                let value = as_ffi_value(value)?;
-
-                Ok((key, value))
-            })
-            .collect::<Result<_>>()
-            .map(FFIValue::HashMap),
-        SteelVal::ListV(l) => l
-            .into_iter()
-            .map(as_ffi_value)
-            .collect::<Result<_>>()
-            .map(FFIValue::Vector),
-
-        SteelVal::StringV(s) => Ok(FFIValue::StringV(s.as_str().into())),
-
-        _ => {
-            stop!(TypeMismatch => "Cannot proceed with the conversion from steelval to FFI Value. This will only succeed for a subset of values deemed as FFI-safe-enough: {:?}", value)
-        }
-    }
-}
-
-impl FFIBoxedDynFunction {
-    fn as_boxed_dyn_function(&self) -> BoxedDynFunction {
-        let name = self.name.to_string();
-
-        let cloned_function = Arc::clone(&self.function);
-
-        let function = move |args: &[SteelVal]| -> crate::rvals::Result<SteelVal> {
-            // Convert the arguments to the FFI types before passing through
-            let args = args
-                .into_iter()
-                .map(as_ffi_value)
-                .collect::<Result<RVec<_>>>()?;
-
-            // Don't use RSlice - use a vec, so that we can consume the values (don't have to clone)
-            let result = (cloned_function)(args);
-
-            match result {
-                RResult::ROk(output) => output.into_steelval(),
-                RResult::RErr(e) => Err(SteelErr::new(ErrorKind::Generic, e.to_string())),
-            }
-        };
-
-        BoxedDynFunction {
-            name: Some(StaticOrRcStr::Owned(Arc::new(name))),
-            arity: Some(self.arity),
-            function: Arc::new(function),
-        }
-    }
-}
-
-// Wrap the function that we get from FFI into another instance.
-impl From<FFIBoxedDynFunction> for BoxedDynFunction {
-    fn from(value: FFIBoxedDynFunction) -> Self {
-        let name = value.name.into_string();
-
-        let function = move |args: &[SteelVal]| -> crate::rvals::Result<SteelVal> {
-            // Convert the arguments to the FFI types before passing through
-            let args = args
-                .into_iter()
-                .map(as_ffi_value)
-                .collect::<Result<RVec<_>>>()?;
-
-            let result = (value.function)(args);
-
-            match result {
-                RResult::ROk(output) => output.into_steelval(),
-                RResult::RErr(e) => Err(SteelErr::new(ErrorKind::Generic, e.to_string())),
-            }
-        };
-
-        BoxedDynFunction {
-            name: Some(StaticOrRcStr::Owned(Arc::new(name))),
-            arity: Some(value.arity),
-            function: Arc::new(function),
-        }
-    }
-}
-
-thread_local! {
-    pub static FFI_MODULES: Arc<Mutex<Vec<RBox<FFIModule>>>> = Arc::new(Mutex::new(Vec::new()));
-}
-
-pub struct FFIWrappedModule {
-    raw_module: RBox<FFIModule>,
-    converted_module: BuiltInModule,
-}
-
-impl FFIWrappedModule {
-    pub fn new(raw_module: RBox<FFIModule>) -> Result<Self> {
-        let mut converted_module = BuiltInModule::new((&raw_module.name).to_string());
-
-        for tuple in raw_module.values.iter() {
-            let key = tuple.0;
-            let value = tuple.1;
-
-            converted_module.register_value(&key, value.as_steelval()?);
-        }
-
-        Ok(Self {
-            raw_module,
-            converted_module,
-        })
-    }
-
-    pub fn build(self) -> BuiltInModule {
-        // Extend the lifetime of this
-        FFI_MODULES.with(|x| x.lock().unwrap().push(self.raw_module));
-
-        self.converted_module
-    }
-}
-
-#[repr(C)]
-#[derive(Clone, Debug, StableAbi)]
-pub struct FFIInternalDocumentation {
-    definitions: RHashMap<RCowStr<'static>, FFIDocumentation<'static>>,
-}
-
-impl FFIInternalDocumentation {
-    pub fn new() -> Self {
-        Self {
-            definitions: RHashMap::new(),
-        }
-    }
-
-    pub fn register_doc(
-        &mut self,
-        definition: impl Into<RCowStr<'static>>,
-        description: FFIDocumentation<'static>,
-    ) {
-        self.definitions.insert(definition.into(), description);
-    }
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, PartialEq, StableAbi)]
-pub enum FFIDocumentation<'a> {
-    Function(FFIDocTemplate<'a>),
-    Module(FFIModuleDoc<'a>),
-    Value(FFIValueDoc<'a>),
-    Markdown(FFIMarkdownDoc<'a>),
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, PartialEq, StableAbi)]
-pub struct FFIDocTemplate<'a> {
-    pub signature: RStr<'a>,
-    pub params: RSlice<'a, RStr<'a>>,
-    pub description: RStr<'a>,
-    pub examples: RSlice<'a, Tuple2<RStr<'a>, RStr<'a>>>,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, PartialEq, StableAbi)]
-pub struct FFIModuleDoc<'a> {
-    pub name: RStr<'a>,
-    pub description: RStr<'a>,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, PartialEq, StableAbi)]
-pub struct FFIValueDoc<'a> {
-    pub name: RStr<'a>,
-    pub description: RStr<'a>,
-}
-
-#[repr(C)]
-#[derive(Debug, Clone, PartialEq, StableAbi)]
-pub struct FFIMarkdownDoc<'a>(pub RStr<'a>);
-
-impl<'a> From<FFIDocTemplate<'a>> for FFIDocumentation<'a> {
-    fn from(val: FFIDocTemplate<'a>) -> Self {
-        FFIDocumentation::Function(val)
-    }
-}
-
-impl<'a> From<FFIModuleDoc<'a>> for FFIDocumentation<'a> {
-    fn from(val: FFIModuleDoc<'a>) -> Self {
-        FFIDocumentation::Module(val)
-    }
-}
-
-impl<'a> From<FFIValueDoc<'a>> for FFIDocumentation<'a> {
-    fn from(val: FFIValueDoc<'a>) -> Self {
-        FFIDocumentation::Value(val)
-    }
-}
-
-impl<'a> From<FFIMarkdownDoc<'a>> for FFIDocumentation<'a> {
-    fn from(val: FFIMarkdownDoc<'a>) -> Self {
-        FFIDocumentation::Markdown(val)
-    }
-}
diff --git a/crates/steel-core/src/steel_vm/lazy_stream.rs b/crates/steel-core/src/steel_vm/lazy_stream.rs
deleted file mode 100644
index 199532873..000000000
--- a/crates/steel-core/src/steel_vm/lazy_stream.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-use super::vm::VmCore;
-use crate::parser::span::Span;
-use crate::rvals::{Result, SteelVal};
-use std::cell::RefCell;
-use std::rc::Rc;
-
-use crate::values::lazy_stream::LazyStream;
-
-// Used for inlining stream iterators
-pub(crate) struct LazyStreamIter<'global, 'a> {
-    stream: LazyStream,
-    vm_ctx: Rc<RefCell<&'global mut VmCore<'a>>>,
-    cur_inst_span: &'global Span,
-}
-
-impl<'global, 'a> LazyStreamIter<'global, 'a> {
-    pub fn new(
-        stream: LazyStream,
-        vm_ctx: Rc<RefCell<&'global mut VmCore<'a>>>,
-        cur_inst_span: &'global Span,
-    ) -> Self {
-        Self {
-            stream,
-            vm_ctx,
-            cur_inst_span,
-        }
-    }
-}
-
-impl<'global, 'a> Iterator for LazyStreamIter<'global, 'a> {
-    type Item = Result<SteelVal>;
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.stream.empty_stream {
-            return None;
-        }
-
-        let stream_first = self.stream.stream_first();
-        let stream_thunk = self.stream.stream_thunk();
-
-        let next_value = self.vm_ctx.borrow_mut().call_func_or_else_many_args(
-            &stream_thunk,
-            Vec::new(),
-            self.cur_inst_span,
-            throw!(TypeMismatch => format!("stream expected a thunk, found: {stream_thunk}")),
-        );
-
-        if let Ok(next_value) = next_value {
-            if let SteelVal::StreamV(lazy_stream) = next_value {
-                self.stream = lazy_stream.unwrap();
-            } else {
-                panic!("Lazy stream not implemented for the given type");
-            }
-        }
-
-        Some(Ok(stream_first))
-    }
-}
-
-#[cfg(test)]
-mod stream_tests {
-    use crate::steel_vm::test_util::assert_script;
-
-    #[test]
-    fn simple_stream() {
-        let script = r#"
-        (define (stream-cdr stream)
-            ((#%stream-cdr stream)))
-
-        (define (integers n)
-            (stream-cons n (lambda () (integers (+ 1 n)))))
-
-        (define (stream-section n stream)
-            (cond ((= n 0) '())
-                  (else
-                   (cons
-                    (stream-car stream)
-                    (stream-section
-                     (- n 1)
-                     (stream-cdr stream))))))
-
-        (assert! (equal? (list 0 1 2 3 4) (stream-section 5 (integers 0))))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn simple_stream_with_map() {
-        let script = r#"
-        (define (stream-cdr stream)
-            ((#%stream-cdr stream)))
-
-        (define (integers n)
-            (stream-cons n (lambda () (integers (+ 1 n)))))
-
-        (define (stream-section n stream)
-            (cond ((= n 0) '())
-                  (else
-                   (cons
-                    (stream-car stream)
-                    (stream-section
-                     (- n 1)
-                     (stream-cdr stream))))))
-
-        (define (map-stream func s)
-            (cond
-                [(stream-empty? s) s]
-                [else
-                    (stream-cons (func (stream-car s))
-                                    (lambda ()
-                                    (map-stream func (stream-cdr s))))]))
-
-        (assert! 
-            (equal? (list 10 10 10 10 10)
-                    (stream-section 5 (map-stream (lambda (x) 10) (integers 0)))))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn simple_stream_with_transducer() {
-        let script = r#"
-        (define (stream-cdr stream)
-            ((#%stream-cdr stream)))
-
-        (define (integers n)
-            (stream-cons n (lambda () (integers (+ 1 n)))))
-
-        (assert! 
-            (equal? (list 0 1 2 3 4)
-                    (transduce (integers 0) (taking 5) (into-list))))
-        "#;
-        assert_script(script);
-    }
-}
diff --git a/crates/steel-core/src/steel_vm/meta.rs b/crates/steel-core/src/steel_vm/meta.rs
deleted file mode 100644
index 6d05d4d22..000000000
--- a/crates/steel-core/src/steel_vm/meta.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-#![allow(unused)]
-
-// pub type BuiltInSignature = fn(Vec<SteelVal>, &mut dyn VmContext) -> Result<SteelVal>;`
-
-use std::{cell::RefCell, convert::TryFrom, io::Write, rc::Rc};
-
-use crate::parser::tryfrom_visitor::TryFromExprKindForSteelVal;
-// use im_lists::list::List;
-use crate::values::lists::List;
-
-use crate::values::port::SteelPortRepr;
-use crate::values::structs::SteelResult;
-use crate::{
-    parser::ast::ExprKind,
-    rvals::Custom,
-    values::port::{SteelPort, CAPTURED_OUTPUT_PORT, DEFAULT_OUTPUT_PORT},
-    SteelErr, SteelVal,
-};
-use crate::{parser::expander::LocalMacroManager, rvals::Result};
-use crate::{parser::parser::ParseError, steel_vm::engine::Engine};
-
-use crate::stop;
-
-#[derive(Clone)]
-pub(crate) struct EngineWrapper(Engine);
-
-impl EngineWrapper {
-    pub(crate) fn new() -> Self {
-        EngineWrapper(Engine::new())
-    }
-
-    pub(crate) fn deep_copy(self) -> Self {
-        self
-    }
-
-    pub(crate) fn add_module(&mut self, path: String) -> Result<()> {
-        self.0.add_module(path)?;
-        Ok(())
-    }
-
-    pub(crate) fn raise_error(&self, error: SteelErr) {
-        self.0.raise_error(error)
-    }
-
-    //
-    pub(crate) fn modules(&self) -> Vec<String> {
-        self.0
-            .modules()
-            .iter()
-            .map(|x| x.0.to_str().unwrap().to_string())
-            .collect()
-    }
-
-    // TODO: Warning, here be dragons
-    pub(crate) fn call_fn(&mut self, function_name: SteelVal, args: SteelVal) -> Result<SteelVal> {
-        let function = match function_name {
-            SteelVal::SymbolV(expr) | SteelVal::StringV(expr) => {
-                self.0.extract_value(expr.as_ref())?
-            }
-            _ => {
-                stop!(TypeMismatch => "get-value expected either a string or a symbol, found: {}", function_name)
-            }
-        };
-
-        if let SteelVal::ListV(list) = args {
-            let arguments = list.into_iter().collect();
-
-            println!("Calling with arguments: {arguments:?}");
-
-            self.0.call_function_with_args(function, arguments)
-        } else {
-            stop!(TypeMismatch => "call-function-in-env expects a list for the arguments")
-        }
-    }
-
-    fn call_impl(&mut self, expr: SteelVal) -> Result<List<SteelVal>> {
-        match expr {
-            SteelVal::StringV(expr) => self
-                .0
-                .compile_and_run_raw_program(expr.as_ref())
-                .map(|x| x.into()),
-            SteelVal::ListV(list) => {
-                let values = list
-                    .iter()
-                    .map(|x| x.to_string())
-                    .map(|x| {
-                        self.0
-                            .compile_and_run_raw_program(x.trim_start_matches('\''))
-                    })
-                    .collect::<Result<Vec<Vec<SteelVal>>>>();
-
-                Ok(values?.into_iter().flatten().collect::<List<_>>())
-            }
-            _ => {
-                stop!(TypeMismatch => "run! expects either a list of expressions, or a string")
-            }
-        }
-    }
-
-    pub(crate) fn call(&mut self, expr: SteelVal) -> SteelResult<List<SteelVal>, SteelErr> {
-        self.call_impl(expr).into()
-    }
-
-    // TODO: Warning, here be dragons
-    pub(crate) fn get_value(&self, expr: SteelVal) -> Result<SteelVal> {
-        match expr {
-            SteelVal::SymbolV(expr) | SteelVal::StringV(expr) => {
-                self.0.extract_value(expr.as_ref())
-            }
-            _ => {
-                stop!(TypeMismatch => "get-value expected either a string or a symbol, found: {}", expr)
-            }
-        }
-    }
-}
-
-impl Custom for EngineWrapper {}
-
-impl std::fmt::Debug for EngineWrapper {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "SteelEngine")
-    }
-}
-
-// TODO: move this to an iterator utils class
-pub fn separate_by<T, F: Fn(&T) -> bool>(
-    iter: impl IntoIterator<Item = T>,
-    pred: F,
-) -> (Vec<T>, Vec<T>) {
-    let mut left = Vec::new();
-    let mut right = Vec::new();
-
-    for item in iter {
-        if pred(&item) {
-            left.push(item)
-        } else {
-            right.push(item)
-        }
-    }
-
-    (left, right)
-}
-
-pub fn read(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 1 {
-        stop!(ArityMismatch => "read expects a string as its sole argument")
-    }
-
-    assert!(args.len() == 1);
-
-    args[0]
-        .string_or_else(throw!(TypeMismatch => "read expects a string"))
-        .map(crate::parser::parser::Parser::parse_without_lowering)??
-        .into_iter()
-        .map(TryFromExprKindForSteelVal::try_from_expr_kind)
-        .collect::<Result<List<_>>>()
-        .map(SteelVal::ListV)
-}
-
-// Takes in a quoted list, put it back to a raw string representation, re-parse it
-// back as a typed ast, parse and expand macros, re-emit it _back_ as a list of symbols
-pub fn expand_macros(arguments: &[SteelVal]) -> Result<SteelVal> {
-    if arguments.len() != 1 {
-        stop!(ArityMismatch => "expand! expects a list of quoted expressions as its sole argument")
-    }
-
-    assert!(arguments.len() == 1);
-
-    // This should be the '( expressions ... )
-    // This should also expand the reader macros as well
-    let parsed = arguments[0]
-        .list_or_else(throw!(TypeMismatch =>  "expand! expected a list in the first position"))?
-        .iter()
-        .map(|x| x.to_string())
-        // Here we might need to trim the start of the string representation
-        // In order to be actually parsable - might be worth doing ExprKind::try_from
-        // instead of writing to a string and reparsing directly...
-        .map(|x| crate::parser::parser::Parser::parse(x.trim_start_matches('\'')))
-        .collect::<std::result::Result<Vec<Vec<_>>, ParseError>>()?;
-
-    // Separate by define-syntax
-    let (macros, non_macros) = separate_by(parsed.into_iter().flatten(), |x| {
-        matches!(x, ExprKind::Macro(_))
-    });
-
-    let macro_manager = LocalMacroManager::from_exprs(macros)?;
-
-    // Expand the macros, convert them back to a consumable expression
-    macro_manager
-        .expand(non_macros)?
-        .into_iter()
-        .map(SteelVal::try_from)
-        .collect::<Result<List<_>>>()
-        .map(SteelVal::ListV)
-}
-
-fn drain_custom_output_port() -> String {
-    CAPTURED_OUTPUT_PORT.with(|x| {
-        // Flush the buffer
-        {
-            x.borrow_mut()
-                .flush()
-                .expect("Unable to flush the captured output port");
-        }
-
-        std::str::from_utf8(&x.borrow_mut().get_mut().drain(0..).collect::<Vec<u8>>())
-            .unwrap_or("Unable to capture std out")
-            .to_string()
-    })
-}
-
-pub fn value_to_string(value: SteelVal) -> String {
-    format!("{value:?}")
-}
-
-/// Eval with a completely fresh environment
-/// Returns:
-/// (list
-///     <results list>
-///     <captured std out as a string>
-///     <error as a string if any>)
-pub fn eval(program: String) -> List<SteelVal> {
-    // if arguments.len() != 1 {
-    //     stop!(ArityMismatch => "eval! expects a list of quoted expressions as its sole argument")
-    // }
-
-    // assert!(arguments.len() == 1);
-
-    let mut engine = Engine::new_sandboxed();
-
-    // let existing_output_port = DEFAULT_OUTPUT_PORT.with(|x| x.clone());
-
-    // Override the default output port to capture things getting written to standard out
-    // DEFAULT_OUTPUT_PORT.with(|x| {
-    //     *x.borrow_mut() = SteelPort {
-    //         port: Rc::new(RefCell::new(SteelPortRepr::StringOutput(
-    //             CAPTURED_OUTPUT_PORT.with(|x| (*x.borrow()).clone()),
-    //         ))),
-    //     }
-    // });
-
-    // let value = arguments[0]
-    //     .string_or_else(throw!(TypeMismatch =>  "eval! expected a list in the first position"))?;
-    // Here we might need to trim the start of the string representation
-    // In order to be actually parsable - might be worth doing ExprKind::try_from
-    // instead of writing to a string and reparsing directly...
-
-    let res = engine.compile_and_run_raw_program(&program);
-
-    // Set it back to be the usual output port, which in this case is usually just standard out
-    // This way after the evaluation is done, the output port is back to being
-    // This is not great, TODO: @Matt 5/28/2022 take a look at this later
-    // In the event we're stacking up multiple built up output buffers, this could do a whole
-    // lot of cloning. In the common case, its just cloning the handle to std out which seems
-    // fine
-    // DEFAULT_OUTPUT_PORT.with(|x| *x.borrow_mut() = existing_output_port.borrow().clone());
-    // DEFAULT_OUTPUT_PORT.with(|x| *x.borrow_mut() = SteelPort::default_current_output_port());
-
-    match res {
-        Ok(v) => vec![
-            SteelVal::ListV(v.into()),
-            SteelVal::StringV(drain_custom_output_port().into()),
-            SteelVal::StringV("".into()),
-        ]
-        .into(),
-        Err(e) => {
-            let report = e.emit_result_to_string("input.stl", &program);
-
-            vec![
-                SteelVal::ListV(List::new()),
-                SteelVal::StringV(drain_custom_output_port().into()),
-                SteelVal::StringV(report.into()),
-            ]
-            .into()
-
-            // Err(e)
-        }
-    }
-
-    // todo!()
-    // .collect::<Result<Vec<Vec<SteelVal>>>>();
-
-    // let values = arguments[0]
-    //     .list_or_else(throw!(TypeMismatch =>  "eval! expected a list in the first position"))?
-    //     .iter()
-    //     .map(|x| x.to_string())
-    //     // Here we might need to trim the start of the string representation
-    //     // In order to be actually parsable - might be worth doing ExprKind::try_from
-    //     // instead of writing to a string and reparsing directly...
-    //     .map(|x| engine.compile_and_run_raw_program(x.trim_start_matches('\'')))
-    //     .collect::<Result<Vec<Vec<SteelVal>>>>();
-
-    // Ok(values?.into_iter().flatten().collect::<List<_>>().into())
-}
diff --git a/crates/steel-core/src/steel_vm/mod.rs b/crates/steel-core/src/steel_vm/mod.rs
deleted file mode 100644
index b79a93d29..000000000
--- a/crates/steel-core/src/steel_vm/mod.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-pub mod builtin;
-pub mod cache;
-pub(crate) mod const_evaluation;
-pub mod contract_checker;
-#[cfg(feature = "dylibs")]
-pub mod dylib;
-pub mod engine;
-#[cfg(feature = "dylibs")]
-pub mod ffi;
-mod lazy_stream;
-mod meta;
-pub mod primitives;
-pub mod register_fn;
-#[cfg(test)]
-mod test_util;
-#[cfg(test)]
-mod tests;
-pub(crate) mod transducers;
-pub(crate) mod vm;
diff --git a/crates/steel-core/src/steel_vm/primitives.rs b/crates/steel-core/src/steel_vm/primitives.rs
deleted file mode 100644
index e9d8bd94c..000000000
--- a/crates/steel-core/src/steel_vm/primitives.rs
+++ /dev/null
@@ -1,1658 +0,0 @@
-use std::{cell::RefCell, cmp::Ordering};
-
-use super::{
-    builtin::BuiltInModule,
-    cache::WeakMemoizationTable,
-    engine::Engine,
-    register_fn::RegisterFn,
-    vm::{get_test_mode, list_modules, set_test_mode, VmCore},
-};
-use crate::{
-    gc::Gc,
-    parser::{interner::InternedString, span::Span, tryfrom_visitor::TryFromExprKindForSteelVal},
-    primitives::{
-        fs_module,
-        hashmaps::hashmap_module,
-        hashmaps::{HM_CONSTRUCT, HM_GET, HM_INSERT},
-        hashsets::hashset_module,
-        lists::{list_module, UnRecoverableResult},
-        nums::{quotient, SPECIAL_ADD_DEFINITION},
-        port_module,
-        process::process_module,
-        random::random_module,
-        string_module,
-        time::time_module,
-        ControlOperations, IoFunctions, MetaOperations, NumOperations, StreamOperations,
-        SymbolOperations, VectorOperations,
-    },
-    rerrs::ErrorKind,
-    rvals::{
-        as_underlying_type,
-        cycles::{BreadthFirstSearchSteelValVisitor, SteelCycleCollector},
-        FromSteelVal, SteelString, ITERATOR_FINISHED, NUMBER_EQUALITY_DEFINITION,
-    },
-    steel_vm::{
-        builtin::{get_function_name, Arity},
-        vm::threads::threading_module,
-    },
-    values::{
-        closed::HeapRef,
-        functions::{attach_contract_struct, get_contract, LambdaMetadataTable},
-        structs::{build_type_id_module, make_struct_type, SteelResult, UserDefinedStruct},
-    },
-};
-use crate::{
-    rvals::IntoSteelVal,
-    values::structs::{build_option_structs, build_result_structs},
-};
-use crate::{
-    rvals::{Result, SteelVal},
-    SteelErr,
-};
-
-#[cfg(feature = "web")]
-use crate::primitives::web::requests::requests_module;
-
-use crate::values::lists::List;
-use im_rc::HashMap;
-use num::{Signed, ToPrimitive};
-use once_cell::sync::Lazy;
-
-macro_rules! ensure_tonicity_two {
-    ($check_fn:expr) => {{
-        |args: &[SteelVal]| -> Result<SteelVal> {
-
-            if args.is_empty() {
-                stop!(ArityMismatch => "expected at least one argument");
-            }
-
-            for window in args.windows(2) {
-                if let &[left, right] = &window {
-                    if !$check_fn(&left, &right) {
-                        return Ok(SteelVal::BoolV(false))
-                    }
-                } else {
-                    unreachable!()
-                }
-
-            }
-
-            Ok(SteelVal::BoolV(true))
-
-        }
-    }};
-}
-
-macro_rules! gen_pred {
-    ($variant:ident) => {{
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            Ok(if let Some(SteelVal::$variant(..)) = args.first() {
-                SteelVal::BoolV(true)
-            } else {
-                SteelVal::BoolV(false)
-            })
-        })
-    }};
-
-    ($variant1:ident, $variant2:ident) => {{
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if let Some(first) = args.first() {
-                match first {
-                    SteelVal::$variant1(..) | SteelVal::$variant2(..) => {
-                        return Ok(SteelVal::BoolV(true));
-                    }
-                    _ => {}
-                }
-            }
-            Ok(SteelVal::BoolV(false))
-        })
-    }};
-
-    // TODO replace this with something better
-    ($variant1:ident, $variant2:ident, $variant3:ident, $variant4:ident, $variant5:ident, $variant6: ident, $variant7: ident) => {{
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if let Some(first) = args.first() {
-                match first {
-                    SteelVal::$variant1(..)
-                    | SteelVal::$variant2(..)
-                    | SteelVal::$variant3(..)
-                    | SteelVal::$variant4(..)
-                    | SteelVal::$variant5(..)
-                    | SteelVal::$variant6(..)
-                    | SteelVal::$variant7(..) => {
-                        return Ok(SteelVal::BoolV(true));
-                    }
-                    _ => {}
-                }
-            }
-            Ok(SteelVal::BoolV(false))
-        })
-    }};
-
-    ($variant1:ident, $variant2:ident, $variant3:ident, $variant4:ident, $variant5:ident, $variant6:ident) => {{
-        SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-            if let Some(first) = args.first() {
-                match first {
-                    SteelVal::$variant1(..)
-                    | SteelVal::$variant2(..)
-                    | SteelVal::$variant3(..)
-                    | SteelVal::$variant4(..)
-                    | SteelVal::$variant5(..)
-                    | SteelVal::$variant6(..) => {
-                        return Ok(SteelVal::BoolV(true));
-                    }
-                    _ => {}
-                }
-            }
-            Ok(SteelVal::BoolV(false))
-        })
-    }};
-}
-
-const LIST: &str = "list";
-const PRIM_LIST: &str = "#%prim.list";
-const CAR: &str = "car";
-const CDR: &str = "cdr";
-const CONS: &str = "cons";
-const FIRST: &str = "first";
-const REST: &str = "rest";
-const APPEND: &str = "append";
-const PUSH_BACK: &str = "push-back";
-const LENGTH: &str = "length";
-const REVERSE: &str = "reverse";
-// const LIST_TO_VECTOR: &str = "list->vector";
-const LIST_TO_STRING: &str = "list->string";
-const NULL_HUH: &str = "null?";
-const INT_HUH: &str = "int?";
-const INTEGER_HUH: &str = "integer?";
-const FLOAT_HUH: &str = "float?";
-const NUMBER_HUH: &str = "number?";
-const SYMBOL_HUH: &str = "symbol?";
-const VECTOR_HUH: &str = "vector?";
-const STRING_HUH: &str = "string?";
-const LIST_HUH: &str = "list?";
-const BOOLEAN_HUH: &str = "boolean?";
-const FUNCTION_HUH: &str = "function?";
-
-// TODO: Add the equivalent with prim in front
-pub const CONSTANTS: &[&str] = &[
-    "+",
-    "#%prim.+",
-    "i+",
-    "#%prim.i+",
-    "f+",
-    "#%prim.f+",
-    "*",
-    "#%prim.*",
-    "/",
-    "#%prim./",
-    "-",
-    "#%prim.-",
-    CAR,
-    "#%prim.car",
-    CDR,
-    "#%prim.cdr",
-    FIRST,
-    "#%prim.first",
-    REST,
-    "#%prim.rest",
-    // RANGE,
-    // "#%prim.range",
-    NULL_HUH,
-    "#%prim.null?",
-    INT_HUH,
-    "#%prim.int?",
-    FLOAT_HUH,
-    "#%prim.float?",
-    NUMBER_HUH,
-    "#%prim.number?",
-    STRING_HUH,
-    "#%prim.string?",
-    SYMBOL_HUH,
-    "#%prim.symbol?",
-    VECTOR_HUH,
-    "#%prim.vector?",
-    LIST_HUH,
-    "#%prim.list?",
-    INTEGER_HUH,
-    "#%prim.integer?",
-    BOOLEAN_HUH,
-    "#%prim.boolean?",
-    FUNCTION_HUH,
-    "#%prim.function?",
-    "=",
-    "#%prim.=",
-    "equal?",
-    "#%prim.equal?",
-    ">",
-    "#%prim.>",
-    ">=",
-    "#%prim.>=",
-    "<",
-    "#%prim.<",
-    "<=",
-    "#%prim.<=",
-    "string-append",
-    "#%prim.string-append",
-    "string->list",
-    "#%prim.string->list",
-    "string-upcase",
-    "#%prim.string-upcase",
-    "string-lowercase",
-    "#%prim.string-lowercase",
-    "trim",
-    "#%prim.trim",
-    "trim-start",
-    "#%prim.trim-start",
-    "trim-end",
-    "#%prim.trim-end",
-    "split-whitespace",
-    "#%prim.split-whitespace",
-    "void",
-    "#%prim.void",
-    "list->string",
-    "#%prim.list->string",
-    "concat-symbols",
-    "#%prim.concat-symbols",
-    "string->int",
-    "#%prim.string->int",
-    "even?",
-    "#%prim.even?",
-    "odd",
-    CONS,
-    "#%prim.cons",
-    APPEND,
-    "#%prim.append",
-    PUSH_BACK,
-    LENGTH,
-    "#%prim.length",
-    REVERSE,
-    "#%prim.reverse",
-    LIST_TO_STRING,
-    "#%prim.list->string",
-    LIST,
-    PRIM_LIST,
-    "#%prim.not",
-    "not",
-];
-
-thread_local! {
-    pub static MAP_MODULE: BuiltInModule = hashmap_module();
-    pub static SET_MODULE: BuiltInModule = hashset_module();
-    pub static LIST_MODULE: BuiltInModule = list_module();
-    pub static STRING_MODULE: BuiltInModule = string_module();
-    pub static VECTOR_MODULE: BuiltInModule = vector_module();
-    pub static STREAM_MODULE: BuiltInModule = stream_module();
-    // pub static CONTRACT_MODULE: BuiltInModule = contract_module();
-    pub static IDENTITY_MODULE: BuiltInModule = identity_module();
-    pub static NUMBER_MODULE: BuiltInModule = number_module();
-    pub static EQUALITY_MODULE: BuiltInModule = equality_module();
-    pub static ORD_MODULE: BuiltInModule = ord_module();
-    pub static TRANSDUCER_MODULE: BuiltInModule = transducer_module();
-    pub static SYMBOL_MODULE: BuiltInModule = symbol_module();
-    pub static IO_MODULE: BuiltInModule = io_module();
-    pub static FS_MODULE: BuiltInModule = fs_module();
-    pub static PORT_MODULE: BuiltInModule = port_module();
-    pub static META_MODULE: BuiltInModule = meta_module();
-    pub static JSON_MODULE: BuiltInModule = json_module();
-    pub static CONSTANTS_MODULE: BuiltInModule = constants_module();
-    pub static SYNTAX_MODULE: BuiltInModule = syntax_module();
-    pub static SANDBOXED_META_MODULE: BuiltInModule = sandboxed_meta_module();
-    pub static SANDBOXED_IO_MODULE: BuiltInModule = sandboxed_io_module();
-    pub static PROCESS_MODULE: BuiltInModule = process_module();
-    pub static RANDOM_MODULE: BuiltInModule = random_module();
-    pub static RESULT_MODULE: BuiltInModule = build_result_structs();
-    pub static TYPE_ID_MODULE: BuiltInModule = build_type_id_module();
-    pub static OPTION_MODULE: BuiltInModule = build_option_structs();
-    pub static PRELUDE_MODULE: BuiltInModule = prelude();
-    pub static TIME_MODULE: BuiltInModule = time_module();
-    pub static THREADING_MODULE: BuiltInModule = threading_module();
-
-    pub static MUTABLE_HASH_MODULE: BuiltInModule = mutable_hashmap_module();
-    pub static MUTABLE_VECTOR_MODULE: BuiltInModule = mutable_vector_module();
-    pub static PRIVATE_READER_MODULE: BuiltInModule = reader_module();
-
-    #[cfg(feature = "web")]
-    pub static REQUESTS_MODULE: BuiltInModule = requests_module();
-
-    #[cfg(feature = "sqlite")]
-    pub static SQLITE_MODULE: BuiltInModule = crate::primitives::sqlite::sqlite_module();
-}
-
-pub fn prelude() -> BuiltInModule {
-    BuiltInModule::new("steel/base")
-        .with_module(MAP_MODULE.with(|x| x.clone()))
-        .with_module(SET_MODULE.with(|x| x.clone()))
-        .with_module(LIST_MODULE.with(|x| x.clone()))
-        .with_module(STRING_MODULE.with(|x| x.clone()))
-        .with_module(VECTOR_MODULE.with(|x| x.clone()))
-        .with_module(STREAM_MODULE.with(|x| x.clone()))
-        // .with_module(CONTRACT_MODULE.with(|x| x.clone()))
-        .with_module(IDENTITY_MODULE.with(|x| x.clone()))
-        .with_module(NUMBER_MODULE.with(|x| x.clone()))
-        .with_module(EQUALITY_MODULE.with(|x| x.clone()))
-        .with_module(ORD_MODULE.with(|x| x.clone()))
-        .with_module(TRANSDUCER_MODULE.with(|x| x.clone()))
-        .with_module(SYMBOL_MODULE.with(|x| x.clone()))
-        .with_module(IO_MODULE.with(|x| x.clone()))
-        .with_module(FS_MODULE.with(|x| x.clone()))
-        .with_module(PORT_MODULE.with(|x| x.clone()))
-        .with_module(META_MODULE.with(|x| x.clone()))
-        .with_module(JSON_MODULE.with(|x| x.clone()))
-        .with_module(CONSTANTS_MODULE.with(|x| x.clone()))
-        .with_module(SYNTAX_MODULE.with(|x| x.clone()))
-        .with_module(PROCESS_MODULE.with(|x| x.clone()))
-        .with_module(RESULT_MODULE.with(|x| x.clone()))
-        .with_module(OPTION_MODULE.with(|x| x.clone()))
-        .with_module(TYPE_ID_MODULE.with(|x| x.clone()))
-        .with_module(TIME_MODULE.with(|x| x.clone()))
-        .with_module(THREADING_MODULE.with(|x| x.clone()))
-}
-
-pub fn register_builtin_modules_without_io(engine: &mut Engine) {
-    engine.register_fn("##__module-get", BuiltInModule::get);
-    engine.register_fn("%module-get%", BuiltInModule::get);
-
-    engine.register_fn("load-from-module!", BuiltInModule::get);
-
-    engine.register_value("%proto-hash%", HM_CONSTRUCT);
-    engine.register_value("%proto-hash-insert%", HM_INSERT);
-    engine.register_value("%proto-hash-get%", HM_GET);
-    engine.register_value("error!", ControlOperations::error());
-
-    engine.register_value("error", ControlOperations::error());
-
-    engine
-        .register_module(MAP_MODULE.with(|x| x.clone()))
-        .register_module(SET_MODULE.with(|x| x.clone()))
-        .register_module(LIST_MODULE.with(|x| x.clone()))
-        .register_module(STRING_MODULE.with(|x| x.clone()))
-        .register_module(VECTOR_MODULE.with(|x| x.clone()))
-        .register_module(STREAM_MODULE.with(|x| x.clone()))
-        // .register_module(CONTRACT_MODULE.with(|x| x.clone()))
-        .register_module(IDENTITY_MODULE.with(|x| x.clone()))
-        .register_module(NUMBER_MODULE.with(|x| x.clone()))
-        .register_module(EQUALITY_MODULE.with(|x| x.clone()))
-        .register_module(ORD_MODULE.with(|x| x.clone()))
-        .register_module(TRANSDUCER_MODULE.with(|x| x.clone()))
-        .register_module(SYMBOL_MODULE.with(|x| x.clone()))
-        .register_module(SANDBOXED_IO_MODULE.with(|x| x.clone()))
-        // .register_module(FS_MODULE.with(|x| x.clone()))
-        // .register_module(PORT_MODULE.with(|x| x.clone()))
-        .register_module(SANDBOXED_META_MODULE.with(|x| x.clone()))
-        .register_module(JSON_MODULE.with(|x| x.clone()))
-        .register_module(CONSTANTS_MODULE.with(|x| x.clone()))
-        .register_module(SYNTAX_MODULE.with(|x| x.clone()))
-        .register_module(PRELUDE_MODULE.with(|x| x.clone()));
-}
-
-fn render_as_md(text: String) {
-    #[cfg(feature = "markdown")]
-    println!("{}", termimad::text(&text));
-
-    #[cfg(not(feature = "markdown"))]
-    println!("{}", text);
-}
-
-pub fn register_builtin_modules(engine: &mut Engine) {
-    engine.register_value("std::env::args", SteelVal::ListV(List::new()));
-
-    engine.register_fn("##__module-get", BuiltInModule::get);
-    engine.register_fn("%module-get%", BuiltInModule::get);
-
-    engine.register_fn("load-from-module!", BuiltInModule::get);
-
-    // Registering values in modules
-    engine.register_fn("#%module", BuiltInModule::new::<String>);
-    engine.register_fn(
-        "#%module-add",
-        |module: &mut BuiltInModule, name: SteelString, value: SteelVal| {
-            module.register_value(&name, value);
-        },
-    );
-
-    engine.register_fn("%doc?", BuiltInModule::get_doc);
-    // engine.register_fn("%module-docs", BuiltInModule::docs);
-    engine.register_value("%list-modules!", SteelVal::BuiltIn(list_modules));
-    engine.register_fn("%module/lookup-function", BuiltInModule::search);
-    engine.register_fn("%string->render-markdown", render_as_md);
-    engine.register_fn(
-        "%module-bound-identifiers->list",
-        BuiltInModule::bound_identifiers,
-    );
-    engine.register_value("%proto-hash%", HM_CONSTRUCT);
-    engine.register_value("%proto-hash-insert%", HM_INSERT);
-    engine.register_value("%proto-hash-get%", HM_GET);
-    engine.register_value("error!", ControlOperations::error());
-
-    engine.register_value("error", ControlOperations::error());
-
-    engine.register_value(
-        "%memo-table",
-        WeakMemoizationTable::new().into_steelval().unwrap(),
-    );
-    engine.register_fn("%memo-table-ref", WeakMemoizationTable::get);
-    engine.register_fn("%memo-table-set!", WeakMemoizationTable::insert);
-
-    engine
-        .register_module(MAP_MODULE.with(|x| x.clone()))
-        .register_module(SET_MODULE.with(|x| x.clone()))
-        .register_module(LIST_MODULE.with(|x| x.clone()))
-        .register_module(STRING_MODULE.with(|x| x.clone()))
-        .register_module(VECTOR_MODULE.with(|x| x.clone()))
-        .register_module(STREAM_MODULE.with(|x| x.clone()))
-        // .register_module(CONTRACT_MODULE.with(|x| x.clone()))
-        .register_module(IDENTITY_MODULE.with(|x| x.clone()))
-        .register_module(NUMBER_MODULE.with(|x| x.clone()))
-        .register_module(EQUALITY_MODULE.with(|x| x.clone()))
-        .register_module(ORD_MODULE.with(|x| x.clone()))
-        .register_module(TRANSDUCER_MODULE.with(|x| x.clone()))
-        .register_module(SYMBOL_MODULE.with(|x| x.clone()))
-        .register_module(IO_MODULE.with(|x| x.clone()))
-        .register_module(FS_MODULE.with(|x| x.clone()))
-        .register_module(PORT_MODULE.with(|x| x.clone()))
-        .register_module(META_MODULE.with(|x| x.clone()))
-        .register_module(JSON_MODULE.with(|x| x.clone()))
-        .register_module(CONSTANTS_MODULE.with(|x| x.clone()))
-        .register_module(SYNTAX_MODULE.with(|x| x.clone()))
-        .register_module(PROCESS_MODULE.with(|x| x.clone()))
-        .register_module(RESULT_MODULE.with(|x| x.clone()))
-        .register_module(OPTION_MODULE.with(|x| x.clone()))
-        .register_module(TYPE_ID_MODULE.with(|x| x.clone()))
-        .register_module(PRELUDE_MODULE.with(|x| x.clone()))
-        .register_module(TIME_MODULE.with(|x| x.clone()))
-        .register_module(RANDOM_MODULE.with(|x| x.clone()))
-        .register_module(THREADING_MODULE.with(|x| x.clone()));
-
-    // Private module
-    engine.register_module(MUTABLE_HASH_MODULE.with(|x| x.clone()));
-    engine.register_module(MUTABLE_VECTOR_MODULE.with(|x| x.clone()));
-    engine.register_module(PRIVATE_READER_MODULE.with(|x| x.clone()));
-
-    #[cfg(feature = "web")]
-    engine.register_module(REQUESTS_MODULE.with(|x| x.clone()));
-
-    #[cfg(feature = "sqlite")]
-    engine.register_module(SQLITE_MODULE.with(|x| x.clone()));
-}
-
-pub static MODULE_IDENTIFIERS: Lazy<fxhash::FxHashSet<InternedString>> = Lazy::new(|| {
-    let mut set = fxhash::FxHashSet::default();
-
-    // TODO: Consolidate the prefixes and module names into one spot
-    set.insert("%-builtin-module-steel/hash".into());
-    set.insert("%-builtin-module-steel/sets".into());
-    set.insert("%-builtin-module-steel/lists".into());
-    set.insert("%-builtin-module-steel/strings".into());
-    set.insert("%-builtin-module-steel/vectors".into());
-    set.insert("%-builtin-module-steel/streams".into());
-    set.insert("%-builtin-module-steel/identity".into());
-    set.insert("%-builtin-module-steel/numbers".into());
-    set.insert("%-builtin-module-steel/equality".into());
-    set.insert("%-builtin-module-steel/ord".into());
-    set.insert("%-builtin-module-steel/transducers".into());
-    set.insert("%-builtin-module-steel/io".into());
-    set.insert("%-builtin-module-steel/filesystem".into());
-    set.insert("%-builtin-module-steel/ports".into());
-    set.insert("%-builtin-module-steel/meta".into());
-    set.insert("%-builtin-module-steel/constants".into());
-    set.insert("%-builtin-module-steel/syntax".into());
-    set.insert("%-builtin-module-steel/process".into());
-    set.insert("%-builtin-module-steel/core/result".into());
-    set.insert("%-builtin-module-steel/core/option".into());
-    set.insert("%-builtin-module-steel/threads".into());
-    set.insert("%-builtin-module-steel/base".into());
-
-    set
-});
-
-// TODO: Make the prelude string generation lazy - so that
-// the first time we load (steel/base) we don't have to regenerate
-// the string. Probably just need a lazy static for loading 'steel/base'
-// and then reference that directly.
-pub static ALL_MODULES: &str = r#"
-    (require-builtin steel/hash)
-    (require-builtin steel/sets)
-    (require-builtin steel/lists)
-    (require-builtin steel/strings)
-    (require-builtin steel/symbols)
-    (require-builtin steel/vectors)
-    (require-builtin steel/streams)
-    (require-builtin steel/identity)
-    (require-builtin steel/numbers)
-    (require-builtin steel/equality)
-    (require-builtin steel/ord)
-    (require-builtin steel/transducers)
-    (require-builtin steel/io)
-    (require-builtin steel/filesystem)
-    (require-builtin steel/ports)
-    (require-builtin steel/meta)
-    (require-builtin steel/json)
-    (require-builtin steel/constants)
-    (require-builtin steel/syntax)
-    (require-builtin steel/process)
-    (require-builtin steel/core/result)
-    (require-builtin steel/core/option)
-    (require-builtin steel/core/types)
-    (require-builtin steel/threads)
-
-
-    (require-builtin steel/hash as #%prim.)
-    (require-builtin steel/sets as #%prim.)
-    (require-builtin steel/lists as #%prim.)
-    (require-builtin steel/strings as #%prim.)
-    (require-builtin steel/symbols as #%prim.)
-    (require-builtin steel/vectors as #%prim.)
-    (require-builtin steel/streams as #%prim.)
-    (require-builtin steel/identity as #%prim.)
-    (require-builtin steel/numbers as #%prim.)
-    (require-builtin steel/equality as #%prim.)
-    (require-builtin steel/ord as #%prim.)
-    (require-builtin steel/transducers as #%prim.)
-    (require-builtin steel/io as #%prim.)
-    (require-builtin steel/filesystem as #%prim.)
-    (require-builtin steel/ports as #%prim.)
-    (require-builtin steel/meta as #%prim.)
-    (require-builtin steel/json as #%prim.)
-    (require-builtin steel/constants as #%prim.)
-    (require-builtin steel/syntax as #%prim.)
-    (require-builtin steel/process as #%prim.)
-    (require-builtin steel/core/result as #%prim.)
-    (require-builtin steel/core/option as #%prim.)
-    (require-builtin steel/core/types as #%prim.)
-    (require-builtin steel/threads as #%prim.)
-
-"#;
-
-pub static ALL_MODULES_RESERVED: &str = r#"
-    (require-builtin steel/hash as #%prim.)
-    (require-builtin steel/sets as #%prim.)
-    (require-builtin steel/lists as #%prim.)
-    (require-builtin steel/strings as #%prim.)
-    (require-builtin steel/symbols as #%prim.)
-    (require-builtin steel/vectors as #%prim.)
-    (require-builtin steel/streams as #%prim.)
-    (require-builtin steel/identity as #%prim.)
-    (require-builtin steel/numbers as #%prim.)
-    (require-builtin steel/equality as #%prim.)
-    (require-builtin steel/ord as #%prim.)
-    (require-builtin steel/transducers as #%prim.)
-    (require-builtin steel/io as #%prim.)
-    (require-builtin steel/filesystem as #%prim.)
-    (require-builtin steel/ports as #%prim.)
-    (require-builtin steel/meta as #%prim.)
-    (require-builtin steel/json as #%prim.)
-    (require-builtin steel/constants as #%prim.)
-    (require-builtin steel/syntax as #%prim.)
-    (require-builtin steel/process as #%prim.)
-    (require-builtin steel/core/result as #%prim.)
-    (require-builtin steel/core/option as #%prim.)
-    (require-builtin steel/core/types as #%prim.)
-    (require-builtin steel/threads as #%prim.)
-"#;
-
-pub static SANDBOXED_MODULES: &str = r#"
-    (require-builtin steel/hash)
-    (require-builtin steel/sets)
-    (require-builtin steel/lists)
-    (require-builtin steel/strings)
-    (require-builtin steel/symbols)
-    (require-builtin steel/vectors)
-    (require-builtin steel/streams)
-    (require-builtin steel/identity)
-    (require-builtin steel/numbers)
-    (require-builtin steel/equality)
-    (require-builtin steel/ord)
-    (require-builtin steel/transducers)
-    (require-builtin steel/io)
-    (require-builtin steel/meta)
-    (require-builtin steel/json)
-    (require-builtin steel/constants)
-    (require-builtin steel/syntax)
-"#;
-
-// static MAP_MODULE: Lazy<BuiltInModule> = Lazy::new(hashmap);
-// static SET_MODULE: Lazy<BuiltInModule> = Lazy::new(hashset);
-
-fn vector_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/vectors");
-    module
-        .register_value("mutable-vector", VectorOperations::mut_vec_construct())
-        .register_value("make-vector", VectorOperations::make_vector())
-        .register_value("mutable-vector->list", VectorOperations::mut_vec_to_list())
-        .register_value("vector-push!", VectorOperations::mut_vec_push())
-        .register_value("mut-vec-len", VectorOperations::mut_vec_length())
-        .register_value("vector-length", VectorOperations::vec_length())
-        .register_value("vector-append!", VectorOperations::mut_vec_append())
-        .register_value("mut-vector-ref", VectorOperations::mut_vec_get())
-        .register_value("vector-set!", VectorOperations::mut_vec_set())
-        // Immutable vector operations
-        .register_value("vector", VectorOperations::vec_construct())
-        .register_value("push-front", VectorOperations::vec_cons())
-        .register_value("pop-front", VectorOperations::vec_car())
-        .register_value("vec-rest", VectorOperations::vec_cdr())
-        .register_value("null?", VectorOperations::list_vec_null())
-        .register_value("push", VectorOperations::vec_push())
-        .register_value("range-vec", VectorOperations::vec_range())
-        .register_value("vec-append", VectorOperations::vec_append())
-        .register_value("vector-ref", VectorOperations::vec_ref());
-    module
-}
-
-#[steel_derive::function(name = "not", constant = true)]
-fn not(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::BoolV(false))
-}
-
-#[steel_derive::function(name = "int?", constant = true)]
-fn intp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::IntV(_))
-}
-
-#[steel_derive::function(name = "integer?", constant = true)]
-fn integerp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::IntV(_))
-}
-
-#[steel_derive::function(name = "float?", constant = true)]
-fn floatp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::NumV(_))
-}
-
-#[steel_derive::function(name = "number?", constant = true)]
-fn numberp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::NumV(_) | SteelVal::IntV(_))
-}
-
-#[steel_derive::function(name = "string?", constant = true)]
-fn stringp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::StringV(_))
-}
-
-#[steel_derive::function(name = "list?", constant = true)]
-fn listp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::ListV(_))
-}
-
-#[steel_derive::function(name = "vector?", constant = true)]
-fn vectorp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::VectorV(_))
-}
-
-#[steel_derive::function(name = "symbol?", constant = true)]
-fn symbolp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::SymbolV(_))
-}
-
-#[steel_derive::function(name = "hash?", constant = true)]
-fn hashp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::HashMapV(_))
-}
-
-#[steel_derive::function(name = "set?", constant = true)]
-fn hashsetp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::HashSetV(_))
-}
-
-#[steel_derive::function(name = "continuation?", constant = true)]
-fn continuationp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::ContinuationFunction(_))
-}
-
-#[steel_derive::function(name = "boolean?", constant = true)]
-fn booleanp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::BoolV(_))
-}
-
-#[steel_derive::function(name = "bool?", constant = true)]
-fn boolp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::BoolV(_))
-}
-
-#[steel_derive::function(name = "void?", constant = true)]
-fn voidp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::Void)
-}
-
-#[steel_derive::function(name = "struct?", constant = true)]
-fn structp(value: &SteelVal) -> bool {
-    if let SteelVal::CustomStruct(s) = value {
-        s.is_transparent()
-    } else {
-        false
-    }
-}
-
-#[steel_derive::function(name = "#%private-struct?", constant = true)]
-fn private_structp(value: &SteelVal) -> bool {
-    matches!(value, SteelVal::CustomStruct(_))
-}
-
-#[steel_derive::function(name = "function?", constant = true)]
-fn functionp(value: &SteelVal) -> bool {
-    matches!(
-        value,
-        SteelVal::Closure(_)
-            | SteelVal::FuncV(_)
-            // | SteelVal::ContractedFunction(_)
-            | SteelVal::BoxedFunction(_)
-            | SteelVal::ContinuationFunction(_)
-            | SteelVal::MutFunc(_)
-            | SteelVal::BuiltIn(_)
-    )
-}
-
-#[steel_derive::function(name = "procedure?", constant = true)]
-fn procedurep(value: &SteelVal) -> bool {
-    if let SteelVal::CustomStruct(s) = value {
-        return s.maybe_proc().map(|x| procedurep(x)).unwrap_or(false);
-    }
-
-    matches!(
-        value,
-        SteelVal::Closure(_)
-            | SteelVal::FuncV(_)
-            | SteelVal::BoxedFunction(_)
-            | SteelVal::ContinuationFunction(_)
-            | SteelVal::MutFunc(_)
-            | SteelVal::BuiltIn(_)
-    )
-}
-fn identity_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/identity");
-    module
-        // .register_value("int?", gen_pred!(IntV))
-        .register_native_fn_definition(NOT_DEFINITION)
-        .register_native_fn_definition(INTEGERP_DEFINITION)
-        .register_native_fn_definition(INTP_DEFINITION)
-        .register_native_fn_definition(FLOATP_DEFINITION)
-        .register_native_fn_definition(NUMBERP_DEFINITION)
-        .register_native_fn_definition(NUMBERP_DEFINITION)
-        .register_native_fn_definition(STRINGP_DEFINITION)
-        .register_native_fn_definition(LISTP_DEFINITION)
-        .register_native_fn_definition(VECTORP_DEFINITION)
-        .register_native_fn_definition(SYMBOLP_DEFINITION)
-        .register_native_fn_definition(HASHP_DEFINITION)
-        .register_native_fn_definition(HASHSETP_DEFINITION)
-        .register_native_fn_definition(CONTINUATIONP_DEFINITION)
-        .register_native_fn_definition(BOOLEANP_DEFINITION)
-        .register_native_fn_definition(BOOLP_DEFINITION)
-        .register_native_fn_definition(VOIDP_DEFINITION)
-        .register_native_fn_definition(STRUCTP_DEFINITION)
-        .register_native_fn_definition(PRIVATE_STRUCTP_DEFINITION)
-        .register_value("mutable-vector?", gen_pred!(MutableVector))
-        .register_value("char?", gen_pred!(CharV))
-        .register_value("future?", gen_pred!(FutureV))
-        .register_native_fn_definition(FUNCTIONP_DEFINITION)
-        .register_native_fn_definition(PROCEDUREP_DEFINITION)
-        .register_value(
-            "atom?",
-            gen_pred!(NumV, IntV, StringV, SymbolV, BoolV, CharV),
-        );
-    module
-}
-
-fn stream_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/streams");
-    module
-        .register_value("stream-cons", StreamOperations::stream_cons())
-        .register_value("empty-stream", StreamOperations::empty_stream())
-        .register_value("stream-empty?", StreamOperations::stream_empty_huh())
-        .register_value("stream-car", StreamOperations::stream_car())
-        .register_value("#%stream-cdr", StreamOperations::stream_cdr());
-    module
-}
-
-// fn contract_module() -> BuiltInModule {
-//     let mut module = BuiltInModule::new("steel/contracts");
-//     module
-//         .register_value("bind/c", contracts::BIND_CONTRACT_TO_FUNCTION)
-//         .register_value("make-flat/c", contracts::MAKE_FLAT_CONTRACT)
-//         .register_value(
-//             "make-dependent-function/c",
-//             contracts::MAKE_DEPENDENT_CONTRACT,
-//         )
-//         .register_value("make-function/c", contracts::MAKE_FUNCTION_CONTRACT)
-//         .register_value("make/c", contracts::MAKE_C);
-
-//     module
-// }
-
-#[steel_derive::function(name = "exact->inexact", constant = true)]
-fn exact_to_inexact(number: &SteelVal) -> Result<SteelVal> {
-    match number {
-        SteelVal::IntV(i) => Ok(SteelVal::NumV(*i as f64)),
-        SteelVal::NumV(n) => Ok(SteelVal::NumV(*n)),
-        SteelVal::BigNum(n) => Ok(SteelVal::NumV(n.to_f64().unwrap())),
-        _ => stop!(TypeMismatch => "exact->inexact expects a number type, found: {}", number),
-    }
-}
-
-// Docs from racket:
-// (round x) → (or/c integer? +inf.0 -inf.0 +nan.0)
-//   x : real?
-// Returns the integer closest to x, resolving ties in favor of an even number, but +inf.0, -inf.0, and +nan.0 round to themselves.
-#[steel_derive::function(name = "round", constant = true)]
-fn round(number: f64) -> f64 {
-    number.round()
-}
-
-/// Returns the absolute value of the given input
-#[steel_derive::function(name = "abs", constant = true)]
-fn abs(number: &SteelVal) -> Result<SteelVal> {
-    match number {
-        SteelVal::IntV(i) => Ok(SteelVal::IntV(i.abs())),
-        SteelVal::NumV(n) => Ok(SteelVal::NumV(n.abs())),
-        SteelVal::BigNum(n) => n.abs().into_steelval(),
-        _ => stop!(TypeMismatch => "abs expects a number type, found: {}", number),
-    }
-}
-
-#[steel_derive::function(name = "expt", constant = true)]
-fn expt(left: &SteelVal, right: &SteelVal) -> Result<SteelVal> {
-    match (left, right) {
-        (SteelVal::IntV(l), SteelVal::IntV(r)) if *r < (u32::MAX as isize) => {
-            Ok(SteelVal::IntV(l.pow(*r as u32)))
-        }
-        (SteelVal::NumV(l), SteelVal::IntV(r)) if *r < (i32::MAX as isize) => {
-            Ok(SteelVal::NumV(l.powi(*r as i32)))
-        }
-        (SteelVal::NumV(l), SteelVal::NumV(r)) => Ok(SteelVal::NumV(l.powf(*r))),
-        _ => {
-            stop!(TypeMismatch => "expt expected two numbers")
-        }
-    }
-}
-
-/// Returns Euler's number raised to the power of z.
-#[steel_derive::function(name = "exp", constant = true)]
-fn exp(left: &SteelVal) -> Result<SteelVal> {
-    match left {
-        SteelVal::IntV(i) if *i == 0 => Ok(SteelVal::IntV(1)),
-        SteelVal::IntV(l) if *l < i32::MAX as isize => {
-            Ok(SteelVal::NumV(std::f64::consts::E.powi(*l as i32)))
-        }
-        SteelVal::NumV(n) => Ok(SteelVal::NumV(std::f64::consts::E.powf(*n))),
-        _ => {
-            stop!(Generic => "integer power too large to be used for exponent")
-        }
-    }
-}
-
-#[steel_derive::native(name = "log", arity = "AtLeast(1)")]
-fn log(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() > 2 {
-        stop!(ArityMismatch => "log expects one or two arguments, found: {}", args.len());
-    }
-
-    let first = &args[0];
-    let base = args
-        .get(1)
-        .cloned()
-        .unwrap_or(SteelVal::NumV(std::f64::consts::E));
-
-    match (first, &base) {
-        (SteelVal::IntV(1), _) => Ok(SteelVal::IntV(0)),
-        (SteelVal::IntV(_) | SteelVal::NumV(_), SteelVal::IntV(1)) => {
-            stop!(Generic => "log: divide by zero with args: {} and {}", first, base);
-        }
-        (SteelVal::IntV(arg), SteelVal::NumV(n)) => Ok(SteelVal::NumV((*arg as f64).log(*n))),
-        (SteelVal::IntV(arg), SteelVal::IntV(base)) => Ok(SteelVal::IntV(arg.ilog(*base) as isize)),
-        (SteelVal::NumV(arg), SteelVal::NumV(n)) => Ok(SteelVal::NumV(arg.log(*n))),
-        (SteelVal::NumV(arg), SteelVal::IntV(base)) => Ok(SteelVal::NumV(arg.log(*base as f64))),
-        _ => {
-            stop!(TypeMismatch => "log expects one or two numbers, found: {} and {}", first, base);
-        }
-    }
-}
-
-fn number_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/numbers");
-    module
-        .register_native_fn_definition(SPECIAL_ADD_DEFINITION)
-        .register_value("f+", NumOperations::float_add())
-        .register_value("*", NumOperations::multiply())
-        .register_value("/", NumOperations::divide())
-        .register_value("-", NumOperations::subtract())
-        .register_value("even?", NumOperations::even())
-        .register_value("odd?", NumOperations::odd())
-        .register_fn("quotient", quotient)
-        .register_value("arithmetic-shift", NumOperations::arithmetic_shift())
-        .register_native_fn_definition(ABS_DEFINITION)
-        .register_native_fn_definition(EXPT_DEFINITION)
-        .register_native_fn_definition(ROUND_DEFINITION)
-        .register_native_fn_definition(EXACT_TO_INEXACT_DEFINITION)
-        .register_native_fn_definition(EXP_DEFINITION)
-        .register_native_fn_definition(LOG_DEFINITION);
-
-    module
-}
-
-#[inline(always)]
-pub fn equality_primitive(args: &[SteelVal]) -> Result<SteelVal> {
-    // if args.is_empty() {
-    //     stop!(ArityMismatch => "expected at least one argument");
-    // }
-
-    // for (left, right) in args.iter().tuple_windows() {
-    //     if left != right {
-    //         return Ok(SteelVal::BoolV(false));
-    //     }
-    // }
-
-    Ok(SteelVal::BoolV(args.windows(2).all(|x| x[0] == x[1])))
-
-    // Ok(SteelVal::BoolV(true))
-}
-
-// TODO: Align with the above using windows
-pub fn gte_primitive(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.is_empty() {
-        stop!(ArityMismatch => "expected at least one argument");
-    }
-
-    for window in args.windows(2) {
-        if let &[left, right] = &window {
-            match left.partial_cmp(&right) {
-                None | Some(Ordering::Less) => return Ok(SteelVal::BoolV(false)),
-                _ => continue,
-            }
-        }
-    }
-
-    Ok(SteelVal::BoolV(true))
-}
-
-#[inline(always)]
-pub fn lte_primitive(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.is_empty() {
-        stop!(ArityMismatch => "expected at least one argument");
-    }
-
-    // Ok(SteelVal::BoolV(args.is_sorted_by()))
-
-    // self.as_slice().windows(2).all(|w| {
-    //     compare(&&w[0], &&w[1]).map(|o| o != Ordering::Greater).unwrap_or(false)
-    // })
-
-    // for &[left, right] in args.windows(2) {
-    //     match left.partial_cmp(&right) {
-    //         None | Some(Ordering::Greater) => return Ok(SteelVal::BoolV(false)),
-    //         _ => continue,
-    //     }
-    // }
-
-    Ok(SteelVal::BoolV(args.windows(2).all(|x| {
-        x[0].partial_cmp(&x[1])
-            .map(|x| x != Ordering::Greater)
-            .unwrap_or(false)
-    })))
-
-    // Ok(SteelVal::BoolV(true))
-}
-
-fn equality_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/equality");
-    module
-        .register_value(
-            "equal?",
-            SteelVal::FuncV(ensure_tonicity_two!(|a, b| a == b)),
-        )
-        .register_value("eqv?", SteelVal::FuncV(ensure_tonicity_two!(|a, b| a == b)))
-        .register_value(
-            "eq?",
-            SteelVal::FuncV(ensure_tonicity_two!(
-                |a: &SteelVal, b: &SteelVal| a.ptr_eq(b)
-            )),
-        )
-        .register_native_fn_definition(NUMBER_EQUALITY_DEFINITION);
-
-    // TODO: Replace this with just numeric equality!
-    // .register_value("=", SteelVal::FuncV(ensure_tonicity_two!(|a, b| a == b)));
-
-    module
-}
-
-fn ord_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/ord");
-    module
-        .register_value(">", SteelVal::FuncV(ensure_tonicity_two!(|a, b| a > b)))
-        .register_value(">=", SteelVal::FuncV(gte_primitive))
-        .register_value("<", SteelVal::FuncV(ensure_tonicity_two!(|a, b| a < b)))
-        .register_value("<=", SteelVal::FuncV(ensure_tonicity_two!(|a, b| a <= b)));
-    module
-}
-
-pub fn transducer_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/transducers");
-
-    use crate::primitives::transducers::*;
-
-    module
-        .register_native_fn("compose", compose, Arity::AtLeast(0))
-        .register_native_fn("mapping", map, Arity::Exact(1))
-        .register_native_fn("flattening", flatten, Arity::Exact(1))
-        .register_native_fn("flat-mapping", flat_map, Arity::Exact(1))
-        .register_native_fn("filtering", filter, Arity::Exact(1))
-        .register_native_fn("taking", take, Arity::Exact(1))
-        .register_native_fn("dropping", dropping, Arity::Exact(1))
-        .register_native_fn("extending", extending, Arity::Exact(1))
-        .register_native_fn("enumerating", enumerating, Arity::Exact(0))
-        .register_native_fn("zipping", zipping, Arity::Exact(1))
-        .register_native_fn("interleaving", interleaving, Arity::Exact(1))
-        .register_value("into-sum", crate::values::transducers::INTO_SUM)
-        .register_value("into-product", crate::values::transducers::INTO_PRODUCT)
-        .register_value("into-max", crate::values::transducers::INTO_MAX)
-        .register_value("into-min", crate::values::transducers::INTO_MIN)
-        .register_value("into-count", crate::values::transducers::INTO_COUNT)
-        .register_value("into-list", crate::values::transducers::INTO_LIST)
-        .register_value("into-vector", crate::values::transducers::INTO_VECTOR)
-        .register_value("into-hashmap", crate::values::transducers::INTO_HASHMAP)
-        .register_value("into-hashset", crate::values::transducers::INTO_HASHSET)
-        .register_value("into-string", crate::values::transducers::INTO_STRING)
-        .register_value("into-last", crate::values::transducers::INTO_LAST)
-        .register_value("into-for-each", crate::values::transducers::FOR_EACH)
-        .register_value("into-nth", crate::values::transducers::NTH)
-        .register_value("into-reducer", crate::values::transducers::REDUCER);
-    module
-}
-
-fn symbol_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/symbols");
-    module
-        .register_value("concat-symbols", SymbolOperations::concat_symbols())
-        .register_value("symbol->string", SymbolOperations::symbol_to_string());
-    module
-}
-
-fn io_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/io");
-    module
-        // .register_value("display", IoFunctions::display())
-        // .register_value("displayln", IoFunctions::displayln())
-        // .register_value("simple-display", IoFunctions::display())
-        .register_value("stdout-simple-displayln", IoFunctions::displayln())
-        // .register_value("newline", IoFunctions::newline())
-        .register_value("read-to-string", IoFunctions::read_to_string());
-
-    // #[cfg(feature = "colors")]
-    // module.register_value("display-color", IoFunctions::display_color());
-
-    module
-}
-
-fn sandboxed_io_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/io");
-    module
-        .register_value("stdout-simple-displayln", IoFunctions::displayln())
-        // .register_value("newline", IoFunctions::newline())
-        .register_value("read-to-string", IoFunctions::read_to_string());
-    // .register_value("display", IoFunctions::sandboxed_display())
-    // .register_value("display-color", IoFunctions::display_color())
-    // .register_value("newline", IoFunctions::sandboxed_newline());
-    // .register_value("read-to-string", IoFunctions::read_to_string());
-    module
-}
-
-fn constants_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/constants");
-    module.register_value("void", SteelVal::Void);
-    module
-}
-
-fn get_environment_variable(var: String) -> Result<SteelVal> {
-    std::env::var(var)
-        .map(|x| x.into_steelval().unwrap())
-        .map_err(|x| SteelErr::new(ErrorKind::Generic, x.to_string()))
-}
-
-fn maybe_get_environment_variable(var: String) -> SteelResult<SteelVal, SteelErr> {
-    std::env::var(var)
-        .map(|x| x.into_steelval().unwrap())
-        .map_err(|x| SteelErr::new(ErrorKind::Generic, x.to_string()))
-        .into()
-}
-
-fn sandboxed_meta_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/meta");
-    module
-        // .register_value("assert!", MetaOperations::assert_truthy())
-        .register_value("active-object-count", MetaOperations::active_objects())
-        .register_value("inspect-bytecode", MetaOperations::inspect_bytecode())
-        // .register_value("memory-address", MetaOperations::memory_address())
-        // .register_value("async-exec", MetaOperations::exec_async())
-        // .register_value("poll!", MetaOperations::poll_value())
-        // .register_value("block-on", MetaOperations::block_on())
-        // .register_value("join!", MetaOperations::join_futures())
-        // .register_value("struct-ref", struct_ref())
-        // .register_value("struct->list", struct_to_list())
-        // .register_value("struct->vector", struct_to_vector())
-        .register_fn("value->string", super::meta::value_to_string)
-        // .register_value("expand!", SteelVal::FuncV(super::meta::expand_macros))
-        // .register_value("read!", SteelVal::FuncV(super::meta::read))
-        // .register_value("eval!", SteelVal::FuncV(super::meta::eval))
-        // TODO: @Matt -> implement the traits for modules as well
-        // .register_fn("Engine::new", super::meta::EngineWrapper::new)
-        .register_fn("eval!", super::meta::eval)
-        .register_fn("value->iterator", crate::rvals::value_into_iterator)
-        .register_value("iter-next!", SteelVal::FuncV(crate::rvals::iterator_next));
-    // .register_fn("run!", super::meta::EngineWrapper::call)
-    // .register_fn("get-value", super::meta::EngineWrapper::get_value)
-    // .register_fn("env-var", get_environment_variable);
-    module
-}
-
-fn lookup_function_name(value: SteelVal) -> Option<SteelVal> {
-    match value {
-        SteelVal::BoxedFunction(f) => f.name().map(|x| x.into_steelval().unwrap()),
-        SteelVal::FuncV(f) => get_function_name(f).map(|x| x.name.into_steelval().unwrap()),
-        _ => None,
-    }
-}
-
-// Only works with fixed size arity functions
-fn arity(value: SteelVal) -> UnRecoverableResult {
-    match value {
-        SteelVal::Closure(c) => {
-            // Ok(SteelVal::IntV(c.arity() as isize)).into()
-
-            if let Some(SteelVal::CustomStruct(s)) = c.get_contract_information() {
-                let guard = s;
-                if guard.name().resolve() == "FunctionContract" {
-                    if let SteelVal::ListV(l) = &guard.fields[0] {
-                        Ok(SteelVal::IntV(l.len() as isize)).into()
-                    } else {
-                        steelerr!(TypeMismatch => "Unable to find the arity for the given function")
-                            .into()
-                    }
-                } else if guard.name().resolve() == "FlatContract" {
-                    Ok(SteelVal::IntV(1)).into()
-                } else {
-                    // This really shouldn't happen
-                    Ok(SteelVal::IntV(c.arity() as isize)).into()
-                }
-            } else {
-                Ok(SteelVal::IntV(c.arity() as isize)).into()
-            }
-        }
-        SteelVal::BoxedFunction(f) => f
-            .get_arity()
-            .map(|x| SteelVal::IntV(x as isize))
-            .ok_or(SteelErr::new(
-                ErrorKind::TypeMismatch,
-                "Unable to find the arity for the given function".to_string(),
-            ))
-            // .ok_or(steelerr!(TypeMismatch => "Unable to find the arity for the give function"))
-            .into(),
-
-        // Lookup the function signature metadata, return the arity payload
-        SteelVal::FuncV(f) => {
-            let metadata = get_function_name(f);
-
-            metadata
-                .map(|x| x.arity)
-                .ok_or(SteelErr::new(
-                    ErrorKind::TypeMismatch,
-                    "Unable to find the arity for the given function".to_string(),
-                ))
-                .and_then(|x| x.into_steelval())
-                .into()
-        }
-
-        // Ok(SteelVal::IntV(f.get_arity()))
-        _ => steelerr!(TypeMismatch => "Unable to find the arity for the given function").into(),
-    }
-}
-
-// Only works with fixed size arity functions
-fn is_multi_arity(value: SteelVal) -> UnRecoverableResult {
-    match value {
-        SteelVal::Closure(c) => Ok(SteelVal::BoolV(c.is_multi_arity)).into(),
-        _ => steelerr!(TypeMismatch => "Unable to find the arity for the given function").into(),
-    }
-}
-
-struct MutableVector {
-    vector: Vec<SteelVal>,
-}
-
-impl MutableVector {
-    fn new() -> Self {
-        Self { vector: Vec::new() }
-    }
-
-    fn vector_push(&mut self, value: SteelVal) {
-        self.vector.push(value);
-    }
-
-    fn vector_pop(&mut self) -> Option<SteelVal> {
-        self.vector.pop()
-    }
-
-    fn vector_set(&mut self, index: usize, value: SteelVal) {
-        self.vector[index] = value;
-    }
-
-    fn vector_ref(&self, index: usize) -> SteelVal {
-        self.vector[index].clone()
-    }
-
-    fn vector_len(&self) -> usize {
-        self.vector.len()
-    }
-
-    fn vector_to_list(&self) -> SteelVal {
-        SteelVal::ListV(self.vector.clone().into())
-    }
-
-    fn vector_is_empty(&self) -> bool {
-        self.vector.is_empty()
-    }
-
-    fn vector_from_list(lst: List<SteelVal>) -> Self {
-        Self {
-            vector: lst.into_iter().collect(),
-        }
-    }
-}
-
-impl crate::rvals::Custom for MutableVector {
-    fn gc_visit_children(&self, context: &mut crate::values::closed::MarkAndSweepContext) {
-        for value in &self.vector {
-            context.push_back(value.clone());
-        }
-    }
-
-    fn visit_equality(&self, visitor: &mut crate::rvals::cycles::EqualityVisitor) {
-        for value in &self.vector {
-            visitor.push_back(value.clone());
-        }
-    }
-
-    // Compare the two for equality otherwise
-    fn equality_hint(&self, other: &dyn crate::rvals::CustomType) -> bool {
-        if let Some(other) = as_underlying_type::<MutableVector>(other) {
-            self.vector.len() == other.vector.len()
-        } else {
-            false
-        }
-    }
-}
-
-struct MutableHashTable {
-    table: HashMap<SteelVal, SteelVal>,
-}
-
-impl crate::rvals::Custom for MutableHashTable {
-    fn gc_visit_children(&self, context: &mut crate::values::closed::MarkAndSweepContext) {
-        for (key, value) in &self.table {
-            context.push_back(key.clone());
-            context.push_back(value.clone());
-        }
-    }
-}
-
-impl MutableHashTable {
-    pub fn new() -> Self {
-        Self {
-            table: HashMap::new(),
-        }
-    }
-
-    pub fn insert(&mut self, key: SteelVal, value: SteelVal) {
-        self.table.insert(key, value);
-    }
-
-    pub fn get(&self, key: SteelVal) -> Option<SteelVal> {
-        self.table.get(&key).cloned()
-    }
-}
-
-struct Reader {
-    buffer: String,
-    offset: usize,
-}
-
-impl crate::rvals::Custom for Reader {}
-
-impl Reader {
-    fn create_reader() -> Reader {
-        Self {
-            buffer: String::new(),
-            offset: 0,
-        }
-    }
-
-    fn push_string(&mut self, input: crate::rvals::SteelString) {
-        self.buffer.push_str(input.as_str());
-    }
-
-    fn is_empty(&self) -> bool {
-        self.buffer.is_empty()
-    }
-
-    fn read_one(&mut self) -> Result<SteelVal> {
-        if let Some(buffer) = self.buffer.get(self.offset..) {
-            // println!("Reading range: {}", buffer);
-
-            let mut parser = crate::parser::parser::Parser::new_flat(buffer, None);
-
-            if let Some(raw) = parser.next() {
-                // self.offset += parser.offset();
-
-                let next = if let Ok(next) = raw {
-                    next
-                } else {
-                    return Ok(SteelVal::Void);
-                };
-
-                self.offset += parser.offset();
-
-                let result = TryFromExprKindForSteelVal::try_from_expr_kind_quoted(next);
-
-                if let Some(remaining) = self.buffer.get(self.offset..) {
-                    for _ in remaining.chars().take_while(|x| x.is_whitespace()) {
-                        self.offset += 1;
-                    }
-                }
-
-                if self.offset == self.buffer.len() {
-                    self.buffer.clear();
-                    self.offset = 0;
-                }
-
-                result
-            } else {
-                // No value, keep reading
-                Ok(SteelVal::Void)
-            }
-        } else {
-            Ok(SteelVal::SymbolV(
-                crate::primitives::ports::EOF_OBJECT.with(|x| x.clone()),
-            ))
-        }
-    }
-}
-
-fn reader_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("#%private/steel/reader");
-
-    module
-        .register_fn("new-reader", Reader::create_reader)
-        .register_fn("reader-push-string", Reader::push_string)
-        .register_fn("reader-read-one", Reader::read_one)
-        .register_fn("reader-empty?", Reader::is_empty);
-
-    module
-}
-
-fn mutable_vector_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("#%private/steel/mvector");
-
-    module
-        .register_fn("make-mutable-vector", MutableVector::new)
-        .register_fn("mutable-vector-ref", MutableVector::vector_ref)
-        .register_fn("mutable-vector-set!", MutableVector::vector_set)
-        .register_fn("mutable-vector-pop!", MutableVector::vector_pop)
-        .register_fn("mutable-vector-push!", MutableVector::vector_push)
-        .register_fn("mutable-vector-len", MutableVector::vector_len)
-        .register_fn("mutable-vector->list", MutableVector::vector_to_list)
-        .register_fn("mutable-vector-empty?", MutableVector::vector_is_empty)
-        .register_fn("mutable-vector-from-list", MutableVector::vector_from_list);
-
-    module
-}
-
-fn mutable_hashmap_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("#%private/steel/mhash");
-
-    module
-        .register_fn("mhash", MutableHashTable::new)
-        .register_fn("mhash-set!", MutableHashTable::insert)
-        .register_fn("mhash-ref", MutableHashTable::get);
-
-    module
-}
-
-#[steel_derive::function(name = "#%unbox")]
-pub fn unbox_mutable(value: &HeapRef<SteelVal>) -> SteelVal {
-    value.get()
-}
-
-#[steel_derive::function(name = "#%set-box!")]
-pub fn set_box_mutable(value: &HeapRef<SteelVal>, update: SteelVal) -> SteelVal {
-    value.set_and_return(update)
-}
-
-// TODO: Handle arity issues!!!
-fn make_mutable_box(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    let allocated_var = ctx.thread.heap.allocate(
-        args[0].clone(), // TODO: Could actually move off of the stack entirely
-        ctx.thread.stack.iter(),
-        ctx.thread.stack_frames.iter().map(|x| x.function.as_ref()),
-        ctx.thread.global_env.roots(),
-    );
-
-    Some(Ok(SteelVal::HeapAllocated(allocated_var)))
-}
-
-#[steel_derive::function(name = "unbox")]
-pub fn unbox(value: &Gc<RefCell<SteelVal>>) -> SteelVal {
-    value.borrow().clone()
-}
-
-#[steel_derive::function(name = "set-box!")]
-pub fn set_box(value: &Gc<RefCell<SteelVal>>, update_to: SteelVal) {
-    *value.borrow_mut() = update_to;
-}
-
-pub fn black_box(_: &[SteelVal]) -> Result<SteelVal> {
-    Ok(SteelVal::Void)
-}
-
-fn meta_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/meta");
-    module
-        .register_value("#%black-box", SteelVal::FuncV(black_box))
-        .register_value(
-            "#%function-ptr-table",
-            LambdaMetadataTable::new().into_steelval().unwrap(),
-        )
-        .register_fn("#%function-ptr-table-add", LambdaMetadataTable::add)
-        .register_fn("#%function-ptr-table-get", LambdaMetadataTable::get)
-        .register_fn("#%private-cycle-collector", SteelCycleCollector::from_root)
-        .register_fn("#%private-cycle-collector-get", SteelCycleCollector::get)
-        .register_fn(
-            "#%private-cycle-collector-values",
-            SteelCycleCollector::values,
-        )
-        .register_value("assert!", MetaOperations::assert_truthy())
-        .register_value("active-object-count", MetaOperations::active_objects())
-        .register_value("inspect-bytecode", MetaOperations::inspect_bytecode())
-        .register_value("memory-address", MetaOperations::memory_address())
-        // .register_value("async-exec", MetaOperations::exec_async())
-        .register_value("poll!", MetaOperations::poll_value())
-        .register_value("block-on", MetaOperations::block_on())
-        .register_value("join!", MetaOperations::join_futures())
-        .register_fn(
-            "#%struct-property-ref",
-            |value: &UserDefinedStruct, key: SteelVal| UserDefinedStruct::get(value, &key),
-        )
-        // .register_value("struct-ref", struct_ref())
-        // .register_value("struct->list", struct_to_list())
-        // .register_value("struct->vector", struct_to_vector())
-        .register_value("expand!", SteelVal::FuncV(super::meta::expand_macros))
-        .register_value("read!", SteelVal::FuncV(super::meta::read))
-        .register_value(
-            "current-function-span",
-            SteelVal::BuiltIn(super::vm::current_function_span),
-        )
-        .register_value("error-with-span", error_with_src_loc())
-        .register_value("raise-error-with-span", error_from_error_with_span())
-        .register_value("raise-error", raise_error_from_error())
-        .register_value("call/cc", SteelVal::BuiltIn(super::vm::call_cc))
-        .register_value(
-            "call-with-exception-handler",
-            SteelVal::BuiltIn(super::vm::call_with_exception_handler),
-        )
-        .register_value("breakpoint!", SteelVal::BuiltIn(super::vm::breakpoint))
-        .register_value(
-            "call-with-current-continuation",
-            SteelVal::BuiltIn(super::vm::call_cc),
-        )
-        .register_fn("eval!", super::meta::eval)
-        .register_fn("value->string", super::meta::value_to_string)
-        // TODO: @Matt -> implement the traits for modules as well
-        .register_fn("Engine::new", super::meta::EngineWrapper::new)
-        .register_fn("Engine::clone", super::meta::EngineWrapper::deep_copy)
-        .register_fn("Engine::add-module", super::meta::EngineWrapper::add_module)
-        .register_fn("Engine::modules->list", super::meta::EngineWrapper::modules)
-        .register_fn(
-            "Engine::raise_error",
-            super::meta::EngineWrapper::raise_error,
-        )
-        .register_value("set-test-mode!", SteelVal::BuiltIn(set_test_mode))
-        .register_value("get-test-mode", SteelVal::BuiltIn(get_test_mode))
-        .register_fn("run!", super::meta::EngineWrapper::call)
-        // .register_fn("get-value", super::meta::EngineWrapper::get_value)
-        .register_fn("value->iterator", crate::rvals::value_into_iterator)
-        .register_value("iter-next!", SteelVal::FuncV(crate::rvals::iterator_next))
-        // Check whether the iterator is done
-        .register_value("#%iterator-finished", ITERATOR_FINISHED.with(|x| x.clone()))
-        .register_value("%iterator?", gen_pred!(BoxedIterator))
-        .register_fn("env-var", get_environment_variable)
-        .register_fn("maybe-get-env-var", maybe_get_environment_variable)
-        .register_fn("set-env-var!", std::env::set_var::<String, String>)
-        .register_fn("arity?", arity)
-        .register_fn("function-name", lookup_function_name)
-        .register_fn("multi-arity?", is_multi_arity)
-        .register_value("make-struct-type", SteelVal::FuncV(make_struct_type))
-        // .register_fn("struct-properties", UserDefinedStruct::properties)
-        // .register_value(
-        //     "box",
-        //     SteelVal::BuiltIn(crate::primitives::meta_ops::steel_box),
-        // )
-        // .register_fn("unbox", HeapRef::get)
-        // .register_fn("set-box!", HeapRef::set_interior_mut)
-        .register_fn("box", SteelVal::boxed)
-        .register_native_fn_definition(UNBOX_DEFINITION)
-        .register_native_fn_definition(SET_BOX_DEFINITION)
-        .register_value("#%box", SteelVal::BuiltIn(make_mutable_box))
-        // TODO: Deprecate these at some point
-        .register_native_fn_definition(SET_BOX_MUTABLE_DEFINITION)
-        .register_native_fn_definition(UNBOX_MUTABLE_DEFINITION)
-        // .register_fn("unbox", |value: SteelVal| )
-        .register_value(
-            "attach-contract-struct!",
-            SteelVal::FuncV(attach_contract_struct),
-        )
-        .register_value("get-contract-struct", SteelVal::FuncV(get_contract))
-        .register_fn("current-os!", || std::env::consts::OS);
-
-    // TODO: Remove
-    #[cfg(feature = "dylibs")]
-    module.register_native_fn_definition(crate::steel_vm::dylib::LOAD_MODULE_DEFINITION);
-
-    module
-}
-
-fn json_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/json");
-    module
-        .register_value(
-            "string->jsexpr",
-            crate::values::json_vals::string_to_jsexpr(),
-        )
-        .register_value(
-            "value->jsexpr-string",
-            crate::values::json_vals::serialize_val_to_string(),
-        );
-    module
-}
-
-fn syntax_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/syntax");
-    module
-        .register_fn("syntax->datum", crate::rvals::Syntax::syntax_datum)
-        .register_fn("syntax-loc", crate::rvals::Syntax::syntax_loc)
-        .register_fn("syntax/loc", crate::rvals::Syntax::new)
-        .register_fn("#%syntax/raw", crate::rvals::Syntax::proto)
-        .register_fn("syntax-e", crate::rvals::Syntax::syntax_e)
-        .register_value("syntax?", gen_pred!(SyntaxObject));
-    module
-}
-
-// #[derive(Clone, Copy)]
-// pub struct SourceLocation {
-//     span: Span,
-//     source: Option<usize>,
-// }
-
-// impl Custom for SourceLocation {}
-
-// TODO: Add integration for native functions to just write something like:
-// pub fn dummy(args: RestArgs) where RestArgs just derefs to &[SteelVal] and the arguments
-// can be selected that way
-
-pub fn error_with_src_loc() -> SteelVal {
-    SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-        let mut error_message = String::new();
-
-        if args.len() < 2 {
-            stop!(ArityMismatch => "error-with-span expects at least 2 arguments - the span and the error message")
-        }
-
-        let span = Span::from_steelval(&args[0])?;
-
-        if !args[1..].is_empty() {
-            for arg in &args[1..] {
-                let error_val = arg.to_string();
-                error_message.push(' ');
-                error_message.push_str(error_val.trim_matches('\"'));
-            }
-
-            stop!(Generic => error_message; span);
-        } else {
-            stop!(ArityMismatch => "error-with-span takes at least one argument"; span);
-        }
-    })
-}
-
-pub fn error_from_error_with_span() -> SteelVal {
-    SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-        if args.len() != 2 {
-            stop!(ArityMismatch => "raise-error-with-span expects at least 2 arguments - the error object and the span")
-        }
-
-        let mut steel_error = SteelErr::from_steelval(&args[0])?;
-
-        // steel_error.span()
-
-        if let Some(span) = steel_error.span() {
-            steel_error.push_span_context_to_stack_trace_if_trace_exists(span);
-        }
-
-        let span = Span::from_steelval(&args[1])?;
-
-        Err(steel_error.with_span(span))
-    })
-}
-
-pub fn raise_error_from_error() -> SteelVal {
-    SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-        let steel_error = SteelErr::from_steelval(&args[0])?;
-
-        Err(steel_error)
-    })
-}
-
-// Be able to introspect on the modules - probably just need to add a modules
-// field on the vm, or use a wrapped type with modules to find things
-// TODO: Add magic number for modules. - key to magic number, do pointer equality
-fn _lookup_doc(_ctx: &mut VmCore, _args: &[SteelVal]) -> Result<SteelVal> {
-    // for value in ctx.thread.global_env.bindings_vec.iter() {
-    //     if let
-    // }
-
-    todo!()
-}
diff --git a/crates/steel-core/src/steel_vm/register_fn.rs b/crates/steel-core/src/steel_vm/register_fn.rs
deleted file mode 100644
index 5b8734386..000000000
--- a/crates/steel-core/src/steel_vm/register_fn.rs
+++ /dev/null
@@ -1,2144 +0,0 @@
-#![allow(unused)]
-
-use std::{cell::RefCell, future::Future, marker::PhantomData, rc::Rc, sync::Arc};
-
-use super::{
-    builtin::{Arity, FunctionSignatureMetadata},
-    engine::Engine,
-};
-use crate::values::lists::List;
-use crate::{
-    gc::unsafe_erased_pointers::{
-        BorrowedObject, OpaqueReferenceNursery, ReadOnlyBorrowedObject, ReadOnlyTemporary,
-        Temporary,
-    },
-    rvals::{
-        AsRefMutSteelValFromRef, AsRefSteelVal, AsRefSteelValFromUnsized, AsSlice, FromSteelVal,
-        IntoSteelVal, Result, SteelVal,
-    },
-};
-use crate::{
-    gc::unsafe_erased_pointers::{ReadOnlyTemporaryObject, TemporaryObject},
-    steel_vm::builtin::BuiltInModule,
-};
-use crate::{rvals::AsRefSteelValFromRef, stop};
-use crate::{
-    rvals::{AsRefMutSteelVal, FutureResult},
-    values::functions::BoxedDynFunction,
-};
-use futures_util::FutureExt;
-
-use crate::containers::RegisterValue;
-
-/// Trait for allowing any function that satisfies the `Fn` trait to be embedded in the engine
-/// This allows for clean embedding of function pointers as well as closures that capture immutable environments
-pub trait RegisterFn<FN, ARGS, RET> {
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self;
-    fn register_owned_fn(&mut self, name: String, func: FN) -> &mut Self {
-        self
-    }
-}
-
-pub trait RegisterFnBorrowed<FN, ARGS, RET> {
-    fn register_fn_borrowed(&mut self, name: &'static str, func: FN) -> &mut Self;
-    // fn register_owned_fn(&mut self, name: String, func: FN) -> &mut Self {
-    //     self
-    // }
-}
-
-pub trait SendSyncStatic: Send + Sync + 'static {}
-impl<T: Send + Sync + 'static> SendSyncStatic for T {}
-
-// Exists only to provides some bounds for the impl_register_fn implementation
-// Without this, upstream crates could provides alternative implementations for (_,_), (_,_,_), etc.
-// This allows us to get away with some funny business in the arguments
-pub struct Wrapper<ARGS>(PhantomData<ARGS>);
-
-pub struct NativeWrapper;
-
-pub struct AsyncWrapper<ARGS>(PhantomData<ARGS>);
-
-// The _rest_ of the arguments -> This has a specialized implementation for rest arguments getting
-// collected into a list, so that register_fn / the macro can use this implementation itself when writing
-// functions over many args
-struct RestArgs<'a> {
-    args: &'a [SteelVal],
-}
-
-impl<'a> std::ops::Deref for RestArgs<'a> {
-    type Target = [SteelVal];
-
-    fn deref(&self) -> &Self::Target {
-        self.args
-    }
-}
-
-impl<
-        FUT: Future<Output = RET> + 'static,
-        RET: IntoSteelVal + 'static,
-        FN: Fn() -> FUT + SendSyncStatic,
-    > RegisterFn<FN, AsyncWrapper<()>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<FutureResult> {
-            if !args.is_empty() {
-                stop!(ArityMismatch => format!("{} expected 0 arguments, got {}", name, args.len()));
-            }
-
-            let res = func();
-
-            Ok(FutureResult::new(Box::pin(res.map(|x| x.into_steelval()))))
-        };
-
-        self.register_value(name, SteelVal::FutureFunc(Box::new(Rc::new(f))))
-    }
-}
-
-// impl RegisterFn<fn(&[SteelVal]) -> Result<SteelVal>, NativeWrapper, Result<SteelVal>> for Engine {
-//     fn register_fn(
-//         &mut self,
-//         name: &'static str,
-//         func: fn(&[SteelVal]) -> Result<SteelVal>,
-//     ) -> &mut Self {
-//         self.register_value(name, SteelVal::FuncV(func))
-//     }
-// }
-
-// impl RegisterFn<fn(&[SteelVal]) -> Result<SteelVal>, NativeWrapper, Result<SteelVal>>
-//     for BuiltInModule
-// {
-//     fn register_fn(
-//         &mut self,
-//         name: &'static str,
-//         func: fn(&[SteelVal]) -> Result<SteelVal>,
-//     ) -> &mut Self {
-//         // Just automatically add it to the function pointer table to help out with searching
-//         self.add_to_fn_ptr_table(
-//             func,
-//             FunctionSignatureMetadata::new(name, Arity::Exact(1234)),
-//         );
-//         self.register_value(name, SteelVal::FuncV(func))
-//     }
-// }
-
-impl<RET: IntoSteelVal, FN: Fn() -> RET + SendSyncStatic> RegisterFn<FN, Wrapper<()>, RET>
-    for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if !args.is_empty() {
-                stop!(ArityMismatch => format!("{} expected 0 arguments, got {}", name, args.len()));
-            }
-
-            let res = func();
-
-            res.into_steelval()
-        };
-
-        // self.register_value(name, SteelVal::FuncV(f))
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(0),
-            ))),
-        )
-    }
-}
-
-impl<RET: IntoSteelVal, SELF: AsRefSteelVal, FN: Fn(&SELF) -> RET + SendSyncStatic>
-    RegisterFn<FN, MarkerWrapper1<SELF>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut nursery = <SELF::Nursery>::default();
-
-            let input = <SELF>::as_ref(&args[0], &mut nursery)?;
-
-            let res = func(&input);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<RET: IntoSteelVal, SELF: AsRefMutSteelVal, FN: Fn(&mut SELF) -> RET + SendSyncStatic>
-    RegisterFn<FN, MarkerWrapper2<SELF>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 1, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref(&args[0])?;
-
-            let res = func(&mut input);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelValFromRef,
-        FN: Fn(&mut SELF) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper5<SELF>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 1, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let res = func(&mut input);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelValFromRef,
-        FRAME: AsRefMutSteelVal,
-        FN: Fn(&mut SELF, &mut FRAME) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper6<(SELF, FRAME)>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 2, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-            let mut area = <FRAME>::as_mut_ref(&args[1])?;
-
-            let res = func(&mut input, &mut area);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(2),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelValFromRef,
-        FRAME: AsRefMutSteelVal,
-        FN: Fn(&mut SELF, &mut FRAME) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper6<(SELF, FRAME)>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 2, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-            let mut area = <FRAME>::as_mut_ref(&args[1])?;
-
-            let res = func(&mut input, &mut area);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(2),
-            ))),
-        )
-    }
-}
-
-// Handle the component interface in helix. This will be the following:
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelVal,
-        AREA: FromSteelVal,
-        FRAME: AsRefMutSteelValFromRef,
-        CTX: AsRefMutSteelValFromRef,
-        FN: Fn(&mut SELF, AREA, &mut FRAME, &mut CTX) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper6<(SELF, AREA, FRAME, CTX)>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 4 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 4, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref(&args[0])?;
-            let mut area = <AREA>::from_steelval(&args[1])?;
-            let mut frame = <FRAME>::as_mut_ref_from_ref(&args[2])?;
-            let mut ctx = <CTX>::as_mut_ref_from_ref(&args[3])?;
-
-            let res = func(&mut input, area, &mut frame, &mut ctx);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(4),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelVal,
-        AREA: FromSteelVal,
-        FRAME: AsRefMutSteelValFromRef,
-        CTX: AsRefMutSteelValFromRef,
-        FN: Fn(&mut SELF, AREA, &mut FRAME, &mut CTX) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper6<(SELF, AREA, FRAME, CTX)>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 4 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 4, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref(&args[0])?;
-            let mut area = <AREA>::from_steelval(&args[1])?;
-            let mut frame = <FRAME>::as_mut_ref_from_ref(&args[2])?;
-            let mut ctx = <CTX>::as_mut_ref_from_ref(&args[3])?;
-
-            let res = func(&mut input, area, &mut frame, &mut ctx);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(4),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelVal,
-        AREA: AsRefSteelVal,
-        CTX: AsRefMutSteelValFromRef,
-        FN: Fn(&mut SELF, &AREA, &mut CTX) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper7<(SELF, AREA, CTX)>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 4 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 3, args.len()));
-            }
-
-            let mut nursery = <AREA as AsRefSteelVal>::Nursery::default();
-
-            let mut input = <SELF>::as_mut_ref(&args[0])?;
-            let mut area = <AREA>::as_ref(&args[1], &mut nursery)?;
-            let mut ctx = <CTX>::as_mut_ref_from_ref(&args[2])?;
-
-            let res = func(&mut input, &area, &mut ctx);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(3),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefSteelVal,
-        AREA: FromSteelVal,
-        CTX: AsRefSteelValFromRef,
-        FN: Fn(&SELF, AREA, &CTX) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper8<(SELF, AREA, CTX)>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 4 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 3, args.len()));
-            }
-
-            let mut nursery = <SELF as AsRefSteelVal>::Nursery::default();
-
-            let mut input = <SELF>::as_ref(&args[0], &mut nursery)?;
-            let mut area = <AREA>::from_steelval(&args[1])?;
-            let mut ctx = <CTX>::as_ref_from_ref(&args[2])?;
-
-            let res = func(&input, area, &ctx);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(3),
-            ))),
-        )
-    }
-}
-
-// TODO: @Matt - come back and fix this because its atrocious
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelValFromRef,
-        INNER: FromSteelVal + Clone + AsRefSteelValFromUnsized<INNER>,
-        F: FromSteelVal,
-        FN: Fn(&mut SELF, &[INNER], F) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper6<(SELF, F, INNER)>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 3 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 3, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let temp_res = INNER::as_ref_from_unsized(&args[1])?;
-
-            let res = func(
-                &mut input,
-                temp_res.as_slice_repr(),
-                F::from_steelval(&args[2])?,
-            );
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(3),
-            ))),
-        )
-    }
-
-    fn register_owned_fn(&mut self, name: String, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let cloned_name = name.clone();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 3 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 3, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let temp_res = INNER::as_ref_from_unsized(&args[1])?;
-
-            let res = func(
-                &mut input,
-                temp_res.as_slice_repr(),
-                F::from_steelval(&args[2])?,
-            );
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            &cloned_name.to_string(),
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-                Arc::new(f),
-                Some(cloned_name.into()),
-                Some(3),
-            ))),
-        )
-    }
-}
-
-impl<
-        // RET: IntoSteelVal,
-        'a,
-        SELF: AsRefMutSteelValFromRef + 'a,
-        SELFSTAT: AsRefMutSteelValFromRef + 'static,
-        RET: AsRefMutSteelValFromRef + 'a,
-        STATICRET: AsRefMutSteelValFromRef + 'static,
-        // INNER: FromSteelVal + Clone + AsRefSteelValFromUnsized<INNER>,
-        // F: FromSteelVal,
-        FN: (Fn(&'a mut SELF) -> &'a mut RET) + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper7<(SELF, RET, STATICRET, SELFSTAT)>, STATICRET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        // todo!()
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            let args = unsafe { std::mem::transmute::<&[SteelVal], &'static [SteelVal]>(args) };
-
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 1, args.len()));
-            }
-
-            // If this value is
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let res = func(input);
-
-            let erased = res as *mut _;
-
-            // Take the result - but we need to tie this lifetime to the existing lifetime of the parent one.
-            // So here we should have a weak reference to the existing lifetime?
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let temporary_borrowed_object =
-                crate::gc::unsafe_erased_pointers::TemporaryObject { ptr: wrapped };
-
-            let temp_borrow = unsafe {
-                std::mem::transmute::<TemporaryObject<RET>, TemporaryObject<STATICRET>>(
-                    temporary_borrowed_object,
-                )
-            };
-
-            // Allocate the rooted object here
-            OpaqueReferenceNursery::allocate(temp_borrow.into_opaque_reference());
-
-            let borrow_flag = args[0]
-                .get_borrow_flag_if_borrowed_object::<SELFSTAT>()
-                .unwrap();
-
-            // Mark as borrowed now
-            borrow_flag.set(true);
-
-            let mut borrowed = BorrowedObject::new(weak_ptr).with_parent_flag(borrow_flag);
-
-            let extended = unsafe {
-                std::mem::transmute::<BorrowedObject<RET>, BorrowedObject<STATICRET>>(borrowed)
-            };
-
-            let return_value =
-                SteelVal::Reference(Rc::new(extended.into_opaque_reference::<'static>()));
-
-            Ok(return_value)
-
-            // let weak_ptr = Rc::downgrade(&wrapped);
-
-            // todo!()
-
-            // res.into_steelval()
-        };
-
-        // todo!()
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-// TODO: Generalize this to multiple things, use more and more and more macros
-impl<
-        // RET: IntoSteelVal,
-        'a,
-        SELF: AsRefMutSteelValFromRef + 'a,
-        SELFSTAT: AsRefMutSteelValFromRef + 'static,
-        RET: AsRefSteelValFromRef + 'a,
-        STATICRET: AsRefSteelValFromRef + 'static,
-        FN: (Fn(&'a mut SELF) -> &'a RET) + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper8<(SELF, RET, STATICRET, SELFSTAT)>, STATICRET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            let args = unsafe { std::mem::transmute::<&[SteelVal], &'static [SteelVal]>(args) };
-
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 1, args.len()));
-            }
-
-            // If this value is
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let res = func(input);
-
-            let erased = res as *const _;
-
-            // Take the result - but we need to tie this lifetime to the existing lifetime of the parent one.
-            // So here we should have a weak reference to the existing lifetime?
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let temporary_borrowed_object =
-                crate::gc::unsafe_erased_pointers::ReadOnlyTemporaryObject { ptr: wrapped };
-
-            let temp_borrow = unsafe {
-                std::mem::transmute::<
-                    ReadOnlyTemporaryObject<RET>,
-                    ReadOnlyTemporaryObject<STATICRET>,
-                >(temporary_borrowed_object)
-            };
-
-            // Allocate the rooted object here
-            OpaqueReferenceNursery::allocate(temp_borrow.into_opaque_reference());
-
-            let borrow_flag = args[0]
-                .get_borrow_count_if_borrowed_object::<SELFSTAT>()
-                .unwrap();
-
-            borrow_flag.set(borrow_flag.get() + 1);
-
-            let borrowed = ReadOnlyBorrowedObject::new(weak_ptr, borrow_flag);
-
-            let extended = unsafe {
-                std::mem::transmute::<ReadOnlyBorrowedObject<RET>, ReadOnlyBorrowedObject<STATICRET>>(
-                    borrowed,
-                )
-            };
-
-            let return_value =
-                SteelVal::Reference(Rc::new(extended.into_opaque_reference::<'static>()));
-
-            Ok(return_value)
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<
-        // RET: IntoSteelVal,
-        'a,
-        SELF: AsRefMutSteelValFromRef + 'a,
-        SELFSTAT: AsRefMutSteelValFromRef + 'static,
-        RET: AsRefSteelValFromRef + 'a,
-        STATICRET: AsRefSteelValFromRef + 'static,
-        ARG: FromSteelVal,
-        FN: (Fn(&'a mut SELF, ARG) -> &'a RET) + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper8<(SELF, ARG, RET, STATICRET, SELFSTAT)>, STATICRET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            let args = unsafe { std::mem::transmute::<&[SteelVal], &'static [SteelVal]>(args) };
-
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 2, args.len()));
-            }
-
-            // If this value is
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-            let arg = ARG::from_steelval(&args[1])?;
-
-            let res = func(input, arg);
-
-            let erased = res as *const _;
-
-            // Take the result - but we need to tie this lifetime to the existing lifetime of the parent one.
-            // So here we should have a weak reference to the existing lifetime?
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let temporary_borrowed_object =
-                crate::gc::unsafe_erased_pointers::ReadOnlyTemporaryObject { ptr: wrapped };
-
-            let temp_borrow = unsafe {
-                std::mem::transmute::<
-                    ReadOnlyTemporaryObject<RET>,
-                    ReadOnlyTemporaryObject<STATICRET>,
-                >(temporary_borrowed_object)
-            };
-
-            // Allocate the rooted object here
-            OpaqueReferenceNursery::allocate(temp_borrow.into_opaque_reference());
-
-            let borrow_flag = args[0]
-                .get_borrow_count_if_borrowed_object::<SELFSTAT>()
-                .unwrap();
-
-            borrow_flag.set(borrow_flag.get() + 1);
-
-            let borrowed = ReadOnlyBorrowedObject::new(weak_ptr, borrow_flag);
-
-            let extended = unsafe {
-                std::mem::transmute::<ReadOnlyBorrowedObject<RET>, ReadOnlyBorrowedObject<STATICRET>>(
-                    borrowed,
-                )
-            };
-
-            let return_value =
-                SteelVal::Reference(Rc::new(extended.into_opaque_reference::<'static>()));
-
-            Ok(return_value)
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(2),
-            ))),
-        )
-    }
-}
-
-impl<
-        'a,
-        SELF: AsRefSteelValFromRef + 'a,
-        SELFSTAT: AsRefSteelValFromRef + 'static,
-        RET: AsRefSteelValFromRef + 'a,
-        RETSTAT: AsRefSteelValFromRef + 'static,
-        ARG: FromSteelVal,
-        FN: (Fn(&'a SELF, ARG) -> RET) + SendSyncStatic,
-    > RegisterFnBorrowed<FN, MarkerWrapper9<(SELF, ARG, SELFSTAT, RET, RETSTAT)>, RET>
-    for BuiltInModule
-{
-    fn register_fn_borrowed(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            let args = unsafe { std::mem::transmute::<&[SteelVal], &'static [SteelVal]>(args) };
-
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 2, args.len()));
-            }
-
-            // If this value is
-            let mut input = <SELF>::as_ref_from_ref(&args[0])?;
-            let arg = ARG::from_steelval(&args[1])?;
-
-            let res = func(input, arg);
-
-            // let lifted = unsafe { std::mem::transmute::<RET, RETSTAT>(res) };
-
-            // lifted.into_steelval()
-
-            let erased = res;
-
-            // Take the result - but we need to tie this lifetime to the existing lifetime of the parent one.
-            // So here we should have a weak reference to the existing lifetime?
-            let wrapped = Rc::new(erased);
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let temporary_borrowed_object =
-                crate::gc::unsafe_erased_pointers::Temporary { ptr: wrapped };
-
-            let temp_borrow = unsafe {
-                std::mem::transmute::<Temporary<RET>, Temporary<RETSTAT>>(temporary_borrowed_object)
-            };
-
-            // Allocate the rooted object here
-            OpaqueReferenceNursery::allocate(temp_borrow.into_opaque_reference());
-
-            let borrowed = ReadOnlyTemporary { ptr: weak_ptr };
-
-            let extended = unsafe {
-                std::mem::transmute::<ReadOnlyTemporary<RET>, ReadOnlyTemporary<RETSTAT>>(borrowed)
-            };
-
-            let return_value =
-                SteelVal::Reference(Rc::new(extended.into_opaque_reference::<'static>()));
-
-            Ok(return_value)
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(2),
-            ))),
-        )
-    }
-}
-
-impl<
-        'a,
-        SELF: AsRefSteelValFromRef + 'a,
-        SELFSTAT: AsRefSteelValFromRef + 'static,
-        RET: AsRefSteelValFromRef + 'a,
-        RETSTAT: AsRefSteelValFromRef + 'static,
-        FN: (Fn(&'a SELF) -> RET) + SendSyncStatic,
-    > RegisterFnBorrowed<FN, MarkerWrapper9<(SELF, SELFSTAT, RET, RETSTAT)>, RET>
-    for BuiltInModule
-{
-    fn register_fn_borrowed(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            let args = unsafe { std::mem::transmute::<&[SteelVal], &'static [SteelVal]>(args) };
-
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 1, args.len()));
-            }
-
-            // If this value is
-            let mut input = <SELF>::as_ref_from_ref(&args[0])?;
-
-            let res = func(input);
-
-            // let lifted = unsafe { std::mem::transmute::<RET, RETSTAT>(res) };
-
-            // lifted.into_steelval()
-
-            let erased = res;
-
-            // Take the result - but we need to tie this lifetime to the existing lifetime of the parent one.
-            // So here we should have a weak reference to the existing lifetime?
-            let wrapped = Rc::new(erased);
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let temporary_borrowed_object =
-                crate::gc::unsafe_erased_pointers::Temporary { ptr: wrapped };
-
-            let temp_borrow = unsafe {
-                std::mem::transmute::<Temporary<RET>, Temporary<RETSTAT>>(temporary_borrowed_object)
-            };
-
-            // Allocate the rooted object here
-            OpaqueReferenceNursery::allocate(temp_borrow.into_opaque_reference());
-
-            let borrowed = ReadOnlyTemporary { ptr: weak_ptr };
-
-            let extended = unsafe {
-                std::mem::transmute::<ReadOnlyTemporary<RET>, ReadOnlyTemporary<RETSTAT>>(borrowed)
-            };
-
-            let return_value =
-                SteelVal::Reference(Rc::new(extended.into_opaque_reference::<'static>()));
-
-            Ok(return_value)
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelVal,
-        AREA: AsRefSteelVal,
-        CTX: AsRefMutSteelValFromRef,
-        FN: Fn(&mut SELF, &AREA, &mut CTX) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper7<(SELF, AREA, CTX)>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 4 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 3, args.len()));
-            }
-
-            let mut nursery = <AREA as AsRefSteelVal>::Nursery::default();
-
-            let mut input = <SELF>::as_mut_ref(&args[0])?;
-            let mut area = <AREA>::as_ref(&args[1], &mut nursery)?;
-            let mut ctx = <CTX>::as_mut_ref_from_ref(&args[2])?;
-
-            let res = func(&mut input, &area, &mut ctx);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(3),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefSteelVal,
-        AREA: FromSteelVal,
-        CTX: AsRefSteelValFromRef,
-        FN: Fn(&SELF, AREA, &CTX) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper8<(SELF, AREA, CTX)>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 4 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 3, args.len()));
-            }
-
-            let mut nursery = <SELF as AsRefSteelVal>::Nursery::default();
-
-            let mut input = <SELF>::as_ref(&args[0], &mut nursery)?;
-            let mut area = <AREA>::from_steelval(&args[1])?;
-            let mut ctx = <CTX>::as_ref_from_ref(&args[2])?;
-
-            let res = func(&input, area, &ctx);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(3),
-            ))),
-        )
-    }
-}
-
-// TODO: @Matt - come back and fix this because its atrocious
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelValFromRef,
-        INNER: FromSteelVal + Clone + AsRefSteelValFromUnsized<INNER>,
-        F: FromSteelVal,
-        FN: Fn(&mut SELF, &[INNER], F) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper6<(SELF, F, INNER)>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 3 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let temp_res = INNER::as_ref_from_unsized(&args[1])?;
-
-            let res = func(
-                &mut input,
-                temp_res.as_slice_repr(),
-                F::from_steelval(&args[2])?,
-            );
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(3),
-            ))),
-        )
-    }
-
-    fn register_owned_fn(&mut self, name: String, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let cloned_name = name.clone();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 3 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let temp_res = INNER::as_ref_from_unsized(&args[1])?;
-
-            let res = func(
-                &mut input,
-                temp_res.as_slice_repr(),
-                F::from_steelval(&args[2])?,
-            );
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            &cloned_name.to_string(),
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-                Arc::new(f),
-                Some(cloned_name.into()),
-                Some(3),
-            ))),
-        )
-    }
-}
-
-impl<
-        // RET: IntoSteelVal,
-        'a,
-        SELF: AsRefMutSteelValFromRef + 'a,
-        SELFSTAT: AsRefMutSteelValFromRef + 'static,
-        RET: AsRefMutSteelValFromRef + 'a,
-        STATICRET: AsRefMutSteelValFromRef + 'static,
-        // INNER: FromSteelVal + Clone + AsRefSteelValFromUnsized<INNER>,
-        // F: FromSteelVal,
-        FN: (Fn(&'a mut SELF) -> &'a mut RET) + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper7<(SELF, RET, STATICRET, SELFSTAT)>, STATICRET>
-    for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        // todo!()
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            let args = unsafe { std::mem::transmute::<&[SteelVal], &'static [SteelVal]>(args) };
-
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 1, args.len()));
-            }
-
-            // If this value is
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let res = func(input);
-
-            let erased = res as *mut _;
-
-            // Take the result - but we need to tie this lifetime to the existing lifetime of the parent one.
-            // So here we should have a weak reference to the existing lifetime?
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let temporary_borrowed_object =
-                crate::gc::unsafe_erased_pointers::TemporaryObject { ptr: wrapped };
-
-            let temp_borrow = unsafe {
-                std::mem::transmute::<TemporaryObject<RET>, TemporaryObject<STATICRET>>(
-                    temporary_borrowed_object,
-                )
-            };
-
-            // Allocate the rooted object here
-            OpaqueReferenceNursery::allocate(temp_borrow.into_opaque_reference());
-
-            let borrow_flag = args[0]
-                .get_borrow_flag_if_borrowed_object::<SELFSTAT>()
-                .unwrap();
-
-            borrow_flag.set(true);
-
-            let borrowed = BorrowedObject::new(weak_ptr).with_parent_flag(borrow_flag);
-
-            let extended = unsafe {
-                std::mem::transmute::<BorrowedObject<RET>, BorrowedObject<STATICRET>>(borrowed)
-            };
-
-            let return_value =
-                SteelVal::Reference(Rc::new(extended.into_opaque_reference::<'static>()));
-
-            Ok(return_value)
-
-            // let weak_ptr = Rc::downgrade(&wrapped);
-
-            // todo!()
-
-            // res.into_steelval()
-        };
-
-        // todo!()
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-// TODO: Generalize this to multiple things, use more and more and more macros
-impl<
-        // RET: IntoSteelVal,
-        'a,
-        SELF: AsRefMutSteelValFromRef + 'a,
-        SELFSTAT: AsRefMutSteelValFromRef + 'static,
-        RET: AsRefSteelValFromRef + 'a,
-        STATICRET: AsRefSteelValFromRef + 'static,
-        FN: (Fn(&'a mut SELF) -> &'a RET) + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper8<(SELF, RET, STATICRET, SELFSTAT)>, STATICRET>
-    for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            let args = unsafe { std::mem::transmute::<&[SteelVal], &'static [SteelVal]>(args) };
-
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 1, args.len()));
-            }
-
-            // If this value is
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let res = func(input);
-
-            let erased = res as *const _;
-
-            // Take the result - but we need to tie this lifetime to the existing lifetime of the parent one.
-            // So here we should have a weak reference to the existing lifetime?
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let temporary_borrowed_object =
-                crate::gc::unsafe_erased_pointers::ReadOnlyTemporaryObject { ptr: wrapped };
-
-            let temp_borrow = unsafe {
-                std::mem::transmute::<
-                    ReadOnlyTemporaryObject<RET>,
-                    ReadOnlyTemporaryObject<STATICRET>,
-                >(temporary_borrowed_object)
-            };
-
-            // Allocate the rooted object here
-            OpaqueReferenceNursery::allocate(temp_borrow.into_opaque_reference());
-
-            let borrow_flag = args[0]
-                .get_borrow_count_if_borrowed_object::<SELFSTAT>()
-                .unwrap();
-
-            borrow_flag.set(borrow_flag.get() + 1);
-
-            // TODO: Mark the parent as borrowed -> Can't be access again until
-            // the child value is out of scope. We shouldn't have a problem with RO values
-            // from this point, since everything can be read
-            let borrowed = ReadOnlyBorrowedObject::new(weak_ptr, borrow_flag);
-
-            let extended = unsafe {
-                std::mem::transmute::<ReadOnlyBorrowedObject<RET>, ReadOnlyBorrowedObject<STATICRET>>(
-                    borrowed,
-                )
-            };
-
-            let return_value =
-                SteelVal::Reference(Rc::new(extended.into_opaque_reference::<'static>()));
-
-            Ok(return_value)
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<
-        // RET: IntoSteelVal,
-        'a,
-        SELF: AsRefMutSteelValFromRef + 'a,
-        SELFSTAT: AsRefMutSteelValFromRef + 'static,
-        RET: AsRefSteelValFromRef + 'a,
-        STATICRET: AsRefSteelValFromRef + 'static,
-        ARG: FromSteelVal,
-        FN: (Fn(&'a mut SELF, ARG) -> &'a RET) + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper8<(SELF, ARG, RET, STATICRET, SELFSTAT)>, STATICRET>
-    for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            let args = unsafe { std::mem::transmute::<&[SteelVal], &'static [SteelVal]>(args) };
-
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 2, args.len()));
-            }
-
-            // If this value is
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-            let arg = ARG::from_steelval(&args[1])?;
-
-            let res = func(input, arg);
-
-            let erased = res as *const _;
-
-            // Take the result - but we need to tie this lifetime to the existing lifetime of the parent one.
-            // So here we should have a weak reference to the existing lifetime?
-            let wrapped = Rc::new(RefCell::new(erased));
-            let weak_ptr = Rc::downgrade(&wrapped);
-
-            let temporary_borrowed_object =
-                crate::gc::unsafe_erased_pointers::ReadOnlyTemporaryObject { ptr: wrapped };
-
-            let temp_borrow = unsafe {
-                std::mem::transmute::<
-                    ReadOnlyTemporaryObject<RET>,
-                    ReadOnlyTemporaryObject<STATICRET>,
-                >(temporary_borrowed_object)
-            };
-
-            // Allocate the rooted object here
-            OpaqueReferenceNursery::allocate(temp_borrow.into_opaque_reference());
-
-            let borrow_flag = args[0]
-                .get_borrow_count_if_borrowed_object::<SELFSTAT>()
-                .unwrap();
-
-            borrow_flag.set(borrow_flag.get() + 1);
-
-            let borrowed = ReadOnlyBorrowedObject::new(weak_ptr, borrow_flag);
-
-            let extended = unsafe {
-                std::mem::transmute::<ReadOnlyBorrowedObject<RET>, ReadOnlyBorrowedObject<STATICRET>>(
-                    borrowed,
-                )
-            };
-
-            let return_value =
-                SteelVal::Reference(Rc::new(extended.into_opaque_reference::<'static>()));
-
-            Ok(return_value)
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(2),
-            ))),
-        )
-    }
-}
-
-// impl<
-//         RET: IntoSteelVal,
-//         SELF: AsRefMutSteelValFromRef,
-//         INNER: FromSteelVal,
-//         F: FromSteelVal,
-//         FN: Fn(&mut SELF, INNER, F) -> RET + 'static,
-//     > RegisterFn<FN, MarkerWrapper7<(SELF, F, INNER)>, RET> for BuiltInModule
-// {
-//     fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-//         // use std::Borrow();
-
-//         let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-//             if args.len() != 3 {
-//                 stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-//             }
-
-//             let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-//             let temp_res = INNER::from_steelval(&args[1])?;
-
-//             let res = func(&mut input, temp_res, F::from_steelval(&args[2])?);
-
-//             res.into_steelval()
-//         };
-
-//         self.register_value(
-//             name,
-//             SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-//                 Box::new(f),
-//                 Some(name),
-//                 Some(1),
-//             ))),
-//         )
-//     }
-
-//     // TODO: Make this use not a static string since we _could_ have dynamic names
-//     fn register_owned_fn(&mut self, name: String, func: FN) -> &mut Self {
-//         // use std::Borrow();
-
-//         let cloned_name = name.clone();
-
-//         let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-//             if args.len() != 3 {
-//                 stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-//             }
-
-//             let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-//             let temp_res = INNER::from_steelval(&args[1])?;
-
-//             let res = func(&mut input, temp_res, F::from_steelval(&args[2])?);
-
-//             res.into_steelval()
-//         };
-
-//         self.register_value(
-//             &cloned_name.clone(),
-//             SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-//                 Box::new(f),
-//                 Some(Rc::new(cloned_name)),
-//                 Some(1),
-//             ))),
-//         )
-//     }
-// }
-
-impl<
-        FUT: Future<Output = RET> + 'static,
-        RET: IntoSteelVal + 'static,
-        FN: Fn() -> FUT + SendSyncStatic,
-    > RegisterFn<FN, AsyncWrapper<()>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<FutureResult> {
-            if !args.is_empty() {
-                stop!(ArityMismatch => format!("{} expected 0 arguments, got {}", name, args.len()));
-            }
-
-            let res = func();
-
-            Ok(FutureResult::new(Box::pin(res.map(|x| x.into_steelval()))))
-        };
-
-        self.register_value(name, SteelVal::FutureFunc(Box::new(Rc::new(f))))
-    }
-}
-
-impl<RET: IntoSteelVal, FN: Fn() -> RET + SendSyncStatic> RegisterFn<FN, Wrapper<()>, RET>
-    for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if !args.is_empty() {
-                stop!(ArityMismatch => format!("{} expected 0 arguments, got {}", name, args.len()));
-            }
-
-            let res = func();
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(0),
-            ))),
-        )
-    }
-}
-
-impl<RET: IntoSteelVal, SELF: AsRefSteelVal, FN: Fn(&SELF) -> RET + SendSyncStatic>
-    RegisterFn<FN, MarkerWrapper1<SELF>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut nursery = <SELF::Nursery>::default();
-
-            let input = <SELF>::as_ref(&args[0], &mut nursery)?;
-
-            let res = func(&input);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-
-    fn register_owned_fn(&mut self, name: String, func: FN) -> &mut Self {
-        let name = Rc::new(name);
-        let cloned_name = Rc::clone(&name);
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 1, args.len()));
-            }
-
-            let mut nursery = <SELF::Nursery>::default();
-
-            let input = <SELF>::as_ref(&args[0], &mut nursery)?;
-
-            let res = func(&input);
-
-            res.into_steelval()
-        };
-
-        todo!("Resolve using RC's here")
-
-        // self.register_value(
-        //     &Rc::clone(&cloned_name),
-        //     SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-        //         Arc::new(f),
-        //         Some(cloned_name),
-        //         Some(1),
-        //     ))),
-        // )
-    }
-}
-
-impl<RET: IntoSteelVal, SELF: AsRefMutSteelVal, FN: Fn(&mut SELF) -> RET + SendSyncStatic>
-    RegisterFn<FN, MarkerWrapper2<SELF>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref(&args[0])?;
-
-            let res = func(&mut input);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        SELF: AsRefMutSteelValFromRef,
-        FN: Fn(&mut SELF) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper5<SELF>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-            let res = func(&mut input);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<RET: IntoSteelVal, SELF: AsRefSteelValFromRef, FN: Fn(&SELF) -> RET + SendSyncStatic>
-    RegisterFn<FN, MarkerWrapper8<SELF>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut input = <SELF>::as_ref_from_ref(&args[0])?;
-
-            let res = func(&mut input);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-impl<
-        RET: IntoSteelVal,
-        ARG: FromSteelVal,
-        SELF: AsRefSteelValFromRef,
-        FN: Fn(&SELF, ARG) -> RET + SendSyncStatic,
-    > RegisterFn<FN, MarkerWrapper8<(SELF, ARG)>, RET> for BuiltInModule
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut input = <SELF>::as_ref_from_ref(&args[0])?;
-            let arg = <ARG>::from_steelval(&args[1]).map_err(|mut err| {
-                err.prepend_message(":");
-                err.prepend_message(name);
-                err
-            })?;
-
-            let res = func(&mut input, arg);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(2),
-            ))),
-        )
-    }
-}
-
-impl<RET: IntoSteelVal, SELF: AsRefSteelValFromRef, FN: Fn(&SELF) -> RET + SendSyncStatic>
-    RegisterFn<FN, MarkerWrapper8<SELF>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        // use std::Borrow();
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 0, args.len()));
-            }
-
-            let mut input = <SELF>::as_ref_from_ref(&args[0])?;
-
-            let res = func(&mut input);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(1),
-            ))),
-        )
-    }
-}
-
-// pub struct Marker {}
-
-pub struct MarkerWrapper1<ARGS>(PhantomData<ARGS>);
-pub struct MarkerWrapper2<ARGS>(PhantomData<ARGS>);
-pub struct MarkerWrapper3<ARGS>(PhantomData<ARGS>);
-
-pub struct MarkerWrapper4<ARGS>(PhantomData<ARGS>);
-
-pub struct MarkerWrapper5<ARGS>(PhantomData<ARGS>);
-
-pub struct MarkerWrapper6<ARGS>(PhantomData<ARGS>);
-pub struct MarkerWrapper7<ARGS>(PhantomData<ARGS>);
-pub struct MarkerWrapper8<ARGS>(PhantomData<ARGS>);
-
-pub struct MarkerWrapper9<ARGS>(PhantomData<ARGS>);
-
-impl<
-        A: AsRefSteelVal,
-        B: AsRefSteelVal,
-        FN: Fn(&A, &B) -> RET + SendSyncStatic,
-        RET: IntoSteelVal,
-    > RegisterFn<FN, MarkerWrapper1<(A, B)>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 2, args.len()));
-            }
-
-            let mut nursery = <A::Nursery>::default();
-
-            let one = A::as_ref(&args[0], &mut nursery)?;
-
-            let mut nursery = <B::Nursery>::default();
-
-            let two = B::as_ref(&args[1], &mut nursery)?;
-
-            let res = func(&one, &two);
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(2),
-            ))),
-        )
-    }
-}
-
-impl<
-        A: FromSteelVal,
-        B: AsRefSteelVal,
-        FN: Fn(A, &B) -> RET + SendSyncStatic,
-        RET: IntoSteelVal,
-    > RegisterFn<FN, MarkerWrapper2<(A, B)>, RET> for Engine
-{
-    fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, 2, args.len()));
-            }
-
-            let mut nursery = <B::Nursery>::default();
-
-            let input = B::as_ref(&args[1], &mut nursery)?;
-
-            let res = func(
-                A::from_steelval(&args[0]).map_err(|mut err| {
-                    err.prepend_message(":");
-                    err.prepend_message(name);
-                    err
-                })?,
-                &input,
-            );
-
-            res.into_steelval()
-        };
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f),
-                Some(name),
-                Some(2),
-            ))),
-        )
-    }
-}
-
-macro_rules! impl_register_fn {
-    ($arg_count:expr => $($param:ident: $idx:expr),*) => {
-        impl<
-            $($param: FromSteelVal,)*
-            FN: Fn($($param),*) -> RET + SendSyncStatic,
-            RET: IntoSteelVal
-        > RegisterFn<FN, Wrapper<($($param,)*)>, RET> for Engine {
-            fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-                let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-                    if args.len() != $arg_count {
-                        stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-                    }
-
-                    let res = func($(<$param>::from_steelval(&args[$idx]).map_err(|mut err| {
-                        err.prepend_message(":");
-                        err.prepend_message(name);
-                        err
-                    })?,)*);
-
-                    res.into_steelval()
-                };
-
-                self.register_value(
-                    name,
-                    SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                        Arc::new(f),
-                        Some(name),
-                        Some($arg_count),
-                    ))),
-                )
-            }
-        }
-
-        impl<
-            $($param: FromSteelVal,)*
-            FN: Fn($($param),*) -> RET + SendSyncStatic,
-            RET: IntoSteelVal
-        > RegisterFn<FN, Wrapper<($($param,)*)>, RET> for BuiltInModule {
-            fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-                let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-                    if args.len() != $arg_count {
-                        stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-                    }
-
-                    let res = func($(<$param>::from_steelval(&args[$idx]).map_err(|mut err| {
-                        err.prepend_message(":");
-                        err.prepend_message(name);
-                        err
-                    })?,)*);
-
-                    res.into_steelval()
-                };
-
-                self.register_value(
-                    name,
-                    SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                        Arc::new(f),
-                        Some(name),
-                        Some($arg_count),
-                    ))),
-                )
-            }
-        }
-
-
-        // Async functions
-
-        impl<
-            FUT: Future<Output = RET> + 'static,
-            $($param: FromSteelVal,)*
-            FN: Fn($($param),*) -> FUT + SendSyncStatic,
-            RET: IntoSteelVal
-        > RegisterFn<FN, AsyncWrapper<($($param,)*)>, RET> for Engine {
-            fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-                let f = move |args: &[SteelVal]| -> Result<FutureResult> {
-                    if args.len() != $arg_count {
-                        stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-                    }
-
-                    let res = func($(<$param>::from_steelval(&args[$idx])?,)*);
-
-                    Ok(FutureResult::new(Box::pin(res.map(|x| x.into_steelval()))))
-                };
-
-                self.register_value(name, SteelVal::FutureFunc(Box::new(Rc::new(f))))
-            }
-        }
-
-        impl<
-            FUT: Future<Output = RET> + 'static,
-            $($param: FromSteelVal,)*
-            FN: Fn($($param),*) -> FUT + SendSyncStatic,
-            RET: IntoSteelVal
-        > RegisterFn<FN, AsyncWrapper<($($param,)*)>, RET> for BuiltInModule {
-            fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-                let f = move |args: &[SteelVal]| -> Result<FutureResult> {
-                    if args.len() != $arg_count {
-                        stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-                    }
-
-                    let res = func($(<$param>::from_steelval(&args[$idx])?,)*);
-
-                    Ok(FutureResult::new(Box::pin(res.map(|x| x.into_steelval()))))
-                };
-
-                self.register_value(name, SteelVal::FutureFunc(Box::new(Rc::new(f))))
-            }
-        }
-    };
-}
-
-macro_rules! impl_register_fn_self {
-    ($arg_count:expr => $($param:ident: $idx:expr),*) => {
-        impl<
-            T: RegisterValue,
-            SELF: AsRefSteelVal,
-            $($param: FromSteelVal,)*
-            FN: Fn(&SELF, $($param),*) -> RET + SendSyncStatic,
-            RET: IntoSteelVal
-        > RegisterFn<FN, MarkerWrapper3<(SELF, $($param,)*)>, RET> for T {
-            fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-                let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-                    if args.len() != $arg_count {
-                        stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-                    }
-
-                    let mut nursery = <SELF::Nursery>::default();
-
-                    let input = <SELF>::as_ref(&args[0], &mut nursery)?;
-
-                    let res = func(&input, $(<$param>::from_steelval(&args[$idx]).map_err(|mut err| {
-                                    err.prepend_message(":");
-                                    err.prepend_message(name);
-                                    err
-                              })?,)*);
-
-                    res.into_steelval()
-                };
-
-                self.register_value_inner(
-                    name,
-                    SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                        Arc::new(f),
-                        Some(name),
-                        Some($arg_count),
-                    ))),
-                )
-            }
-        }
-
-        impl<
-            T: RegisterValue,
-            SELF: AsRefMutSteelVal,
-            $($param: FromSteelVal,)*
-            FN: Fn(&mut SELF, $($param),*) -> RET + SendSyncStatic,
-            RET: IntoSteelVal
-        > RegisterFn<FN, MarkerWrapper4<(SELF, $($param,)*)>, RET> for T {
-            fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-                let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-                    if args.len() != $arg_count {
-                        stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-                    }
-
-                    let mut input = <SELF>::as_mut_ref(&args[0])?;
-
-                    let res = func(&mut input, $(<$param>::from_steelval(&args[$idx]).map_err(|mut err| {
-                            err.prepend_message(":");
-                            err.prepend_message(name);
-                            err
-                        })?,)*);
-
-                    res.into_steelval()
-                };
-
-                self.register_value_inner(
-                    name,
-                    SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                        Arc::new(f),
-                        Some(name),
-                        Some($arg_count),
-                    ))),
-                )
-            }
-        }
-
-        impl<
-            T: RegisterValue,
-            SELF: AsRefMutSteelValFromRef,
-            $($param: FromSteelVal,)*
-            FN: Fn(&mut SELF, $($param),*) -> RET + SendSyncStatic,
-            RET: IntoSteelVal
-        > RegisterFn<FN, MarkerWrapper5<(SELF, $($param,)*)>, RET> for T {
-            fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-                let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-                    if args.len() != $arg_count {
-                        stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-                    }
-
-                    let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-                    let res = func(&mut input, $(<$param>::from_steelval(&args[$idx]).map_err(|mut err| {
-                            err.prepend_message(":");
-                            err.prepend_message(name);
-                            err
-                        })?,)*);
-
-                    res.into_steelval()
-                };
-
-                self.register_value_inner(
-                    name,
-                    SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                        Arc::new(f),
-                        Some(name),
-                        Some($arg_count),
-                    ))),
-                )
-            }
-
-
-        fn register_owned_fn(&mut self, name: String, func: FN) -> &mut Self {
-
-            let cloned_name = name.clone();
-
-             let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-                 if args.len() != $arg_count {
-                     stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-                 }
-
-                 let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-                 let res = func(&mut input, $(<$param>::from_steelval(&args[$idx])?,)*);
-
-                 res.into_steelval()
-             };
-
-             self.register_value_inner(
-                 &cloned_name.to_string(),
-                 SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-                     Arc::new(f),
-                     Some(Arc::new(cloned_name)),
-                     Some($arg_count),
-                 ))),
-             )
-         }
-
-        }
-
-        // impl<
-        //     T: RegisterValue,
-        //     SELF: AsRefSteelVal,
-        //     $($param: FromSteelVal,)*
-        //     FN: Fn(&SELF, $($param),*) -> RET + SendSyncStatic,
-        //     RET: IntoSteelVal
-        // > RegisterFn<FN, MarkerWrapper1<(SELF, $($param,)*)>, RET> for BuiltInModule {
-        //     fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        //         let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-        //             if args.len() != $arg_count {
-        //                 stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-        //             }
-
-        //             let mut nursery = <SELF::Nursery>::default();
-
-        //             let input = <SELF>::as_ref(&args[0], &mut nursery)?;
-
-        //             let res = func(&input, $(<$param>::from_steelval(&args[$idx])?,)*);
-
-        //             res.into_steelval()
-        //         };
-
-        //         self.register_value(
-        //             name,
-        //             SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-        //                 Arc::new(f),
-        //                 Some(name),
-        //                 Some($arg_count),
-        //             ))),
-        //         )
-        //     }
-        // }
-
-        // impl<
-        //     SELF: AsRefMutSteelVal,
-        //     $($param: FromSteelVal,)*
-        //     FN: Fn(&mut SELF, $($param),*) -> RET + SendSyncStatic,
-        //     RET: IntoSteelVal
-        // > RegisterFn<FN, MarkerWrapper3<(SELF, $($param,)*)>, RET> for BuiltInModule {
-        //     fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        //         let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-        //             if args.len() != $arg_count {
-        //                 stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-        //             }
-
-        //             let mut input = <SELF>::as_mut_ref(&args[0])?;
-
-        //             let res = func(&mut input, $(<$param>::from_steelval(&args[$idx])?,)*);
-
-        //             res.into_steelval()
-        //         };
-
-        //         self.register_value(
-        //             name,
-        //             SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-        //                 Arc::new(f),
-        //                 Some(name),
-        //                 Some($arg_count),
-        //             ))),
-        //         )
-        //     }
-        // }
-
-        // impl<
-        //     SELF: AsRefMutSteelValFromRef,
-        //     $($param: FromSteelVal,)*
-        //     FN: Fn(&mut SELF, $($param),*) -> RET + SendSyncStatic,
-        //     RET: IntoSteelVal
-        // > RegisterFn<FN, MarkerWrapper5<(SELF, $($param,)*)>, RET> for BuiltInModule {
-        //     fn register_fn(&mut self, name: &'static str, func: FN) -> &mut Self {
-        //         let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-        //             if args.len() != $arg_count {
-        //                 stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-        //             }
-
-        //             let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-        //             let res = func(&mut input, $(<$param>::from_steelval(&args[$idx])?,)*);
-
-        //             res.into_steelval()
-        //         };
-
-        //         self.register_value(
-        //             name,
-        //             SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-        //                 Arc::new(f),
-        //                 Some(name),
-        //                 Some($arg_count),
-        //             ))),
-        //         )
-        //     }
-
-        //     fn register_owned_fn(&mut self, name: String, func: FN) -> &mut Self {
-
-        //         let cloned_name = name.clone();
-
-        //         let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-        //             if args.len() != $arg_count {
-        //                 stop!(ArityMismatch => format!("{} expected {} argument, got {}", name, $arg_count, args.len()));
-        //             }
-
-        //             let mut input = <SELF>::as_mut_ref_from_ref(&args[0])?;
-
-        //             let res = func(&mut input, $(<$param>::from_steelval(&args[$idx])?,)*);
-
-        //             res.into_steelval()
-        //         };
-
-        //         self.register_value(
-        //             &cloned_name.to_string(),
-        //             SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-        //                 Arc::new(f),
-        //                 Some(Arc::new(cloned_name)),
-        //                 Some($arg_count),
-        //             ))),
-        //         )
-        //     }
-        // }
-    };
-}
-
-impl_register_fn!(1 => A:0);
-impl_register_fn!(2 => A:0, B:1);
-impl_register_fn!(3 => A:0, B:1, C:2);
-impl_register_fn!(4 => A:0, B:1, C:2, D:3);
-impl_register_fn!(5 => A:0, B:1, C:2, D:3, E:4);
-impl_register_fn!(6 => A:0, B:1, C:2, D:3, E:4, F:5);
-impl_register_fn!(7 => A:0, B:1, C:2, D:3, E:4, F:5, G:6);
-impl_register_fn!(8 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7);
-impl_register_fn!(9 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8);
-impl_register_fn!(10 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9);
-impl_register_fn!(11 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10);
-impl_register_fn!(12 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11);
-impl_register_fn!(13 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12);
-impl_register_fn!(14 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 13);
-impl_register_fn!(15 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 13, O: 14);
-impl_register_fn!(16 => A:0, B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 14, O: 14, P: 15);
-
-impl_register_fn_self!(2 => B:1);
-impl_register_fn_self!(3 => B:1, C:2);
-impl_register_fn_self!(4 => B:1, C:2, D:3);
-impl_register_fn_self!(5 => B:1, C:2, D:3, E:4);
-impl_register_fn_self!(6 => B:1, C:2, D:3, E:4, F:5);
-impl_register_fn_self!(7 => B:1, C:2, D:3, E:4, F:5, G:6);
-impl_register_fn_self!(8 => B:1, C:2, D:3, E:4, F:5, G:6, H:7);
-impl_register_fn_self!(9 => B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8);
-impl_register_fn_self!(10 => B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9);
-impl_register_fn_self!(11 => B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10);
-impl_register_fn_self!(12 => B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11);
-impl_register_fn_self!(13 => B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12);
-impl_register_fn_self!(14 => B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 13);
-impl_register_fn_self!(15 => B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 13, O: 14);
-impl_register_fn_self!(16 => B:1, C:2, D:3, E:4, F:5, G:6, H:7, I:8, J:9, K:10, L:11, M: 12, N: 14, O: 14, P: 15);
-
-// Generate the combinations for up to arity 5?
-mod generated_impls {
-
-    use super::*;
-
-    pub struct FakeEngine {}
-
-    #[derive(Clone)]
-    struct FooBarBaz {}
-
-    impl crate::rvals::Custom for FooBarBaz {}
-
-    // Check the status of the code gen. Eventually we're going to pivot this to just be a blanket implementation
-    // against anything that implements `RegisterValue`
-    // #[test]
-    // fn check_engine_light() {
-    //     let mut engine = FakeEngine {};
-
-    //     engine.register_fn(
-    //         "applesauce",
-    //         |foo: FooBarBaz,
-    //          bar: &FooBarBaz,
-    //          baz: &mut FooBarBaz,
-    //          quux: FooBarBaz,
-    //          qux: FooBarBaz| todo!(),
-    //     );
-    // }
-
-    struct MarkerWrapper<ARGS>(PhantomData<ARGS>);
-
-    impl FakeEngine {
-        pub fn register_value(&mut self, name: &str, value: SteelVal) -> &mut Self {
-            todo!()
-        }
-    }
-
-    // TODO: Come up with better MarkerWrapper<ARGS>(PhantomData<ARGS>); -> This is gonna be nasty.
-    // include!(concat!(env!("OUT_DIR"), "/generated.rs"));
-}
diff --git a/crates/steel-core/src/steel_vm/test_util.rs b/crates/steel-core/src/steel_vm/test_util.rs
deleted file mode 100644
index 95cda4792..000000000
--- a/crates/steel-core/src/steel_vm/test_util.rs
+++ /dev/null
@@ -1,27 +0,0 @@
-use super::engine::Engine;
-use crate::stdlib::PRELUDE;
-
-#[test]
-fn prelude_parses() {
-    let mut vm = Engine::new();
-    vm.compile_and_run_raw_program(PRELUDE).unwrap();
-}
-
-#[cfg(test)]
-fn generate_asserting_machine() -> Engine {
-    // vm.compile_and_run_raw_program(PRELUDE).unwrap();
-    // vm.compile_and_run_raw_program(CONTRACTS).unwrap();
-    Engine::new()
-}
-
-#[cfg(test)]
-pub(crate) fn assert_script<T: AsRef<str>>(script: T) {
-    let mut vm = generate_asserting_machine();
-    assert!(vm.compile_and_run_raw_program(script.as_ref()).is_ok());
-}
-
-#[cfg(test)]
-pub(crate) fn assert_script_error<T: AsRef<str>>(script: T) {
-    let mut vm = generate_asserting_machine();
-    assert!(vm.compile_and_run_raw_program(script.as_ref()).is_err());
-}
diff --git a/crates/steel-core/src/steel_vm/tests.rs b/crates/steel-core/src/steel_vm/tests.rs
deleted file mode 100644
index 8b6c4c7d0..000000000
--- a/crates/steel-core/src/steel_vm/tests.rs
+++ /dev/null
@@ -1,578 +0,0 @@
-#[cfg(test)]
-mod call_cc_tests {
-    use crate::steel_vm::engine::Engine;
-    use crate::steel_vm::register_fn::RegisterFn;
-
-    #[test]
-    fn test_async() {
-        async fn test_function() -> usize {
-            10 + await_within().await
-        }
-
-        async fn await_within() -> usize {
-            25
-        }
-
-        let mut vm = Engine::new();
-
-        // You can even register async finctions
-        vm.register_fn("test", test_function);
-
-        let contents = r#"
-        ; *thread-queue* : list[continuation]
-        (define *thread-queue* '())
-
-        ; halt : continuation
-        (define halt #f)
-
-        ; current-continuation : -> continuation
-        (define (current-continuation)
-            (call/cc
-                (lambda (cc)
-                    (cc cc))))
-
-        ; await : future -> value
-        ; yield the current thread and loop until the value is completed
-        (define (await future)
-            (define output (poll! future))
-            (if output
-                output
-                (begin
-                    (yield)
-                    (await future))))
-
-        ; spawn : (-> anything) -> void
-        (define (spawn thunk)
-        (let ((cc (current-continuation)))
-            (if (continuation? cc)
-                (set! *thread-queue* (append *thread-queue* (list cc)))
-                (begin 
-                    (thunk)
-                    (quit)))))
-
-        ; yield : value -> void
-        (define (yield)
-        (let ((cc (current-continuation)))
-            (if (and (continuation? cc) (pair? *thread-queue*))
-                (let ((next-thread (car *thread-queue*)))
-                (set! *thread-queue* (append (cdr *thread-queue*) (list cc)))
-                (next-thread 'resume))
-                void)))
-
-        ; quit : -> ...
-        (define (quit)
-        (if (pair? *thread-queue*)
-            (let ((next-thread (car *thread-queue*)))
-                (set! *thread-queue* (cdr *thread-queue*))
-                (next-thread 'resume))
-            (halt)))
-        
-        ; start-threads : -> ...
-        (define (start-threads)
-        (let ((cc (current-continuation)))
-            (if cc
-                (begin
-                (set! halt (lambda () (cc #f)))
-                (if (null? *thread-queue*)
-                    void
-                    (begin
-                        (let ((next-thread (car *thread-queue*)))
-                        (set! *thread-queue* (cdr *thread-queue*))
-                        (next-thread 'resume)))))
-                void)))
-
-
-        ;; Example cooperatively threaded program
-        (define counter 10)
-
-        (define (make-thread-thunk name)
-        (define (loop)
-                (when (< counter 0)
-                    (quit))
-                (display "in thread ")
-                (display name)
-                (display "; counter = ")
-                (display counter)
-                (newline)
-                (set! counter (- counter 1))
-                (define output (await (test))) ;; block the execution of this thread on this future
-                (display "Future done!: ")
-                (display output)
-                (newline)
-                (yield)
-                (loop))
-        loop)
-
-        (spawn (make-thread-thunk 'a))
-        (spawn (make-thread-thunk 'b))
-        (spawn (make-thread-thunk 'c))
-
-        (start-threads)
-        "#;
-
-        vm.compile_and_run_raw_program(contents).unwrap();
-
-        assert_eq!(vm.extract::<isize>("counter").unwrap(), -1);
-    }
-}
-
-#[cfg(test)]
-mod register_fn_tests {
-    use crate::steel_vm::engine::Engine;
-    use crate::steel_vm::register_fn::RegisterFn;
-
-    fn external_function(arg1: usize, arg2: usize) -> usize {
-        arg1 + arg2
-    }
-
-    fn option_function(arg1: Option<String>) -> Option<String> {
-        arg1
-    }
-
-    fn result_function(arg1: Option<String>) -> Result<String, String> {
-        if let Some(inner) = arg1 {
-            Ok(inner)
-        } else {
-            Err("Got a none".to_string())
-        }
-    }
-
-    fn add_one(arg: usize) -> usize {
-        arg + 1
-    }
-
-    fn always_true(_arg: usize) -> bool {
-        true
-    }
-
-    fn empty_function() {}
-
-    #[test]
-    fn test_register_fn() {
-        let mut vm = Engine::new();
-
-        // Here we can register functions
-        // Any function can accept parameters that implement `FromSteelVal` and
-        // return values that implement `IntoSteelVal`
-        vm.register_fn("external-function", external_function);
-
-        // See the docs for more information about `FromSteelVal` and `IntoSteelVal`
-        // but we can see even functions that accept/return Option<T> or Result<T,E>
-        // can be registered
-        vm.register_fn("option-function", option_function);
-
-        // Result values will map directly to errors in the VM and bubble back up
-        vm.register_fn("result-function", result_function);
-
-        // functions that return () return void
-        vm.register_fn("empty-function", empty_function);
-
-        vm.register_fn("adding-one", add_one);
-        vm.register_fn("always-true", always_true);
-
-        vm.compile_and_run_raw_program(
-            r#"
-        (define foo (external-function 10 25))
-        (define bar (option-function "applesauce"))
-        (define baz (result-function "bananas"))
-        (define res (transduce (range 0 10) 
-                               (taking 5) 
-                               (into-reducer external-function 0)))
-        (assert! (equal? (map adding-one '(0 1 2 3)) '(1 2 3 4)))
-        (assert! (equal? (filter always-true '(0 1 2 3)) '(0 1 2 3)))
-        (empty-function)
-    "#,
-        )
-        .unwrap();
-
-        let foo = vm.extract::<usize>("foo").unwrap();
-        assert_eq!(35, foo);
-
-        // Can also extract a value by specifying the type on the variable
-        let bar: String = vm.extract("bar").unwrap();
-        assert_eq!("applesauce".to_string(), bar);
-
-        let baz: String = vm.extract("baz").unwrap();
-        assert_eq!("bananas".to_string(), baz);
-
-        let res: usize = vm.extract("res").unwrap();
-        assert_eq!(10, res);
-    }
-}
-
-#[cfg(test)]
-mod register_type_tests {
-    use crate::steel_vm::engine::Engine;
-    use crate::steel_vm::register_fn::RegisterFn;
-
-    // In order to register a type with Steel,
-    // it must implement Clone, Debug, and Steel
-    #[derive(Clone, Debug, PartialEq)]
-    pub struct ExternalStruct {
-        foo: usize,
-        bar: String,
-        baz: f64,
-    }
-
-    impl crate::rvals::Custom for ExternalStruct {}
-
-    impl ExternalStruct {
-        pub fn new(foo: usize, bar: String, baz: f64) -> Self {
-            ExternalStruct { foo, bar, baz }
-        }
-
-        // Embedding functions that take self must take by value
-        pub fn method_by_value(self) -> usize {
-            self.foo
-        }
-
-        // Setters should update the value and return a new instance (functional set)
-        pub fn set_foo(mut self, foo: usize) -> Self {
-            self.foo = foo;
-            self
-        }
-    }
-    #[test]
-    fn register_type_test() {
-        let mut vm = Engine::new();
-
-        // Registering a type gives access to a predicate for the type
-        vm.register_type::<ExternalStruct>("ExternalStruct?");
-
-        // Structs in steel typically have a constructor that is the name of the struct
-        vm.register_fn("ExternalStruct", ExternalStruct::new);
-
-        // register_fn can be chained
-        vm.register_fn("method-by-value", ExternalStruct::method_by_value)
-            .register_fn("set-foo", ExternalStruct::set_foo);
-
-        let external_struct = ExternalStruct::new(1, "foo".to_string(), 12.4);
-
-        // Registering an external value is fallible if the conversion fails for some reason
-        // For instance, registering an Err(T) is fallible. However, most implementation outside of manual
-        // ones should not fail
-        vm.register_external_value("external-struct", external_struct)
-            .unwrap();
-
-        let _ = vm
-            .compile_and_run_raw_program(
-                r#"
-            (define new-external-struct (set-foo external-struct 100))
-            (define get-output (method-by-value external-struct))
-            (define second-new-external-struct (ExternalStruct 50 "bananas" 72.6))
-            "last-result"
-        "#,
-            )
-            .unwrap();
-
-        let new_external_struct = vm.extract::<ExternalStruct>("new-external-struct").unwrap();
-        assert_eq!(
-            ExternalStruct::new(100, "foo".to_string(), 12.4),
-            new_external_struct
-        );
-
-        // Can also extract a value by specifying the type on the variable
-        let get_output: usize = vm.extract("get-output").unwrap();
-        assert_eq!(1, get_output);
-
-        let second_new_external_struct: ExternalStruct =
-            vm.extract("second-new-external-struct").unwrap();
-        assert_eq!(
-            ExternalStruct::new(50, "bananas".to_string(), 72.6),
-            second_new_external_struct
-        );
-    }
-}
-
-#[cfg(test)]
-mod contract_tests {
-    use crate::steel_vm::test_util::{assert_script, assert_script_error};
-
-    #[test]
-    fn simple_flat_contract() {
-        let script = r#"
-          (define/contract (test x y)
-            (->/c even? even? odd?)
-            (+ x y 1))
-
-          (assert! (equal? (test 2 2) 5))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn simple_flat_contract_domain_violation() {
-        let script = r#"
-          (define/contract (test x y)
-            (->/c even? even? odd?)
-            (+ x y 1))
-
-          (test 1 2)
-        "#;
-        assert_script_error(script);
-    }
-
-    #[test]
-    fn simple_higher_order_contract() {
-        let script = r#"
-          (define/contract (blagh func y)
-            (->/c (->/c even? odd?) even? even?)
-            (+ 1 (func y)))
-            
-          (assert! (equal? (blagh (lambda (x) (+ x 1)) 2) 4))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn simple_higher_order_contract_violation() {
-        let script = r#"
-          (define/contract (blagh func y)
-            (->/c (->/c even? odd?) even? even?)
-            (+ 1 (func y)))
-
-          (blagh (lambda (x) (+ x 2)) 2)
-        "#;
-        assert_script_error(script);
-    }
-
-    // TODO: This will fail on old contract implementation
-    // #[test]
-    // fn tail_call_mutual_recursion() {
-    //     let script = r#"
-    //     (define/contract (foo x)
-    //       (->/c int? int?)
-    //         (if (= x 100)
-    //             x
-    //             (bar (+ x 1))))
-
-    //     (define/contract (bar x)
-    //       (->/c int? int?)
-    //         (if (= x 100)
-    //             x
-    //             (foo (+ x 1))))
-
-    //     (assert! (equal? (foo 0) 100))
-    //   "#;
-    //     assert_script(script);
-    // }
-
-    #[test]
-    fn tail_call_contract_still_works() {
-        let script = r#"
-          (define/contract (loop x)
-            (->/c int? int?)
-              (if (= x 100)
-                  x
-                  (loop (+ x 1))))
-
-          (assert! (equal? (loop 0) 100))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn contract_checking_on_application_success() {
-        let script = r#"
-
-        (define/contract (output)
-            (->/c (->/c string? int?))
-            (lambda (x) 10))
-
-        (define/contract (accept func)
-            (->/c (->/c string? int?) string?)
-            "cool cool cool")
-
-        (assert! (equal? (accept (output)) "cool cool cool"))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn contract_checking_not_called_since_not_applied() {
-        let script = r#"
-
-        (define/contract (output)
-            (->/c (->/c string? int?))
-            (lambda (x) 10))
-
-        (define/contract (accept func)
-            (->/c (->/c string? string?) string?)
-            "cool cool cool")
-
-        (assert! (equal? (accept (output)) "cool cool cool"))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn contract_checking_on_return_does_not_happen() {
-        let script = r#"
-
-        (define/contract (output)
-            (->/c (->/c string? int?))
-            (lambda (x) 10))
-
-        (define/contract (accept)
-            (->/c (->/c string? string?))
-            (output))
-
-        (accept)
-        "#;
-
-        assert_script(script);
-    }
-
-    #[test]
-    fn contract_application_in_map() {
-        let script = r#"
-        (define (test x)
-            (->/c int? int?)
-            (+ x 1))
-        (define result (map test (list 1 2 3 4)))
-        (assert! (equal? result (list 2 3 4 5)))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn contract_application_in_filter() {
-        let script = r#"
-        (define (test x)
-            (->/c int? boolean?)
-            (even? x))
-        (define result (filter test (list 1 2 3 4)))
-        (assert! (equal? result (list 2 4)))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn contract_checking_with_weaker() {
-        let script = r#"
-        (define/contract (output)
-            (->/c (->/c string? int?))
-            (lambda (x) 10.0))
-
-        (define/contract (accept)
-            (->/c (->/c string? number?))
-            (output))
-
-        ((accept) "test")
-        "#;
-
-        assert_script_error(script)
-    }
-
-    #[test]
-    fn contract_checking_pre_condition_later() {
-        let script = r#"
-        (define/contract (output)
-            (->/c (->/c list? int?))
-            (lambda (x) 10.0))
-
-        (define/contract (accept)
-            (->/c (->/c string? number?))
-            (output))
-
-        ((accept) "test")
-        "#;
-
-        assert_script_error(script);
-    }
-
-    #[test]
-    fn three_levels_of_contracts() {
-        let script = r#"
-        (define (any? x) #t)
-
-        (define/contract (level1)
-            (->/c (->/c int?))
-            (lambda () 10.2))
-
-        (define/contract (level2)
-            (->/c (->/c number?))
-            (level1))
-
-        (define/contract (level3)
-            (->/c (->/c any?))
-            (level2))
-
-        ((level3))
-        "#;
-
-        assert_script_error(script);
-    }
-
-    #[test]
-    fn contract_with_filter() {
-        let script = r#"
-        (define/contract (is-even? x)
-            (->/c number? boolean?)
-            (even? x))
-
-        (define res (filter is-even? (range 0 10)))
-
-        (assert! (equal? res '(0 2 4 6 8)))
-        "#;
-
-        assert_script(script);
-    }
-
-    #[test]
-    fn contract_with_map() {
-        let script = r#"
-        (define/contract (adding1 x)
-            (->/c number? number?)
-            (+ x 1))
-
-        (define res (map adding1 (range 0 5)))
-
-        (assert! (equal? res '(1 2 3 4 5)))
-        "#;
-
-        assert_script(script);
-    }
-
-    #[test]
-    fn contract_with_reduce() {
-        let script = r#"
-        (define/contract (reducer accum elem)
-            (->/c number? number? number?)
-            (+ accum elem))
-
-        (define res (transduce (range 0 10) (taking 5) (into-reducer + 0)))
-
-        (assert! (equal? res 10))
-        "#;
-        assert_script(script);
-    }
-
-    #[test]
-    fn transducers_containing_contracts() {
-        let script = r#"
-        (define/contract (mapper x)
-            (->/c number? number?)
-            (+ x 1))
-
-        (define/contract (is-even? x)
-            (->/c number? boolean?)
-            (even? x))
-
-        (define x (mapping mapper))
-        (define y (filtering is-even?))
-        (define z (taking 10))
-
-        (define xyz (compose x y z))
-
-        (define exec-list (transduce (range 0 100) xyz (into-list)))
-        (define exec-vector (transduce (range 0 100) xyz (into-vector)))
-        (define my-sum (transduce (range 0 100) xyz (into-reducer + 0)))
-        
-        (assert! (equal? exec-list '(2 4 6 8 10 12 14 16 18 20)))
-        (assert! (equal? exec-vector (vector 2 4 6 8 10 12 14 16 18 20)))
-        (assert! (equal? my-sum 110))
-        "#;
-        assert_script(script);
-    }
-}
diff --git a/crates/steel-core/src/steel_vm/transducers.rs b/crates/steel-core/src/steel_vm/transducers.rs
deleted file mode 100644
index 0846f8236..000000000
--- a/crates/steel-core/src/steel_vm/transducers.rs
+++ /dev/null
@@ -1,572 +0,0 @@
-// use im_lists::list::List;
-use crate::values::lists::List;
-// use itertools::Itertools;
-
-// use super::{evaluation_progress::EvaluationProgress, stack::StackFrame, vm::VmCore};
-use super::{
-    lazy_stream::LazyStreamIter,
-    vm::{VmContext, VmCore},
-};
-use crate::{
-    gc::Gc,
-    parser::span::Span,
-    primitives::VectorOperations,
-    rerrs::{ErrorKind, SteelErr},
-    rvals::{Result, SteelVal},
-    stop,
-    values::transducers::{Reducer, Transducers},
-};
-
-use std::{cell::RefCell, convert::TryInto};
-use std::{iter::Fuse, rc::Rc};
-
-/// An iterator adaptor that alternates elements from two iterators until both
-/// run out.
-///
-/// This iterator is *fused*.
-///
-/// See [`.interleave()`](crate::Itertools::interleave) for more information.
-#[derive(Clone, Debug)]
-#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
-pub struct Interleave<I, J> {
-    a: Fuse<I>,
-    b: Fuse<J>,
-    flag: bool,
-}
-
-/// Create an iterator that interleaves elements in `i` and `j`.
-///
-/// [`IntoIterator`] enabled version of `[Itertools::interleave]`.
-pub fn interleave<I, J>(
-    i: I,
-    j: J,
-) -> Interleave<<I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter>
-where
-    I: IntoIterator,
-    J: IntoIterator<Item = I::Item>,
-{
-    Interleave {
-        a: i.into_iter().fuse(),
-        b: j.into_iter().fuse(),
-        flag: false,
-    }
-}
-
-impl<I, J> Iterator for Interleave<I, J>
-where
-    I: Iterator,
-    J: Iterator<Item = I::Item>,
-{
-    type Item = I::Item;
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        self.flag = !self.flag;
-        if self.flag {
-            match self.a.next() {
-                None => self.b.next(),
-                r => r,
-            }
-        } else {
-            match self.b.next() {
-                None => self.a.next(),
-                r => r,
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        add(self.a.size_hint(), self.b.size_hint())
-    }
-}
-
-/// `SizeHint` is the return type of `Iterator::size_hint()`.
-pub type SizeHint = (usize, Option<usize>);
-
-/// Add `SizeHint` correctly.
-#[inline]
-pub fn add(a: SizeHint, b: SizeHint) -> SizeHint {
-    let min = a.0.saturating_add(b.0);
-    let max = match (a.1, b.1) {
-        (Some(x), Some(y)) => x.checked_add(y),
-        _ => None,
-    };
-
-    (min, max)
-}
-
-impl<I, J> std::iter::FusedIterator for Interleave<I, J>
-where
-    I: Iterator,
-    J: Iterator<Item = I::Item>,
-{
-}
-
-/// Generates the take transducer - wrapper around the take iterator
-macro_rules! generate_take {
-    ($iter:expr, $num:expr, $cur_inst_span:expr) => {
-        if let SteelVal::IntV(num) = $num {
-            if *num < 0 {
-                stop!(ContractViolation => "take transducer must have a position number"; *$cur_inst_span)
-            }
-            Box::new($iter.take(*num as usize))
-        } else {
-            stop!(TypeMismatch => "take transducer takes an integer"; *$cur_inst_span)
-        }
-    }
-}
-
-/// Generates the drop transducer - wrapper around the drop iterator
-macro_rules! generate_drop {
-    ($iter:expr, $num:expr, $cur_inst_span:expr) => {
-        if let SteelVal::IntV(num) = $num {
-            if *num < 0 {
-                stop!(ContractViolation => "drop transducer must have a position number"; *$cur_inst_span)
-            }
-            Box::new($iter.skip(*num as usize))
-        } else {
-            stop!(TypeMismatch => "drop transducer takes an integer"; *$cur_inst_span)
-        }
-    }
-}
-
-pub(crate) const TRANSDUCE: SteelVal = SteelVal::BuiltIn(transduce);
-
-// figure out if nested transducers works
-fn transduce(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    if args.len() < 2 {
-        builtin_stop!(ArityMismatch => format!("transduce expects at least 2 arguments, found {}", args.len()))
-    }
-
-    let (reducer, args) = args
-        .split_last()
-        .ok_or_else(throw!(ArityMismatch => "transduce expects 3 arguments, found none"))
-        .unwrap();
-
-    let mut arg_iter = args.iter();
-    let collection = arg_iter.next().unwrap();
-
-    // TODO make this way better
-    let transducers: Vec<_> = arg_iter
-        .map(|x| {
-            if let SteelVal::IterV(i) = x {
-                Ok(i)
-            } else {
-                stop!(TypeMismatch => format!("transduce expects a transducer, found: {x}"))
-            }
-        })
-        .collect::<Result<Vec<_>>>()
-        .unwrap();
-
-    let transducers = transducers
-        .into_iter()
-        .flat_map(|x| x.ops.clone())
-        .collect::<Vec<_>>();
-
-    if let SteelVal::ReducerV(r) = &reducer {
-        // TODO get rid of this unwrap
-        // just pass a reference instead
-        Some(ctx.call_transduce(&transducers, collection.clone(), r.unwrap(), None))
-    } else {
-        builtin_stop!(TypeMismatch => format!("transduce requires that the last argument be a reducer, found: {reducer}"))
-    }
-}
-
-// struct VecGuard<'a> {
-//     guard: Ref<'a, Vec<SteelVal>>,
-// }
-
-// impl<'b> Deref for VecGuard<'b> {
-//     type Target = Vec<SteelVal>;
-
-//     fn deref(&self) -> &Vec<SteelVal> {
-//         &self.guard
-//     }
-// }
-
-impl<'global, 'a> VmCore<'a> {
-    // With transducers, we also need reducers
-    // reducers should define _how_ a value is going to be converted away
-    // from the iterator stream
-    // This could either be a function that returns a single value, or a generic collection type
-    pub(crate) fn res_iterator(
-        value: &'global SteelVal,
-        vm_ctx: Rc<RefCell<&'global mut Self>>,
-        cur_inst_span: &'global Span,
-        // The nursery here is for iterating over a vec since its wrapped inside the refcell
-        nursery: &'global mut Option<Vec<SteelVal>>,
-    ) -> Result<Box<dyn Iterator<Item = Result<SteelVal>> + 'global>> {
-        match value {
-            SteelVal::VectorV(v) => Ok(Box::new(v.iter().cloned().map(Ok))),
-            SteelVal::StreamV(lazy_stream) => Ok(Box::new(LazyStreamIter::new(
-                lazy_stream.unwrap(),
-                vm_ctx,
-                cur_inst_span,
-            ))),
-            SteelVal::StringV(s) => Ok(Box::new(s.chars().map(|x| Ok(SteelVal::CharV(x))))),
-            SteelVal::ListV(l) => Ok(Box::new(l.into_iter().cloned().map(Ok))),
-            // SteelVal::StructV(s) => Ok(Box::new(s.iter().cloned().map(Ok))),
-            SteelVal::HashSetV(hs) => Ok(Box::new(hs.iter().cloned().map(Ok))),
-            SteelVal::HashMapV(hm) => {
-                Ok(Box::new(hm.iter().map(|x| {
-                    Ok(SteelVal::ListV(vec![x.0.clone(), x.1.clone()].into()))
-                })))
-            }
-            SteelVal::MutableVector(v) => {
-                // Copy over the mutable vector into the nursery
-                *nursery = Some(v.get().clone());
-
-                Ok(Box::new(nursery.as_ref().unwrap().iter().cloned().map(Ok)))
-            }
-            _ => {
-                stop!(TypeMismatch => format!("value unable to be converted to an iterable: {value}"))
-            }
-        }
-    }
-
-    pub(crate) fn transduce(
-        &mut self,
-        ops: &[Transducers],
-        root: SteelVal,
-        reducer: Reducer,
-        cur_inst_span: &Span,
-    ) -> Result<SteelVal> {
-        let vm = Rc::new(RefCell::new(self));
-
-        let mut nursery = None;
-
-        let mut iter = Self::res_iterator(&root, Rc::clone(&vm), cur_inst_span, &mut nursery)?;
-
-        for t in ops {
-            iter = match t {
-                Transducers::Map(stack_func) => {
-                    let vm_copy = Rc::clone(&vm);
-
-                    // TODO: Probably should just capture a continuation here?
-                    let switch_statement = move |arg| {
-                        vm_copy.borrow_mut().call_func_or_else(
-                            stack_func,
-                            arg?,
-                            cur_inst_span,
-                            throw!(TypeMismatch => "map expected a function"; *cur_inst_span),
-                        )
-                    };
-
-                    Box::new(iter.map(switch_statement))
-                }
-                Transducers::Filter(stack_func) => {
-                    let vm_copy = Rc::clone(&vm);
-
-                    let switch_statement = move |arg: Result<SteelVal>| match arg {
-                        Ok(arg) => {
-                            let res = vm_copy.borrow_mut().call_func_or_else(
-                                stack_func,
-                                arg.clone(),
-                                cur_inst_span,
-                                throw!(TypeMismatch => "filter expected a function"; *cur_inst_span)
-                            );
-
-                            match res {
-                                Ok(k) => match k {
-                                    SteelVal::BoolV(false) => None,
-                                    _ => Some(Ok(arg)),
-                                },
-                                Err(e) => Some(Err(e)),
-                            }
-                        }
-
-                        _ => Some(arg),
-                    };
-
-                    Box::new(iter.filter_map(switch_statement))
-                }
-                Transducers::FlatMap(stack_func) => {
-                    let vm_copy = Rc::clone(&vm);
-
-                    let switch_statement =
-                        move |arg: Result<SteelVal>| -> Box<dyn Iterator<Item = Result<SteelVal>>> {
-                            match arg {
-                                Ok(arg) => {
-                                    let res = vm_copy.borrow_mut().call_func_or_else(
-                                    stack_func,
-                                    arg,
-                                    cur_inst_span,
-                                    throw!(TypeMismatch => "map expected a function"; *cur_inst_span),
-                                );
-
-                                    match res {
-                                        Ok(x) => {
-                                            match x {
-                                                SteelVal::VectorV(v) => {
-                                                    Box::new(v.0.unwrap().into_iter().map(Ok))
-                                                }
-                                                // TODO this needs to be fixed
-                                                SteelVal::StringV(s) => Box::new(
-                                                    s.chars()
-                                                        .map(|x| Ok(SteelVal::CharV(x)))
-                                                        .collect::<Vec<_>>()
-                                                        .into_iter(),
-                                                ),
-                                                SteelVal::ListV(l) => {
-                                                    Box::new(l.into_iter().map(Ok))
-                                                }
-                                                // SteelVal::StructV(s) => {
-                                                //     Box::new(s.unwrap().fields.into_iter().map(Ok))
-                                                // }
-                                                els => {
-                                                    let err = SteelErr::new(ErrorKind::TypeMismatch, format!("flatten expected a traversable value, found: {els}")).with_span(*cur_inst_span);
-
-                                                    Box::new(std::iter::once(Err(err)))
-                                                }
-                                            }
-                                        }
-                                        err => Box::new(std::iter::once(err)),
-                                    }
-                                }
-
-                                err => Box::new(std::iter::once(err)),
-                            }
-                        };
-
-                    Box::new(iter.flat_map(switch_statement))
-                }
-                Transducers::Flatten => {
-                    // TODO figure out how to use strings here
-                    let switch_statement =
-                        move |arg: Result<SteelVal>| -> Box<dyn Iterator<Item = Result<SteelVal>>> {
-                            match arg {
-                                Ok(x) => {
-                                    match x {
-                                        SteelVal::VectorV(v) => {
-                                            Box::new(v.0.unwrap().into_iter().map(Ok))
-                                        }
-                                        // TODO this needs to be fixed
-                                        SteelVal::StringV(s) => Box::new(
-                                            s.chars()
-                                                .map(|x| Ok(SteelVal::CharV(x)))
-                                                .collect::<Vec<_>>()
-                                                .into_iter(),
-                                        ),
-                                        SteelVal::ListV(l) => Box::new(l.into_iter().map(Ok)),
-                                        // SteelVal::StructV(s) => {
-                                        //     Box::new(s.unwrap().fields.into_iter().map(Ok))
-                                        // }
-                                        els => {
-                                            let err = SteelErr::new(ErrorKind::TypeMismatch, format!("flatten expected a traversable value, found: {els}")).with_span(*cur_inst_span);
-
-                                            Box::new(std::iter::once(Err(err)))
-                                        }
-                                    }
-                                }
-                                err => Box::new(std::iter::once(err)),
-                            }
-                        };
-
-                    Box::new(iter.flat_map(switch_statement))
-
-                    // todo!()
-                }
-                Transducers::Window(_num) => {
-                    todo!()
-                }
-                Transducers::TakeWhile(_func) => {
-                    todo!()
-                }
-                Transducers::DropWhile(_func) => {
-                    todo!()
-                }
-                Transducers::Extend(collection) => {
-                    let extender: Box<dyn Iterator<Item = Result<SteelVal>>> =
-                        match collection.clone() {
-                            SteelVal::VectorV(v) => Box::new(v.0.unwrap().into_iter().map(Ok)),
-                            // TODO this needs to be fixed
-                            SteelVal::StringV(s) => Box::new(
-                                s.chars()
-                                    .map(|x| Ok(SteelVal::CharV(x)))
-                                    .collect::<Vec<_>>()
-                                    .into_iter(),
-                            ),
-                            SteelVal::ListV(l) => Box::new(l.into_iter().map(Ok)),
-                            // SteelVal::StructV(s) => Box::new(s.unwrap().fields.into_iter().map(Ok)),
-                            els => {
-                                let err = SteelErr::new(
-                                    ErrorKind::TypeMismatch,
-                                    format!("extending expected a traversable value, found: {els}"),
-                                )
-                                .with_span(*cur_inst_span);
-
-                                Box::new(std::iter::once(Err(err)))
-                            }
-                        };
-
-                    Box::new(iter.chain(extender))
-                }
-                Transducers::Cycle => {
-                    todo!()
-                }
-                Transducers::Take(num) => generate_take!(iter, num, cur_inst_span),
-                Transducers::Drop(num) => generate_drop!(iter, num, cur_inst_span),
-                Transducers::Enumerating => Box::new(iter.enumerate().map(|x| {
-                    Ok(SteelVal::ListV(
-                        vec![SteelVal::IntV(x.0 as isize), x.1?].into(),
-                    ))
-                })),
-                Transducers::Zipping(collection) => {
-                    let zipped: Box<dyn Iterator<Item = Result<SteelVal>>> =
-                        match collection.clone() {
-                            SteelVal::VectorV(v) => Box::new(v.0.unwrap().into_iter().map(Ok)),
-                            // TODO this needs to be fixed
-                            SteelVal::StringV(s) => Box::new(
-                                s.chars()
-                                    .map(|x| Ok(SteelVal::CharV(x)))
-                                    .collect::<Vec<_>>()
-                                    .into_iter(),
-                            ),
-                            SteelVal::ListV(l) => Box::new(l.into_iter().map(Ok)),
-                            // SteelVal::StructV(s) => Box::new(s.unwrap().fields.into_iter().map(Ok)),
-                            els => {
-                                let err = SteelErr::new(
-                                    ErrorKind::TypeMismatch,
-                                    format!("extending expected a traversable value, found: {els}"),
-                                )
-                                .with_span(*cur_inst_span);
-
-                                Box::new(std::iter::once(Err(err)))
-                            }
-                        };
-                    Box::new(
-                        iter.zip(zipped)
-                            .map(|x| Ok(SteelVal::ListV(vec![x.0?, x.1?].into()))),
-                    )
-                }
-                Transducers::Interleaving(collection) => {
-                    let other: Box<dyn Iterator<Item = Result<SteelVal>>> = match collection.clone()
-                    {
-                        SteelVal::VectorV(v) => Box::new(v.0.unwrap().into_iter().map(Ok)),
-                        // TODO this needs to be fixed
-                        SteelVal::StringV(s) => Box::new(
-                            s.chars()
-                                .map(|x| Ok(SteelVal::CharV(x)))
-                                .collect::<Vec<_>>()
-                                .into_iter(),
-                        ),
-                        SteelVal::ListV(l) => Box::new(l.into_iter().map(Ok)),
-                        // SteelVal::StructV(s) => Box::new(s.unwrap().fields.into_iter().map(Ok)),
-                        els => {
-                            let err = SteelErr::new(
-                                ErrorKind::TypeMismatch,
-                                format!("extending expected a traversable value, found: {els}"),
-                            )
-                            .with_span(*cur_inst_span);
-
-                            Box::new(std::iter::once(Err(err)))
-                        }
-                    };
-                    Box::new(interleave(iter, other))
-                }
-            }
-        }
-
-        Self::into_value(vm, reducer, iter, cur_inst_span)
-    }
-
-    fn into_value(
-        vm_ctx: Rc<RefCell<&'global mut Self>>,
-        reducer: Reducer,
-        mut iter: impl Iterator<Item = Result<SteelVal>>,
-        cur_inst_span: &Span,
-    ) -> Result<SteelVal> {
-        match reducer {
-            // TODO this only works with integer values right now
-            Reducer::Sum => {
-                iter.map(|x| match x? {
-                    SteelVal::IntV(v) => {
-                        Ok(v)
-                    }
-                    other => {
-                        stop!(TypeMismatch => "sum expects an integer value, found: {:?}", other)
-                    }
-                })
-                .sum::<Result<isize>>()
-                .map(SteelVal::IntV)
-            },
-            Reducer::Multiply => {
-                iter.map(|x| match x? {
-                    SteelVal::IntV(v) => {
-                        Ok(v)
-                    }
-                    other => {
-                        stop!(TypeMismatch => "sum expects an integer value, found: {:?}", other)
-                    }
-                })
-                .product::<Result<isize>>()
-                .map(SteelVal::IntV)
-            }
-            Reducer::Max => todo!(),
-            Reducer::Min => todo!(),
-            Reducer::Count => {
-                Ok(SteelVal::IntV(iter.count().try_into().unwrap())) // TODO have proper big int
-            },
-            Reducer::Nth(usize) => {
-                iter.nth(usize).unwrap_or_else(|| stop!(Generic => "`nth` - index given is greater than the length of the iterator"))
-            },
-            Reducer::List => iter.collect::<Result<List<_>>>().map(SteelVal::ListV),
-            Reducer::Vector => VectorOperations::vec_construct_iter(iter),
-            Reducer::HashMap => {
-                iter.map(|x| {
-                    match x? {
-                        SteelVal::ListV(l) => {
-                            if l.len() != 2 {
-                                stop!(Generic => format!("Hashmap iterator expects an iterable with two elements, found: {l:?}"));
-                            } else {
-                                let mut iter = l.into_iter();
-                                Ok((iter.next().unwrap(), iter.next().unwrap()))
-                            }
-                        }
-                        SteelVal::VectorV(l) => {
-                            if l.len() != 2 {
-                                stop!(Generic => format!("Hashmap iterator expects an iterable with two elements, found: {:?}", &l.0));
-                            } else {
-                                let mut iter = l.iter();
-                                Ok((iter.next().cloned().unwrap(), iter.next().cloned().unwrap()))
-                            }
-                        }
-                        other => {
-                            stop!(TypeMismatch => format!("Unable to convert: {other} to pair that can be used to construct a hashmap"));
-                        }
-                    }
-                }).collect::<Result<im_rc::HashMap<_, _>>>().map(|x| SteelVal::HashMapV(Gc::new(x).into()))
-            },
-            Reducer::HashSet => iter.collect::<Result<im_rc::HashSet<_>>>().map(|x| SteelVal::HashSetV(Gc::new(x).into())),
-            Reducer::String => todo!(),
-            Reducer::Last => iter.last().unwrap_or_else(|| stop!(Generic => "`last` found empty list - `last` requires at least one element in the sequence")),
-            Reducer::ForEach(f) => {
-                for value in iter {
-                    vm_ctx.borrow_mut().call_func_or_else(
-                        &f,
-                        value?,
-                        cur_inst_span,
-                        throw!(TypeMismatch => format!("for-each expected a function, found: {}", &f))
-                    )?;
-                }
-
-                Ok(SteelVal::Void)
-            },
-            Reducer::Generic(reducer) => {
-
-                let initial_value = Ok(reducer.initial_value.clone());
-
-                let switch_statement = move |acc, x| {
-                    vm_ctx.borrow_mut().call_func_or_else_two_args(
-                        &reducer.function,
-                        acc?,
-                        x?,
-                        cur_inst_span,
-                        throw!(TypeMismatch => "reduce expected a function"; *cur_inst_span),
-                    )
-                };
-
-                iter.fold(initial_value, switch_statement)
-            }
-        }
-    }
-}
diff --git a/crates/steel-core/src/steel_vm/vm.rs b/crates/steel-core/src/steel_vm/vm.rs
deleted file mode 100644
index 77936fc21..000000000
--- a/crates/steel-core/src/steel_vm/vm.rs
+++ /dev/null
@@ -1,6476 +0,0 @@
-#![allow(unused)]
-
-use crate::core::instructions::pretty_print_dense_instructions;
-use crate::primitives::lists::cons;
-use crate::primitives::lists::new as new_list;
-use crate::primitives::lists::steel_car;
-use crate::primitives::nums::special_add;
-use crate::steel_vm::primitives::steel_set_box;
-use crate::steel_vm::primitives::steel_set_box_mutable;
-use crate::steel_vm::primitives::steel_unbox;
-use crate::steel_vm::primitives::steel_unbox_mutable;
-use crate::values::closed::Heap;
-use crate::values::functions::SerializedLambda;
-use crate::values::structs::UserDefinedStruct;
-use crate::{
-    compiler::constants::ConstantMap,
-    core::{instructions::DenseInstruction, opcode::OpCode},
-    rvals::FutureResult,
-};
-use crate::{
-    compiler::program::Executable,
-    primitives::{add_primitive, divide_primitive, multiply_primitive, subtract_primitive},
-    steel_vm::primitives::{equality_primitive, lte_primitive},
-    values::transducers::Transducers,
-};
-use crate::{primitives::nums::add_primitive_faster, values::transducers::Reducer};
-
-use crate::{
-    env::Env,
-    gc::Gc,
-    parser::span::Span,
-    rerrs::{ErrorKind, SteelErr},
-    rvals::{Result, SteelVal},
-    stop,
-    values::functions::ByteCodeLambda,
-};
-use std::rc::Weak;
-use std::{cell::RefCell, collections::HashMap, iter::Iterator, rc::Rc};
-
-use super::builtin::DocTemplate;
-
-use crate::values::lists::List;
-
-#[cfg(feature = "profiling")]
-use log::{debug, log_enabled};
-use num::ToPrimitive;
-use once_cell::sync::Lazy;
-#[cfg(feature = "profiling")]
-use std::time::Instant;
-
-use crate::rvals::{
-    as_underlying_type, from_serializable_value, into_serializable_value, IntoSteelVal,
-};
-
-pub(crate) mod threads;
-pub(crate) use threads::{spawn_thread, thread_join};
-
-#[inline]
-#[cold]
-pub fn cold() {}
-
-#[inline]
-pub fn likely(b: bool) -> bool {
-    if !b {
-        cold()
-    }
-    b
-}
-
-#[inline]
-pub fn unlikely(b: bool) -> bool {
-    if b {
-        cold()
-    }
-    b
-}
-
-// #[test]
-// fn call_hello_world() {
-//     println!("{:?}", message());
-// }
-
-const STACK_LIMIT: usize = 1000000;
-const _JIT_THRESHOLD: usize = 100;
-
-const USE_SUPER_INSTRUCTIONS: bool = false;
-const CHECK_STACK_OVERFLOW: bool = false;
-
-#[repr(C)]
-#[derive(Clone, Debug, Copy, PartialEq)]
-pub struct DehydratedCallContext {
-    span: Option<Span>,
-}
-
-impl DehydratedCallContext {
-    pub fn span(&self) -> &Option<Span> {
-        &self.span
-    }
-}
-
-impl DehydratedCallContext {
-    pub fn new(span: Option<Span>) -> Self {
-        DehydratedCallContext { span }
-    }
-}
-
-#[repr(C)]
-#[derive(Clone, Debug, PartialEq)]
-pub struct DehydratedStackTrace {
-    stack_trace: Vec<DehydratedCallContext>,
-}
-
-impl DehydratedStackTrace {
-    fn new(stack_trace: Vec<DehydratedCallContext>) -> Self {
-        Self { stack_trace }
-    }
-
-    pub fn trace(&self) -> &[DehydratedCallContext] {
-        &self.stack_trace
-    }
-
-    pub fn push(&mut self, context: DehydratedCallContext) {
-        self.stack_trace.push(context)
-    }
-}
-
-// // Eventually expand this to other kinds of continuations
-// #[derive(Debug, Clone, Copy)]
-// pub enum ContinuationMark {
-//     Default,
-//     Transducer,
-// }
-
-// This should be the go to thing for handling basically everything we need
-// Then - do I want to always reference the last one, or just refer to the current one?
-// TODO: We'll need to add these functions to the GC as well
-
-#[derive(Debug, Clone)]
-pub struct StackFrame {
-    sp: usize,
-    // This _has_ to be a function
-    pub(crate) handler: Option<Rc<SteelVal>>,
-    // This should get added to the GC as well
-    #[cfg(not(feature = "unsafe-internals"))]
-    pub(crate) function: Gc<ByteCodeLambda>,
-    // Whenever the StackFrame object leaves the context of _this_ VM, these functions
-    // need to become rooted, otherwise we'll have an issue with use after free
-    #[cfg(feature = "unsafe-internals")]
-    pub(crate) function: crate::gc::unsafe_roots::MaybeRooted<ByteCodeLambda>,
-
-    ip: usize,
-    instructions: Rc<[DenseInstruction]>,
-
-    // TODO: Delete this one!
-    // continuation_mark: Option<MaybeContinuation>,
-    weak_continuation_mark: Option<WeakContinuation>,
-}
-
-impl Eq for StackFrame {}
-
-impl PartialEq for StackFrame {
-    fn eq(&self, other: &Self) -> bool {
-        self.sp == other.sp
-            && self.handler == other.handler
-            && self.ip == other.ip
-            && self.instructions == other.instructions
-            && self.function == other.function
-    }
-}
-
-#[test]
-fn check_sizes() {
-    println!("stack frame: {:?}", std::mem::size_of::<StackFrame>());
-    println!(
-        "option rc steelval: {:?}",
-        std::mem::size_of::<Option<Rc<SteelVal>>>()
-    );
-    println!(
-        "option box steelval: {:?}",
-        std::mem::size_of::<Option<Box<SteelVal>>>()
-    );
-    println!(
-        "option steelval: {:?}",
-        std::mem::size_of::<Option<SteelVal>>()
-    );
-}
-
-impl StackFrame {
-    pub fn new(
-        stack_index: usize,
-        function: Gc<ByteCodeLambda>,
-        ip: usize,
-        instructions: Rc<[DenseInstruction]>,
-        // span_id: usize,
-        // spans: Rc<[Span]>,
-    ) -> Self {
-        Self {
-            sp: stack_index,
-            #[cfg(feature = "unsafe-internals")]
-            function: crate::gc::unsafe_roots::MaybeRooted::Reference(function),
-            #[cfg(not(feature = "unsafe-internals"))]
-            function,
-            ip,
-            instructions,
-            // span: None,
-            handler: None,
-
-            weak_continuation_mark: None,
-            // spans,
-            // span_id,
-        }
-    }
-
-    fn with_continuation_mark(mut self, continuation_mark: Continuation) -> Self {
-        self.weak_continuation_mark = Some(WeakContinuation::from_strong(&continuation_mark));
-
-        self
-    }
-
-    fn new_rooted(
-        stack_index: usize,
-        #[cfg(feature = "unsafe-internals")] function: crate::gc::unsafe_roots::MaybeRooted<
-            ByteCodeLambda,
-        >,
-        #[cfg(not(feature = "unsafe-internals"))] function: Gc<ByteCodeLambda>,
-        ip: usize,
-        instructions: Rc<[DenseInstruction]>,
-        // span_id: usize,
-        // spans: Rc<[Span]>,
-    ) -> Self {
-        Self {
-            sp: stack_index,
-            #[cfg(feature = "unsafe-internals")]
-            function,
-            #[cfg(not(feature = "unsafe-internals"))]
-            function,
-            ip,
-            instructions,
-            // span: None,
-            handler: None,
-
-            weak_continuation_mark: None,
-            // spans,
-            // span_id,
-        }
-    }
-
-    pub fn main() -> Self {
-        let function = Gc::new(ByteCodeLambda::main(Vec::new()));
-        StackFrame::new(0, function, 0, Rc::from([]))
-    }
-
-    // #[inline(always)]
-    // pub fn with_span(mut self, span: Span) -> Self {
-    //     self.span = Some(span);
-    //     self
-    // }
-
-    #[inline(always)]
-    pub fn set_function(&mut self, function: Gc<ByteCodeLambda>) {
-        #[cfg(not(feature = "unsafe-internals"))]
-        {
-            self.function = function;
-        }
-
-        #[cfg(feature = "unsafe-internals")]
-        {
-            self.function = crate::gc::unsafe_roots::MaybeRooted::Reference(function);
-        }
-    }
-
-    #[inline(always)]
-    pub fn set_continuation(&mut self, continuation: &Continuation) {
-        self.weak_continuation_mark = Some(WeakContinuation::from_strong(&continuation));
-    }
-
-    // pub fn set_span(&mut self, span: Span) {
-    //     self.span = Some(span);
-    // }
-
-    // pub fn attach_handler(&mut self, handler: SteelVal) {
-    //     self.handler = Some(handler);
-    // }
-
-    pub fn with_handler(mut self, handler: SteelVal) -> Self {
-        self.handler = Some(Rc::new(handler));
-        self
-    }
-}
-
-thread_local! {
-    pub(crate) static DEFAULT_CONSTANT_MAP: ConstantMap = ConstantMap::new();
-}
-
-// Drain and move across the thread boundary, OR, enforce the restriction that only pure functions
-// can move into a new thread... that might be the easiest way?
-#[derive(Clone)]
-pub struct SteelThread {
-    pub(crate) global_env: Env,
-    // Maybe a neat idea, what if we used an immutable vector here?
-    pub(crate) stack: Vec<SteelVal>,
-    profiler: OpCodeOccurenceProfiler,
-    function_interner: FunctionInterner,
-    super_instructions: Vec<Rc<DynamicBlock>>,
-
-    pub(crate) heap: Heap,
-    // If contracts are set to off - contract construction results in a no-op,
-    // so we don't need generics on the thread
-    pub(crate) runtime_options: RunTimeOptions,
-    pub(crate) current_frame: StackFrame,
-    pub(crate) stack_frames: Vec<StackFrame>,
-    pub(crate) constant_map: ConstantMap,
-}
-
-#[derive(Clone)]
-pub(crate) struct RunTimeOptions {
-    pub(crate) contracts_on: bool,
-    pub(crate) test: bool,
-}
-
-impl RunTimeOptions {
-    pub fn new() -> Self {
-        Self {
-            contracts_on: true,
-            test: false,
-        }
-    }
-}
-
-struct InstructionChunk {
-    start: usize,
-    end: usize,
-    id: usize,
-}
-
-#[derive(PartialEq)]
-struct SpanId(usize);
-
-#[derive(Default, Clone)]
-pub struct FunctionInterner {
-    closure_interner: fxhash::FxHashMap<usize, ByteCodeLambda>,
-    pure_function_interner: fxhash::FxHashMap<usize, Gc<ByteCodeLambda>>,
-    // Functions will store a reference to a slot here, rather than any other way
-    // getting the span can be super late bound then, and we don't need to worry about
-    // cache misses nearly as much
-    // Rooted spans more or less are just spans from the top level getting passed in - we'll
-    // take them, root them with some sort of gensym, and then free them on the way out.
-    //
-    // These should get GC'd eventually, by walking the alive set and seeing if there are
-    // actually any references to this still in existence. Functions should probably hold a direct
-    // reference to the existing thread in which it was created, and if passed in externally by
-    // another run time, we can nuke it?
-    spans: fxhash::FxHashMap<usize, Rc<[Span]>>,
-    // Keep these around - each thread keeps track of the instructions on the bytecode object, but we shouldn't
-    // need to dereference that until later? When we actually move to that
-    instructions: fxhash::FxHashMap<usize, Rc<[DenseInstruction]>>,
-}
-
-impl SteelThread {
-    pub fn new() -> SteelThread {
-        SteelThread {
-            global_env: Env::root(),
-            stack: Vec::with_capacity(128),
-            profiler: OpCodeOccurenceProfiler::new(),
-            function_interner: FunctionInterner::default(),
-            super_instructions: Vec::new(),
-
-            heap: Heap::new(),
-            runtime_options: RunTimeOptions::new(),
-            stack_frames: Vec::with_capacity(128),
-            current_frame: StackFrame::main(),
-            // Should probably just have this be Option<ConstantMap> - but then every time we look up
-            // something we'll have to deal with the fact that its wrapped in an option. Another options
-            // Would just have all programs compiled in this thread just share a constant map. For now,
-            // we'll have each thread default to an empty constant map, and replace it with the map bundled
-            // with the executables
-            constant_map: DEFAULT_CONSTANT_MAP.with(|x| x.clone()),
-        }
-    }
-
-    // If you want to explicitly turn off contracts, you can do so
-    pub fn with_contracts(&mut self, contracts: bool) -> &mut Self {
-        self.runtime_options.contracts_on = contracts;
-        self
-    }
-
-    pub fn insert_binding(&mut self, idx: usize, value: SteelVal) {
-        self.global_env.add_root_value(idx, value);
-    }
-
-    pub fn extract_value(&self, idx: usize) -> Option<SteelVal> {
-        self.global_env.extract(idx)
-    }
-
-    // Run the executable
-    pub fn run_executable(&mut self, program: &Executable) -> Result<Vec<SteelVal>> {
-        let Executable {
-            instructions,
-            constant_map,
-            spans,
-            // struct_functions,
-            ..
-        } = program;
-
-        self.constant_map = constant_map.clone();
-
-        let result = instructions
-            .iter()
-            .zip(spans.iter())
-            .map(|x| self.execute(Rc::clone(x.0), constant_map.clone(), Rc::clone(x.1)))
-            .collect();
-
-        self.constant_map = DEFAULT_CONSTANT_MAP.with(|x| x.clone());
-
-        result
-
-        // TODO
-        // self.global_env.print_diagnostics();
-
-        // todo!("Initialize structs and build the program");
-    }
-
-    pub(crate) fn call_function(
-        &mut self,
-        constant_map: ConstantMap,
-        function: SteelVal,
-        args: Vec<SteelVal>,
-    ) -> Result<SteelVal> {
-        match function {
-            SteelVal::FuncV(func) => {
-                let arg_vec: Vec<_> = args.into_iter().collect();
-                func(&arg_vec).map_err(|x| x.set_span_if_none(Span::default()))
-            }
-            SteelVal::BoxedFunction(func) => {
-                let arg_vec: Vec<_> = args.into_iter().collect();
-                func.func()(&arg_vec).map_err(|x| x.set_span_if_none(Span::default()))
-            }
-            // SteelVal::ContractedFunction(cf) => {
-            //     let arg_vec: Vec<_> = args.into_iter().collect();
-            //     cf.apply(arg_vec, cur_inst_span, self)
-            // }
-            SteelVal::MutFunc(func) => {
-                let mut arg_vec: Vec<_> = args.into_iter().collect();
-                func(&mut arg_vec).map_err(|x| x.set_span_if_none(Span::default()))
-            }
-            // SteelVal::BuiltIn(func) => {
-            //     let arg_vec: Vec<_> = args.into_iter().collect();
-            //     func(self, &arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            // }
-            SteelVal::Closure(closure) => {
-                // let prev_length = self.stack.len();
-
-                // let frame = StackFrame::new(prev_length, Gc::clone(&closure), 0, Rc::from([]));
-
-                // Create phony span vec
-                let spans = closure.body_exp().iter().map(|_| Span::default()).collect();
-
-                let mut vm_instance = VmCore::new_unchecked(
-                    Rc::new([]),
-                    constant_map,
-                    // &mut self.function_stack,
-                    // &mut self.stack_index,
-                    // 0,
-                    Rc::clone(&spans),
-                    self,
-                    &spans,
-                );
-
-                // vm_instance.call_func_or_else_many_args(
-                //     &function,
-                //     args,
-                //     &Span::default(),
-                //     throw!(TypeMismatch => format!("application not a procedure: {}", function)),
-                // );
-
-                vm_instance.call_with_args(&closure, args)
-            }
-            _ => {
-                stop!(TypeMismatch => format!("application not a procedure: {function}"))
-            }
-        }
-    }
-
-    pub fn execute(
-        &mut self,
-        instructions: Rc<[DenseInstruction]>,
-        constant_map: ConstantMap,
-        spans: Rc<[Span]>,
-    ) -> Result<SteelVal> {
-        self.profiler.reset();
-
-        #[cfg(feature = "profiling")]
-        let execution_time = Instant::now();
-
-        let mut vm_instance =
-            VmCore::new(instructions, constant_map, Rc::clone(&spans), self, &spans)?;
-
-        // This is our pseudo "dynamic unwind"
-        // If we need to, we'll walk back on the stack and find any handlers to pop
-        'outer: loop {
-            // TODO: @Matt -> move the profiler out into the vm core type parameter and an argument
-            // that way theres 0 cost to including a profiler vs not including a profiler
-
-            let result = vm_instance
-                .vm()
-                .map_err(|error| error.with_stack_trace(vm_instance.snapshot_stack_trace()));
-
-            // (let () (call-with-exception-handler (lambda (x) (displayln x)) (lambda () (+ 10 20 (error "oops!")))) (displayln "hi"))
-
-            if let Err(e) = result {
-                while let Some(mut last) = vm_instance.thread.stack_frames.pop() {
-                    // Unwind the stack, close continuation marks here!
-                    // vm_instance.close_continuation_marks(&last);
-
-                    // For whatever reason - if we're at the top, we shouldn't go down below 0
-                    if vm_instance.pop_count == 0 {
-                        return Err(e);
-                    }
-
-                    // Drop the pop count along with everything else we're doing
-                    vm_instance.pop_count -= 1;
-
-                    if last.weak_continuation_mark.is_some() {
-                        vm_instance.thread.stack.truncate(last.sp);
-                        vm_instance.ip = last.ip;
-                        vm_instance.sp = vm_instance.get_last_stack_frame_sp();
-                        vm_instance.instructions = Rc::clone(&last.instructions);
-
-                        vm_instance.close_continuation_marks(&last);
-                    }
-
-                    if let Some(handler) = last.handler {
-                        // Drop the stack BACK to where it was on this level
-                        vm_instance.thread.stack.truncate(last.sp);
-
-                        vm_instance.thread.stack.push(e.into_steelval()?);
-
-                        // If we're at the top level, we need to handle this _slightly_ differently
-                        // if vm_instance.stack_frames.is_empty() {
-                        // Somehow update the main instruction group to _just_ be the new group
-                        match handler.as_ref() {
-                            SteelVal::Closure(closure) => {
-                                if vm_instance.thread.stack_frames.is_empty() {
-                                    vm_instance.sp = last.sp;
-
-                                    // Push on a dummy stack frame if we're at the top
-                                    vm_instance.thread.stack_frames.push(StackFrame::new(
-                                        last.sp,
-                                        Gc::clone(&closure),
-                                        0,
-                                        Rc::from([]),
-                                    ));
-                                }
-
-                                vm_instance.sp = last.sp;
-                                vm_instance.instructions = closure.body_exp();
-                                // vm_instance.spans = closure.spans();
-
-                                last.handler = None;
-
-                                #[cfg(not(feature = "unsafe-internals"))]
-                                {
-                                    last.function = closure.clone();
-                                }
-
-                                vm_instance.ip = 0;
-
-                                // Put this back as the last stack frame
-                                vm_instance.thread.stack_frames.push(last);
-
-                                vm_instance.pop_count += 1;
-                            }
-                            _ => {
-                                stop!(TypeMismatch => "expected a function for the exception handler, found: {}", handler)
-                            }
-                        }
-
-                        continue 'outer;
-                    }
-                }
-
-                return Err(e);
-            } else {
-                // self.profiler.report();
-                // self.profiler.report_time_spend();
-                // self.profiler.report_basic_blocks();
-
-                // self.upvalue_head = vm_instance.upvalue_head;
-
-                // println!(
-                //     "------ Total trace samples: {} ------",
-                //     self.profiler.sample_count
-                // );
-
-                // panic!("GETTING HERE")
-
-                // println!("GETTING HERE");
-
-                // while self.stack.pop().is_some() {}
-
-                // dbg!(self.stack_frames.len());
-
-                for frame in &vm_instance.thread.stack_frames {
-                    if Continuation::close_marks(&vm_instance, &frame) {
-                        println!("_____ Closed frame in pop ______");
-                    }
-                }
-
-                // Clean up
-                self.stack.clear();
-
-                #[cfg(feature = "profiling")]
-                if log_enabled!(target: "pipeline_time", log::Level::Debug) {
-                    debug!(
-                        target: "pipeline_time",
-                        "VM Evaluation Time: {:?}",
-                        execution_time.elapsed()
-                    );
-                };
-
-                // println!("FINISHED");
-
-                return result;
-            }
-        }
-    }
-
-    // pub fn snapshot_stack_trace(&self) -> DehydratedStackTrace {
-    //     DehydratedStackTrace::new(
-    //         self.stack_frames
-    //             .iter()
-    //             .map(|x| DehydratedCallContext::new(x.span))
-    //             .collect(),
-    //     )
-    // }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct OpenContinuationMark {
-    // Lazily capture the frames we need to?
-    pub(crate) current_frame: StackFrame,
-    pub(crate) stack_frame_offset: usize,
-    instructions: Rc<[DenseInstruction]>,
-
-    // Captured at creation, everything on the stack
-    // from the current frame
-    pub(crate) current_stack_values: Vec<SteelVal>,
-
-    ip: usize,
-    sp: usize,
-    pop_count: usize,
-
-    #[cfg(debug_assertions)]
-    closed_continuation: ClosedContinuation,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-// TODO: This should replace the continuation value.
-pub enum ContinuationMark {
-    Closed(ClosedContinuation),
-    Open(OpenContinuationMark),
-}
-
-impl ContinuationMark {
-    pub fn close(&mut self, ctx: &VmCore<'_>) {
-        match self {
-            ContinuationMark::Closed(_) => {}
-            ContinuationMark::Open(open) => {
-                let mut continuation = ctx.new_closed_continuation_from_state();
-
-                // continuation.stack.truncate(open.stack_frame_offset);
-                continuation.stack.truncate(open.sp);
-                continuation.stack.append(&mut open.current_stack_values);
-
-                continuation.ip = open.ip;
-                continuation.sp = open.sp;
-                continuation.pop_count = open.pop_count;
-                continuation.instructions = Rc::clone(&open.instructions);
-
-                continuation.current_frame = open.current_frame.clone();
-
-                #[cfg(debug_assertions)]
-                {
-                    debug_assert_eq!(open.closed_continuation.stack, continuation.stack);
-                    debug_assert_eq!(
-                        open.closed_continuation.stack_frames.len(),
-                        continuation.stack_frames.len()
-                    );
-                    debug_assert_eq!(
-                        open.closed_continuation.stack_frames,
-                        continuation.stack_frames
-                    );
-                }
-
-                *self = ContinuationMark::Closed(continuation);
-            }
-        }
-    }
-
-    fn into_open_mark(self) -> Option<OpenContinuationMark> {
-        if let Self::Open(open) = self {
-            Some(open)
-        } else {
-            None
-        }
-    }
-
-    fn into_closed(self) -> Option<ClosedContinuation> {
-        if let Self::Closed(closed) = self {
-            Some(closed)
-        } else {
-            None
-        }
-    }
-}
-
-impl Continuation {
-    pub fn close_marks(ctx: &VmCore<'_>, stack_frame: &StackFrame) -> bool {
-        if let Some(cont_mark) = stack_frame
-            .weak_continuation_mark
-            .as_ref()
-            .and_then(|x| Weak::upgrade(&x.inner))
-        {
-            cont_mark.borrow_mut().close(ctx);
-
-            return true;
-        }
-
-        false
-    }
-
-    pub fn set_state_from_continuation(ctx: &mut VmCore<'_>, this: Self) {
-        // Check if this is an open
-        let maybe_open_mark = (*this.inner.borrow()).clone().into_open_mark();
-
-        if let Some(open) = maybe_open_mark {
-            // println!("Setting state from open continuation");
-
-            let strong_count = Rc::strong_count(&this.inner);
-            let weak_count = Rc::weak_count(&this.inner);
-
-            // println!(
-            //     "Strong count: {} - Weak count: {}",
-            //     strong_count, weak_count
-            // );
-
-            while let Some(stack_frame) = ctx.thread.stack_frames.pop() {
-                ctx.pop_count -= 1;
-
-                if let Some(mark) = &stack_frame
-                    .weak_continuation_mark
-                    .as_ref()
-                    .and_then(|x| Weak::upgrade(&x.inner))
-                {
-                    if Rc::ptr_eq(&mark, &this.inner) {
-                        if weak_count == 1 && strong_count > 1 {
-                            if Self::close_marks(ctx, &stack_frame) {
-                                // TODO: We shouldn't have to both close the frame and also
-                                // set state from the continuation in both spots. There is a nefarious
-                                // bug here that I haven't yet resolved.
-                                let definitely_closed =
-                                    this.inner.borrow().clone().into_closed().unwrap();
-
-                                ctx.set_state_from_continuation(definitely_closed);
-
-                                return;
-
-                                // println!("CLOSING MARKS WHEN SETTING STATE FROM CONTINUATION: pop count: {}", ctx.pop_count);
-                            }
-                        }
-
-                        ctx.sp = open.sp;
-                        ctx.ip = open.ip;
-                        ctx.instructions = Rc::clone(&open.instructions);
-
-                        ctx.thread.stack.truncate(open.sp);
-
-                        // TODO: Probably move the pointer for the stack frame as well?
-                        ctx.thread.stack.extend(open.current_stack_values.clone());
-
-                        #[cfg(debug_assertions)]
-                        {
-                            debug_assert_eq!(ctx.sp, open.closed_continuation.sp);
-                            debug_assert_eq!(ctx.ip, open.closed_continuation.ip);
-                            debug_assert_eq!(
-                                ctx.instructions,
-                                open.closed_continuation.instructions
-                            );
-                            debug_assert_eq!(ctx.thread.stack, open.closed_continuation.stack);
-
-                            debug_assert_eq!(ctx.pop_count, open.closed_continuation.pop_count);
-
-                            debug_assert_eq!(
-                                ctx.thread.stack_frames,
-                                open.closed_continuation.stack_frames
-                            );
-                        }
-
-                        return;
-                    }
-                }
-
-                ctx.thread.stack.truncate(stack_frame.sp);
-                ctx.ip = stack_frame.ip;
-                ctx.sp = ctx.get_last_stack_frame_sp();
-                ctx.instructions = Rc::clone(&stack_frame.instructions);
-
-                if Self::close_marks(ctx, &stack_frame) {
-                    // println!("CLOSING MARKS WHEN SETTING STATE FROM CONTINUATION");
-                }
-            }
-
-            panic!("Failed to find an open continuation on the stack");
-        } else {
-            // println!("Setting state from closed continuation");
-
-            match Rc::try_unwrap(this.inner).map(|x| x.into_inner()) {
-                Ok(cont) => {
-                    ctx.set_state_from_continuation(cont.into_closed().unwrap());
-                }
-                Err(e) => {
-                    let definitely_closed = e.borrow().clone().into_closed().unwrap();
-
-                    ctx.set_state_from_continuation(definitely_closed);
-                }
-            }
-        }
-    }
-
-    pub fn ptr_eq(&self, other: &Self) -> bool {
-        Rc::ptr_eq(&self.inner, &other.inner)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct Continuation {
-    // TODO: This _might_ need to be a weak reference. We'll see!
-    pub(crate) inner: Rc<RefCell<ContinuationMark>>,
-}
-
-#[derive(Clone, Debug)]
-struct WeakContinuation {
-    pub(crate) inner: Weak<RefCell<ContinuationMark>>,
-}
-
-impl WeakContinuation {
-    fn from_strong(cont: &Continuation) -> Self {
-        Self {
-            inner: Rc::downgrade(&cont.inner),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct ClosedContinuation {
-    pub(crate) stack: Vec<SteelVal>,
-    pub(crate) current_frame: StackFrame,
-    instructions: Rc<[DenseInstruction]>,
-    pub(crate) stack_frames: Vec<StackFrame>,
-    ip: usize,
-    sp: usize,
-    pop_count: usize,
-
-    #[cfg(debug_assertions)]
-    closed_continuation: Option<Box<ClosedContinuation>>,
-}
-
-pub trait VmContext {
-    // This allows for some funky self calling business
-    fn call_function_one_arg(&mut self, function: &SteelVal, arg: SteelVal) -> Result<SteelVal>;
-
-    // Call with two args
-    fn call_function_two_arg(
-        &mut self,
-        function: &SteelVal,
-        arg1: SteelVal,
-        arg2: SteelVal,
-    ) -> Result<SteelVal>;
-
-    fn call_function_many_args(
-        &mut self,
-        function: &SteelVal,
-        args: List<SteelVal>,
-    ) -> Result<SteelVal>;
-
-    fn call_transduce(
-        &mut self,
-        ops: &[Transducers],
-        root: SteelVal,
-        reducer: Reducer,
-        span: Option<Span>,
-    ) -> Result<SteelVal>;
-}
-
-// For when we want a reference to the built in context as well -> In the event we want to call something
-// See if this is even possible -> if you ever want to offload function calls to the
-// pub type BuiltInSignature2 = fn(Vec<SteelVal>, &mut dyn VmContext) -> Result<SteelVal>;
-
-// These reference the current existing thread
-// TODO: Change this to refer directly to SteelThread in some way
-pub type BuiltInSignature =
-    for<'a, 'b> fn(&'a mut VmCore<'b>, &[SteelVal]) -> Option<Result<SteelVal>>;
-
-impl<'a> VmContext for VmCore<'a> {
-    fn call_function_one_arg(&mut self, function: &SteelVal, arg: SteelVal) -> Result<SteelVal> {
-        let span = Span::default();
-        self.call_func_or_else(
-            function,
-            arg,
-            &span,
-            throw!(TypeMismatch => format!("application not a procedure: {function}")),
-        )
-    }
-
-    fn call_function_two_arg(
-        &mut self,
-        function: &SteelVal,
-        arg1: SteelVal,
-        arg2: SteelVal,
-    ) -> Result<SteelVal> {
-        let span = Span::default();
-        self.call_func_or_else_two_args(
-            function,
-            arg1,
-            arg2,
-            &span,
-            throw!(TypeMismatch => format!("application not a procedure: {function}")),
-        )
-    }
-
-    fn call_function_many_args(
-        &mut self,
-        function: &SteelVal,
-        args: List<SteelVal>,
-    ) -> Result<SteelVal> {
-        let span = Span::default();
-        self.call_func_or_else_many_args(
-            function,
-            args,
-            &span,
-            throw!(TypeMismatch => format!("application not a procedure: {function}")),
-        )
-    }
-
-    fn call_transduce(
-        &mut self,
-        ops: &[Transducers],
-        root: SteelVal,
-        reducer: Reducer,
-        span: Option<Span>,
-    ) -> Result<SteelVal> {
-        let span = span.unwrap_or_default();
-        self.transduce(ops, root, reducer, &span)
-    }
-}
-
-// TODO: Make dynamic block use this
-enum FunctionBlock {
-    Specialized(for<'r> fn(&'r mut VmCore<'_>) -> Result<()>),
-    Unrolled(Rc<[for<'r> fn(&'r mut VmCore<'_>) -> Result<()>]>),
-}
-
-// Construct a basic block for a series of instructions
-// Note: A call to either apply or call/cc should invalidate this, as it fundamentally
-// violates the principle of a basic block.
-#[derive(Clone)]
-pub struct DynamicBlock {
-    basic_block: InstructionPattern,
-    entry_inst: DenseInstruction,
-    header_func: Option<for<'r> fn(&'r mut VmCore<'_>, usize) -> Result<()>>,
-    handlers: Rc<[for<'r> fn(&'r mut VmCore<'_>) -> Result<()>]>,
-    specialized: Option<for<'r> fn(&'r mut VmCore<'_>, usize) -> Result<()>>,
-}
-
-impl DynamicBlock {
-    fn call(&self, context: &mut VmCore<'_>) -> Result<()> {
-        // println!("---- Entering dynamic block ----");
-        // println!("{:#?}", self.basic_block);
-
-        if let Some(specialized) = self.specialized {
-            specialized(context, self.entry_inst.payload_size as usize)?;
-        } else {
-            if let Some(header) = self.header_func {
-                // println!("Calling special entry block");
-                header(context, self.entry_inst.payload_size as usize)?;
-            }
-
-            for func in self.handlers.iter() {
-                func(context)?;
-            }
-        }
-
-        // println!("---- Exited dynamic block ----");
-        // println!(
-        // "Current op code: {:?}",
-        // context.instructions[context.ip].op_code
-        // );
-        Ok(())
-    }
-
-    #[cfg(feature = "dynamic")]
-    fn construct_basic_block(head: DenseInstruction, basic_block: InstructionPattern) -> Self {
-        // TODO: Drop the first
-        let mut handlers = basic_block.block.iter().peekable();
-        // .map(|x| OP_CODE_TABLE[x as usize]);
-        // .collect();
-
-        let mut header_func = None;
-
-        log::debug!(target: "super-instructions", "{basic_block:#?}");
-
-        if let Some(first) = handlers.peek() {
-            header_func = op_code_requires_payload(first.0);
-        }
-
-        if header_func.is_some() {
-            handlers.next();
-        }
-
-        let op_codes: Vec<_> = handlers.clone().copied().collect();
-
-        let specialized = dynamic::DYNAMIC_SUPER_PATTERNS.get(&op_codes);
-
-        if specialized.is_some() {
-            println!("Found specialized function!");
-        }
-
-        let handlers = handlers.map(|x| OP_CODE_TABLE[x.0 as usize]).collect();
-
-        Self {
-            basic_block,
-            handlers,
-            entry_inst: head,
-            header_func,
-            // TODO: Come back and add the specialized ones back in
-            specialized,
-        }
-    }
-}
-
-pub struct VmCore<'a> {
-    pub(crate) instructions: Rc<[DenseInstruction]>,
-    pub(crate) constants: ConstantMap,
-    pub(crate) ip: usize,
-    pub(crate) sp: usize,
-    pub(crate) pop_count: usize,
-    pub(crate) depth: usize,
-    pub(crate) thread: &'a mut SteelThread,
-    pub(crate) root_spans: &'a [Span],
-}
-
-// TODO: Delete this entirely, and just have the run function live on top of the SteelThread.
-//
-impl<'a> VmCore<'a> {
-    fn new_unchecked(
-        instructions: Rc<[DenseInstruction]>,
-        constants: ConstantMap,
-        spans: Rc<[Span]>,
-        // span_id: usize,
-        thread: &'a mut SteelThread,
-        root_spans: &'a [Span],
-    ) -> VmCore<'a> {
-        VmCore {
-            instructions,
-            constants,
-            ip: 0,
-            sp: 0,
-            pop_count: 1,
-            // spans,
-            // span_id,
-            depth: 0,
-            thread,
-            root_spans,
-        }
-    }
-
-    fn new(
-        instructions: Rc<[DenseInstruction]>,
-        constants: ConstantMap,
-        spans: Rc<[Span]>,
-        // span_id: usize,
-        thread: &'a mut SteelThread,
-        root_spans: &'a [Span],
-    ) -> Result<VmCore<'a>> {
-        if instructions.is_empty() {
-            stop!(Generic => "empty stack!")
-        }
-
-        // Set up the instruction pointers here
-        // let function = Gc::new(ByteCodeLambda::main(instructions.iter().copied().collect()));
-
-        // let current_frame = StackFrame::new(0, function, 0, Rc::clone(&instructions));
-
-        Ok(VmCore {
-            instructions,
-            constants,
-            ip: 0,
-            sp: 0,
-            pop_count: 1,
-            // spans,
-            // span_id,
-            depth: 0,
-            thread,
-            root_spans,
-        })
-    }
-
-    pub fn make_box(&mut self, value: SteelVal) -> SteelVal {
-        let allocated_var = self.thread.heap.allocate(
-            value,
-            self.thread.stack.iter(),
-            self.thread.stack_frames.iter().map(|x| x.function.as_ref()),
-            self.thread.global_env.roots(),
-        );
-
-        SteelVal::HeapAllocated(allocated_var)
-    }
-
-    pub fn make_mutable_vector(&mut self, values: Vec<SteelVal>) -> SteelVal {
-        let allocated_var = self.thread.heap.allocate_vector(
-            values,
-            self.thread.stack.iter(),
-            self.thread.stack_frames.iter().map(|x| x.function.as_ref()),
-            self.thread.global_env.roots(),
-        );
-
-        SteelVal::MutableVector(allocated_var)
-    }
-
-    fn gc_collect(&mut self) {
-        self.thread.heap.collect(
-            None,
-            None,
-            self.thread.stack.iter(),
-            self.thread.stack_frames.iter().map(|x| x.function.as_ref()),
-            self.thread.global_env.roots(),
-        );
-    }
-
-    fn weak_collection(&mut self) {
-        self.thread.heap.weak_collection();
-    }
-
-    fn new_open_continuation_from_state(&self) -> Continuation {
-        // println!("Creating new open continuation");
-
-        // return MaybeContinuation {
-        //     inner: Rc::new(RefCell::new(ContinuationMark::Closed(
-        //         self.new_closed_continuation_from_state(),
-        //     ))),
-        // };
-
-        let offset = self.get_offset();
-
-        Continuation {
-            inner: Rc::new(RefCell::new(ContinuationMark::Open(OpenContinuationMark {
-                current_frame: self.thread.stack_frames.last().unwrap().clone(),
-                stack_frame_offset: self.thread.stack.len(),
-                current_stack_values: self.thread.stack[offset..].to_vec(),
-                instructions: self.instructions.clone(),
-                ip: self.ip,
-                sp: self.sp,
-                pop_count: self.pop_count,
-                #[cfg(debug_assertions)]
-                closed_continuation: self.new_closed_continuation_from_state(),
-            }))),
-        }
-    }
-
-    // Could be neat at some point: https://docs.rs/stacker/latest/stacker/
-    fn new_closed_continuation_from_state(&self) -> ClosedContinuation {
-        // dbg!(&self.thread.stack.len());
-        // dbg!(&self.thread.stack_frames.len());
-
-        ClosedContinuation {
-            stack: self.thread.stack.clone(),
-            instructions: Rc::clone(&self.instructions),
-            current_frame: self.thread.stack_frames.last().unwrap().clone(),
-            stack_frames: self.thread.stack_frames.clone(),
-            ip: self.ip,
-            sp: self.sp,
-            pop_count: self.pop_count,
-            #[cfg(debug_assertions)]
-            closed_continuation: None,
-        }
-    }
-
-    // Grab the continuation - but this continuation can only be played once
-    fn new_oneshot_continuation_from_state(&mut self) -> ClosedContinuation {
-        ClosedContinuation {
-            stack: std::mem::take(&mut self.thread.stack),
-            instructions: Rc::clone(&self.instructions),
-            current_frame: self.thread.current_frame.clone(),
-            stack_frames: std::mem::take(&mut self.thread.stack_frames),
-            ip: self.ip,
-            sp: self.sp,
-            pop_count: self.pop_count,
-            #[cfg(debug_assertions)]
-            closed_continuation: None,
-        }
-    }
-
-    pub fn snapshot_stack_trace(&self) -> DehydratedStackTrace {
-        DehydratedStackTrace::new(
-            self.thread
-                .stack_frames
-                .iter()
-                .map(|x| {
-                    DehydratedCallContext::new(
-                        self.thread
-                            .function_interner
-                            .spans
-                            .get(&x.function.id)
-                            .and_then(|x| x.get(self.ip))
-                            .copied(),
-                    )
-                })
-                .collect(),
-        )
-    }
-
-    // #[inline(always)]
-    fn set_state_from_continuation(&mut self, continuation: ClosedContinuation) {
-        // dbg!(&continuation.stack);
-
-        // Linked list of frames perhaps?
-        // TODO: This, unfortunately, will close any open continuations even if they're within the same subset.
-        // So what we really should do is keep a set of sub continuations inside each open continuation, to see
-        // if there are currently open continuations inside of those?
-        //
-        // Or maybe a List<MaybeContinuation> inside of each continuation? Something like that
-        //
-        // That way we can in relatively quick amount of time scan for the continuations and delay
-        // copying everything over.
-
-        let mut marks_still_open = fxhash::FxHashSet::default();
-
-        for frame in &continuation.stack_frames {
-            if let Some(cont_mark) = frame
-                .weak_continuation_mark
-                .as_ref()
-                .and_then(|x| Weak::upgrade(&x.inner))
-            {
-                marks_still_open.insert(cont_mark.as_ptr() as usize);
-                // println!("Found mark still open: {:p}", cont_mark.inner);
-            }
-        }
-
-        while let Some(frame) = self.thread.stack_frames.pop() {
-            if let Some(cont_mark) = frame
-                .weak_continuation_mark
-                .as_ref()
-                .and_then(|x| Weak::upgrade(&x.inner))
-            {
-                // Close frame if the new continuation doesn't have it
-                if !marks_still_open.contains(&(cont_mark.as_ptr() as usize)) {
-                    // println!("Closing marks on stack frame, still open");
-
-                    self.thread.stack.truncate(frame.sp);
-                    self.ip = frame.ip;
-                    self.sp = self.get_last_stack_frame_sp();
-                    self.instructions = Rc::clone(&frame.instructions);
-
-                    self.close_continuation_marks(&frame);
-                    continue;
-                } else {
-                    // println!("Skipping closing frame: {:p}", cont_mark.inner);
-                }
-            }
-        }
-
-        self.thread.stack = continuation.stack;
-        self.instructions = continuation.instructions;
-        // self.spans = continuation.spans;
-        self.ip = continuation.ip;
-        self.sp = continuation.sp;
-        self.pop_count = continuation.pop_count;
-        self.thread.stack_frames = continuation.stack_frames;
-        self.thread.current_frame = continuation.current_frame;
-    }
-
-    // #[inline(always)]
-    fn construct_continuation_function(&self) -> Continuation {
-        // let captured_continuation = self.new_continuation_from_state();
-
-        let continuation = self.new_open_continuation_from_state();
-
-        // SteelVal::ContinuationFunction(continuation)
-
-        continuation
-    }
-
-    fn construct_oneshot_continuation_function(&self) -> SteelVal {
-        todo!()
-    }
-
-    // Reset state FULLY
-    fn call_with_instructions_and_reset_state(
-        &mut self,
-        closure: Rc<[DenseInstruction]>,
-        // spans: Rc<[Span]>,
-    ) -> Result<SteelVal> {
-        let old_ip = self.ip;
-        let old_instructions = std::mem::replace(&mut self.instructions, closure);
-        let old_pop_count = self.pop_count;
-        // let old_spans = std::mem::replace(&mut self.spans, spans);
-
-        // dbg!(self.sp);
-
-        // dbg!(self.thread.stack_frames.last().map(|x| x.sp));
-        // let old_sp = self.sp;
-
-        // let old_stack_index = self.stack_index;
-
-        self.ip = 0;
-        // Force the execution to be done earlier
-        self.pop_count = 1;
-
-        self.depth += 1;
-
-        let res = self.vm();
-
-        self.depth -= 1;
-
-        self.ip = old_ip;
-        self.instructions = old_instructions;
-        self.pop_count = old_pop_count;
-        // self.spans = old_spans;
-        self.sp = self.thread.stack_frames.last().map(|x| x.sp).unwrap_or(0);
-
-        // dbg!(self.sp);
-        // dbg!(self.thread.stack_frames.last().map(|x| x.sp));
-
-        // self.stack_frames.pop();
-
-        res
-    }
-
-    // #[inline(always)]
-    pub(crate) fn call_func_or_else<F: FnOnce() -> SteelErr>(
-        &mut self,
-        func: &SteelVal,
-        arg: SteelVal,
-        cur_inst_span: &Span,
-        err: F,
-    ) -> Result<SteelVal> {
-        match func {
-            SteelVal::FuncV(func) => {
-                let arg_vec = [arg];
-                func(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            SteelVal::BoxedFunction(func) => {
-                let arg_vec = [arg];
-                func.func()(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            // SteelVal::ContractedFunction(cf) => {
-            //     let arg_vec = vec![arg];
-            //     cf.apply(arg_vec, cur_inst_span, self)
-            // }
-            SteelVal::MutFunc(func) => {
-                let mut arg_vec: Vec<_> = vec![arg];
-                func(&mut arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            // SteelVal::BuiltIn(func) => {
-            //     let arg_vec = [arg];
-            //     func(self, &arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            // }
-            SteelVal::Closure(closure) => self.call_with_one_arg(closure, arg),
-            _ => Err(err()),
-        }
-    }
-
-    // #[inline(always)]
-    pub(crate) fn call_func_or_else_two_args<F: FnOnce() -> SteelErr>(
-        &mut self,
-        func: &SteelVal,
-        arg1: SteelVal,
-        arg2: SteelVal,
-        cur_inst_span: &Span,
-        err: F,
-    ) -> Result<SteelVal> {
-        match func {
-            SteelVal::FuncV(func) => {
-                let arg_vec = [arg1, arg2];
-                func(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            SteelVal::BoxedFunction(func) => {
-                let arg_vec = [arg1, arg2];
-                func.func()(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            // SteelVal::ContractedFunction(cf) => {
-            //     let arg_vec = vec![arg1, arg2];
-            //     cf.apply(arg_vec, cur_inst_span, self)
-            // }
-            SteelVal::MutFunc(func) => {
-                let mut arg_vec: Vec<_> = vec![arg1, arg2];
-                func(&mut arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            // SteelVal::BuiltIn(func) => {
-            //     let arg_vec = [arg1, arg2];
-            //     func(self, &arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            // }
-            SteelVal::Closure(closure) => self.call_with_two_args(closure, arg1, arg2),
-            _ => Err(err()),
-        }
-    }
-
-    // #[inline(always)]
-    pub(crate) fn call_func_or_else_many_args<F: FnOnce() -> SteelErr>(
-        &mut self,
-        func: &SteelVal,
-        args: impl IntoIterator<Item = SteelVal>,
-        cur_inst_span: &Span,
-        err: F,
-    ) -> Result<SteelVal> {
-        match func {
-            SteelVal::FuncV(func) => {
-                let arg_vec: Vec<_> = args.into_iter().collect();
-                func(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            SteelVal::BoxedFunction(func) => {
-                let arg_vec: Vec<_> = args.into_iter().collect();
-                func.func()(&arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            // SteelVal::ContractedFunction(cf) => {
-            //     let arg_vec: Vec<_> = args.into_iter().collect();
-            //     cf.apply(arg_vec, cur_inst_span, self)
-            // }
-            SteelVal::MutFunc(func) => {
-                let mut arg_vec: Vec<_> = args.into_iter().collect();
-                func(&mut arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            }
-            // SteelVal::BuiltIn(func) => {
-            //     let arg_vec: Vec<_> = args.into_iter().collect();
-            //     func(self, &arg_vec).map_err(|x| x.set_span_if_none(*cur_inst_span))
-            // }
-            SteelVal::Closure(closure) => self.call_with_args(closure, args),
-            _ => Err(err()),
-        }
-    }
-
-    // Call with an arbitrary number of arguments
-    pub(crate) fn call_with_args(
-        &mut self,
-        closure: &Gc<ByteCodeLambda>,
-        args: impl IntoIterator<Item = SteelVal>,
-    ) -> Result<SteelVal> {
-        // println!("Arity: {:?}", closure.arity());
-        // println!("Multi arity: {:?}", closure.is_multi_arity);
-
-        let prev_length = self.thread.stack.len();
-        // self.stack_index.push(prev_length);
-
-        // if self.stack_frames
-
-        let instructions = closure.body_exp();
-        // let spans = closure.spans();
-
-        // TODO:
-        self.thread.stack_frames.push(StackFrame::new(
-            prev_length,
-            Gc::clone(closure),
-            0,
-            instructions.clone(),
-            // spans.clone(),
-        ));
-
-        self.sp = prev_length;
-
-        let mut argument_count = 0;
-        for arg in args {
-            self.thread.stack.push(arg);
-            argument_count += 1;
-        }
-
-        self.adjust_stack_for_multi_arity(closure, argument_count, &mut 0)?;
-
-        // self.function_stack
-        // .push(CallContext::new(Gc::clone(closure)));
-
-        self.call_with_instructions_and_reset_state(instructions)
-    }
-
-    // Calling convention
-    pub(crate) fn call_with_two_args(
-        &mut self,
-        closure: &Gc<ByteCodeLambda>,
-        arg1: SteelVal,
-        arg2: SteelVal,
-    ) -> Result<SteelVal> {
-        let prev_length = self.thread.stack.len();
-        // self.stack_index.push(prev_length);
-
-        self.thread.stack_frames.push(StackFrame::new(
-            prev_length,
-            Gc::clone(closure),
-            0,
-            Rc::from([]),
-            // Rc::from([]),
-        ));
-
-        self.sp = prev_length;
-
-        self.thread.stack.push(arg1);
-        self.thread.stack.push(arg2);
-        // self.function_stack
-        //     .push(CallContext::new(Gc::clone(closure)));
-
-        self.adjust_stack_for_multi_arity(closure, 2, &mut 0)?;
-
-        self.call_with_instructions_and_reset_state(closure.body_exp())
-    }
-
-    // Calling convention
-    pub(crate) fn call_with_one_arg(
-        &mut self,
-        closure: &Gc<ByteCodeLambda>,
-        arg: SteelVal,
-    ) -> Result<SteelVal> {
-        let prev_length = self.thread.stack.len();
-
-        self.thread.stack_frames.push(StackFrame::new(
-            prev_length,
-            Gc::clone(closure),
-            0,
-            Rc::from([]),
-            // Rc::from([]),
-        ));
-
-        self.sp = prev_length;
-
-        // println!("PUSHING NEW STACK INDEX ON");
-
-        // self.stack_index.push(prev_length);
-        self.thread.stack.push(arg);
-        // self.function_stack
-        //     .push(CallContext::new(Gc::clone(closure)));
-
-        self.adjust_stack_for_multi_arity(closure, 1, &mut 0)?;
-
-        self.call_with_instructions_and_reset_state(closure.body_exp())
-    }
-
-    // pub fn get_slice_of_size_two(&mut self) -> &mut [SteelVal] {
-    //     if let &mut [.., last, two] = self.thread.stack.as_mut_slice() {
-    //         &mut [last, two]
-    //     } else {
-    //         unreachable!()
-    //     }
-    // }
-
-    pub(crate) fn vm(&mut self) -> Result<SteelVal> {
-        // let mut cur_inst;
-
-        if self.depth > 64 {
-            // TODO: Unwind the callstack? Patch over to the VM call stack rather than continue to do recursive calls?
-            stop!(Generic => "stack overflow! The rust call stack is currently used for transducers, so we impose a hard recursion limit of 64"; self.current_span());
-        }
-
-        macro_rules! inline_primitive {
-            ($name:tt, $payload_size:expr) => {{
-                let last_index = self.thread.stack.len() - $payload_size as usize;
-
-                let result = match $name(&mut self.thread.stack[last_index..]) {
-                    Ok(value) => value,
-                    Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                };
-
-                // This is the old way... lets see if the below way improves the speed
-                // self.thread.stack.truncate(last_index);
-                // self.thread.stack.push(result);
-
-                self.thread.stack.truncate(last_index + 1);
-                *self.thread.stack.last_mut().unwrap() = result;
-                // self.thread.stack.push(result);
-
-                self.ip += 2;
-            }};
-        }
-
-        macro_rules! inline_register_primitive {
-            ($name:tt) => {{
-                let read_local = &self.instructions[self.ip];
-                let push_const = &self.instructions[self.ip + 1];
-
-                // get the local
-                // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-                let offset = self.get_offset();
-                let local_value =
-                    self.thread.stack[read_local.payload_size as usize + offset].clone();
-
-                // get the const
-                let const_val = self.constants.get(push_const.payload_size as usize);
-
-                let result = match $name(&[local_value, const_val]) {
-                    Ok(value) => value,
-                    Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                };
-
-                self.thread.stack.push(result);
-
-                self.ip += 2;
-            }};
-        }
-
-        // TODO: Directly call the binary operation with the value as an isize
-        macro_rules! inline_register_primitive_immediate {
-            ($name:tt) => {{
-                let read_local = &self.instructions[self.ip];
-                let push_const = &self.instructions[self.ip + 1];
-
-                // get the local
-                // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-                let offset = self.get_offset();
-                let local_value =
-                    self.thread.stack[read_local.payload_size as usize + offset].clone();
-
-                // get the const value, if it can fit into the value...
-                let const_val = SteelVal::IntV(push_const.payload_size as isize);
-
-                // sub_handler_none_int
-
-                let result = match $name(&[local_value, const_val]) {
-                    Ok(value) => value,
-                    Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                };
-
-                self.thread.stack.push(result);
-
-                self.ip += 2;
-            }};
-        }
-
-        // let mut frame = self.stack_frames.last().unwrap();
-
-        // while self.ip < self.instructions.len() {
-        loop {
-            // Process the op code
-            // TODO: Just build up a slice, don't directly store the full vec of op codes
-
-            // assert_eq!(self.spans.len(), self.instructions.len());
-
-            #[cfg(feature = "dynamic")]
-            if let Some(pat) = self.thread.profiler.process_opcode(
-                &self.instructions[self.ip].op_code,
-                self.ip,
-                &self.instructions,
-                // Grab the current stack frame
-                self.thread.stack_frames.last().map(|x| x.function.as_ref()),
-            ) {
-                // if count > 1000 {
-                log::debug!(target: "super-instructions", "Found a hot pattern, creating super instruction...");
-
-                log::debug!(target: "super-instructions", "{:#?}", pat);
-
-                if USE_SUPER_INSTRUCTIONS {
-                    // Index of the starting opcode
-                    let start = pat.pattern.start;
-
-                    let id = self.thread.super_instructions.len();
-
-                    let guard = self.thread.stack_frames.last_mut().unwrap();
-
-                    // Next run should get the new sequence of opcodes
-                    let (head, _) = guard.function.update_to_super_instruction(start, id);
-
-                    let block = DynamicBlock::construct_basic_block(head, pat);
-
-                    self.thread.super_instructions.push(Rc::new(block));
-                }
-                // self.thread.super_instructions.push(Rc::new(|ctx| {
-                //     block.call(ctx);
-                // }))
-
-                // let
-                // }
-            }
-
-            // println!("{:?}", self.instructions[self.ip]);
-
-            // let now = std::time::Instant::now();
-
-            // TODO -> don't just copy the value from the instructions
-            // We don't need to do that... Figure out a way to just take a reference to the value
-            // Perhaps if the instructions are guaranteed to be immutable references that cannot be mutated
-            // The cost of moving the instruction out of the vector is not what we want. Perhaps move instructions
-            // into its own local array since we don't recur in this function?
-
-            // cur_inst = self.instructions[self.ip];
-
-            // Try to eliminate the current instruction variable
-            // We can elide the reads, and instead opt to just go for values directly on the instructions
-            // Otherwise, we're going to be copying the instruction _every_ time we iterate which is going to slow down the loop
-            // We'd rather just reference the instruction and call it a day
-
-            let instr = self.instructions[self.ip];
-
-            match instr {
-                DenseInstruction {
-                    op_code: OpCode::DynSuperInstruction,
-                    payload_size,
-                    ..
-                } => {
-                    self.cut_sequence();
-
-                    // TODO: Store in a different spot? So that we can avoid cloning on every iteration?
-                    let super_instruction =
-                        { self.thread.super_instructions[payload_size as usize].clone() };
-
-                    super_instruction.call(self)?;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::POPN,
-                    payload_size,
-                    ..
-                } => {
-                    let last = self.thread.stack.pop().unwrap();
-
-                    // println!("-- POP N: {} -- ", payload_size);
-
-                    // println!("popping: {}", payload_size);
-                    // println!("Stack length: {:?}", self.thread.stack.len());
-
-                    // println!("{:#?}", self.thread.stack);
-
-                    // if payload_size as usize > self.thread.stack.len() {
-                    //     self.thread.stack.clear()
-                    // } else {
-                    //     self.thread
-                    //         .stack
-                    //         .truncate(self.thread.stack.len() - payload_size as usize);
-                    // }
-
-                    self.thread
-                        .stack
-                        .truncate(self.thread.stack.len() - payload_size as usize);
-
-                    self.thread.stack.push(last);
-
-                    self.ip += 1;
-
-                    // todo!()
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::POPSINGLE,
-                    ..
-                } => {
-                    self.thread.stack.pop();
-                    self.ip += 1;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::POPPURE,
-                    ..
-                } => {
-                    // println!("-- POP PURE --");
-
-                    if let Some(r) = self.handle_pop_pure() {
-                        return r;
-                    }
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::SUBREGISTER1,
-                    ..
-                } => {
-                    let read_local = &self.instructions[self.ip + 1];
-
-                    // get the local
-                    // let offset = frame.index;
-                    // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-                    let offset = self.get_offset();
-                    let local_value =
-                        self.thread.stack[read_local.payload_size as usize + offset].clone();
-
-                    let result = match subtract_primitive(&[local_value, SteelVal::IntV(1)]) {
-                        Ok(value) => value,
-                        Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                    };
-
-                    self.thread.stack.push(result);
-
-                    self.ip += 2;
-                }
-
-                // Specialization of specific library functions!
-                DenseInstruction {
-                    op_code: OpCode::CONS,
-                    ..
-                } => {
-                    cons_handler(self)?;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::LIST,
-                    payload_size,
-                    ..
-                } => {
-                    list_handler(self, payload_size as usize)?;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::NEWBOX,
-                    ..
-                } => {
-                    new_box_handler(self)?;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::UNBOX,
-                    ..
-                } => {
-                    unbox_handler(self)?;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::SETBOX,
-                    ..
-                } => {
-                    setbox_handler(self)?;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::CAR,
-                    ..
-                } => {
-                    car_handler(self)?;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::ADDREGISTER,
-                    ..
-                } => {
-                    inline_register_primitive!(add_primitive)
-                }
-                DenseInstruction {
-                    op_code: OpCode::SUBREGISTER,
-                    ..
-                } => {
-                    inline_register_primitive!(subtract_primitive)
-                }
-                DenseInstruction {
-                    op_code: OpCode::LTEREGISTER,
-                    ..
-                } => {
-                    inline_register_primitive!(lte_primitive)
-                }
-                DenseInstruction {
-                    op_code: OpCode::ADDIMMEDIATE,
-                    ..
-                } => {
-                    inline_register_primitive_immediate!(add_primitive)
-                }
-                DenseInstruction {
-                    op_code: OpCode::SUBIMMEDIATE,
-                    ..
-                } => {
-                    // inline_register_primitive_immediate!(subtract_primitive)
-
-                    let read_local = &self.instructions[self.ip];
-                    let push_const = &self.instructions[self.ip + 1];
-
-                    // get the local
-                    // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-                    let offset = self.get_offset();
-                    let local_value =
-                        self.thread.stack[read_local.payload_size as usize + offset].clone();
-
-                    // get the const value, if it can fit into the value...
-                    let const_val = push_const.payload_size as isize;
-
-                    // sub_handler_none_int
-
-                    let result = sub_handler_none_int(self, local_value, const_val)?;
-
-                    // let result = match $name(&[local_value, const_val]) {
-                    //     Ok(value) => value,
-                    //     Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                    // };
-
-                    // let result
-
-                    self.thread.stack.push(result);
-
-                    self.ip += 2;
-                }
-                DenseInstruction {
-                    op_code: OpCode::LTEIMMEDIATE,
-                    ..
-                } => {
-                    // inline_register_primitive_immediate!(subtract_primitive)
-
-                    let read_local = &self.instructions[self.ip];
-                    let push_const = &self.instructions[self.ip + 1];
-
-                    // get the local
-                    // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-                    let offset = self.get_offset();
-                    let local_value =
-                        self.thread.stack[read_local.payload_size as usize + offset].clone();
-
-                    // get the const value, if it can fit into the value...
-                    let const_val = push_const.payload_size as isize;
-
-                    // sub_handler_none_int
-
-                    // TODO: Probably elide the stack push if the next inst is an IF
-                    let result = lte_handler_none_int(self, local_value, const_val)?;
-
-                    // let result = match $name(&[local_value, const_val]) {
-                    //     Ok(value) => value,
-                    //     Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                    // };
-
-                    // let result
-
-                    self.thread.stack.push(SteelVal::BoolV(result));
-
-                    self.ip += 2;
-                }
-                DenseInstruction {
-                    op_code: OpCode::LTEIMMEDIATEIF,
-                    ..
-                } => {
-                    // inline_register_primitive_immediate!(subtract_primitive)
-
-                    let read_local = &self.instructions[self.ip];
-                    let push_const = &self.instructions[self.ip + 1];
-
-                    // get the local
-                    // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-                    let offset = self.get_offset();
-                    let local_value =
-                        self.thread.stack[read_local.payload_size as usize + offset].clone();
-
-                    // get the const value, if it can fit into the value...
-                    let const_val = push_const.payload_size as isize;
-
-                    // sub_handler_none_int
-
-                    // TODO: Probably elide the stack push if the next inst is an IF
-                    let result = lte_handler_none_int(self, local_value, const_val)?;
-
-                    // let result = match $name(&[local_value, const_val]) {
-                    //     Ok(value) => value,
-                    //     Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                    // };
-
-                    // let result
-
-                    self.ip += 2;
-
-                    // change to truthy...
-                    if result {
-                        self.ip += 1;
-                    } else {
-                        self.ip = self.instructions[self.ip].payload_size as usize;
-                    }
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::ADD,
-                    payload_size,
-                    ..
-                } => {
-                    add_handler_payload(self, payload_size as usize)?;
-                    // inline_primitive!(add_primitive, payload_size)
-                }
-                DenseInstruction {
-                    op_code: OpCode::BINOPADD,
-                    ..
-                } => {
-                    // add_handler_payload(self, 2)?;
-
-                    let last_index = self.thread.stack.len() - 2;
-
-                    let right = self.thread.stack.pop().unwrap();
-                    let left = self.thread.stack.last().unwrap();
-
-                    let result = match add_handler_none_none(left, &right) {
-                        Ok(value) => value,
-                        Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                    };
-
-                    // let result = match $name(&mut $ctx.thread.stack[last_index..]) {
-                    //     Ok(value) => value,
-                    //     Err(e) => return Err(e.set_span_if_none($ctx.current_span())),
-                    // };
-
-                    // This is the old way... lets see if the below way improves the speed
-                    // $ctx.thread.stack.truncate(last_index);
-                    // $ctx.thread.stack.push(result);
-
-                    // self.thread.stack.truncate(last_index + 1);
-                    // *self.thread.stack.last_mut().unwrap() = result;
-
-                    *self.thread.stack.last_mut().unwrap() = result;
-
-                    self.ip += 2;
-
-                    // inline_primitive!(add_primitive, payload_size)
-                }
-                DenseInstruction {
-                    op_code: OpCode::SUB,
-                    payload_size,
-                    ..
-                } => {
-                    sub_handler_payload(self, payload_size as usize)?;
-                    // inline_primitive!(subtract_primitive, payload_size)
-                }
-                DenseInstruction {
-                    op_code: OpCode::MUL,
-                    payload_size,
-                    ..
-                } => {
-                    inline_primitive!(multiply_primitive, payload_size)
-                }
-                DenseInstruction {
-                    op_code: OpCode::DIV,
-                    payload_size,
-                    ..
-                } => inline_primitive!(divide_primitive, payload_size),
-
-                DenseInstruction {
-                    op_code: OpCode::EQUAL,
-                    payload_size,
-                    ..
-                } => {
-                    inline_primitive!(equality_primitive, payload_size);
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::LTE,
-                    payload_size,
-                    ..
-                } => {
-                    lte_handler_payload(self, payload_size as usize)?;
-                    // inline_primitive!(lte_primitive, payload_size);
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::VOID,
-                    ..
-                } => {
-                    self.thread.stack.push(SteelVal::Void);
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::SET,
-                    payload_size,
-                    ..
-                } => self.handle_set(payload_size as usize)?,
-                DenseInstruction {
-                    op_code: OpCode::PUSHCONST,
-                    payload_size,
-                    ..
-                } => {
-                    let val = self.constants.get(payload_size as usize);
-                    self.thread.stack.push(val);
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::PUSH,
-                    payload_size,
-                    ..
-                } => self.handle_push(payload_size as usize)?,
-                DenseInstruction {
-                    op_code: OpCode::READLOCAL,
-                    payload_size,
-                    ..
-                } => self.handle_local(payload_size as usize)?,
-                DenseInstruction {
-                    op_code: OpCode::READLOCAL0,
-                    ..
-                } => local_handler0(self)?,
-                DenseInstruction {
-                    op_code: OpCode::READLOCAL1,
-                    ..
-                } => local_handler1(self)?,
-                DenseInstruction {
-                    op_code: OpCode::READLOCAL2,
-                    ..
-                } => local_handler2(self)?,
-                DenseInstruction {
-                    op_code: OpCode::READLOCAL3,
-                    ..
-                } => local_handler3(self)?,
-                DenseInstruction {
-                    op_code: OpCode::READCAPTURED,
-                    payload_size,
-                    ..
-                } => self.handle_read_captures(payload_size as usize)?,
-                DenseInstruction {
-                    op_code: OpCode::MOVEREADLOCAL,
-                    payload_size,
-                    ..
-                } => self.handle_move_local(payload_size as usize)?,
-                // TODO: Introduce macro for this
-                DenseInstruction {
-                    op_code: OpCode::MOVEREADLOCAL0,
-                    ..
-                } => {
-                    let offset = self.get_offset();
-                    let value = self.move_from_stack(offset);
-
-                    self.thread.stack.push(value);
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::MOVEREADLOCAL1,
-                    ..
-                } => {
-                    let offset = self.get_offset();
-                    let value = self.move_from_stack(offset + 1);
-
-                    self.thread.stack.push(value);
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::MOVEREADLOCAL2,
-                    ..
-                } => {
-                    let offset = self.get_offset();
-                    let value = self.move_from_stack(offset + 2);
-
-                    self.thread.stack.push(value);
-                    self.ip += 1;
-                }
-
-                DenseInstruction {
-                    op_code: OpCode::MOVEREADLOCAL3,
-                    ..
-                } => {
-                    let offset = self.get_offset();
-                    let value = self.move_from_stack(offset + 3);
-
-                    self.thread.stack.push(value);
-                    self.ip += 1;
-                }
-
-                // DenseInstruction {
-                //     op_code: OpCode::MOVEREADLOCALCALLGLOBAL,
-                //     payload_size,
-                //     ..
-                // } => {
-                //     self.handle_move_local(payload_size as usize)?;
-
-                //     // Move to the next iteration of the loop
-                //     let next_inst = self.instructions[self.ip];
-                //     self.ip += 1;
-                //     let next_next_inst = self.instructions[self.ip];
-                //     self.handle_call_global(
-                //         next_inst.payload_size as usize,
-                //         next_next_inst.payload_size as usize,
-                //     )?;
-                // }
-                DenseInstruction {
-                    op_code: OpCode::SETLOCAL,
-                    payload_size,
-                    ..
-                } => self.handle_set_local(payload_size as usize),
-                DenseInstruction {
-                    op_code: OpCode::LOADINT0,
-                    ..
-                } => {
-                    self.thread.stack.push(SteelVal::INT_ZERO);
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::LOADINT1,
-                    ..
-                } => {
-                    self.thread.stack.push(SteelVal::INT_ONE);
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::LOADINT2,
-                    ..
-                } => {
-                    self.thread.stack.push(SteelVal::INT_TWO);
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::CGLOCALCONST,
-                    payload_size,
-                    ..
-                } => {
-                    let read_local = &self.instructions[self.ip + 1];
-                    let push_const = &self.instructions[self.ip + 2];
-
-                    // Snag the function
-                    let func = self
-                        .thread
-                        .global_env
-                        .repl_lookup_idx(payload_size as usize);
-
-                    // get the local
-                    // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-                    let offset = self.get_offset();
-                    let local_value =
-                        self.thread.stack[read_local.payload_size as usize + offset].clone();
-
-                    // get the const
-                    let const_val = self.constants.get(push_const.payload_size as usize);
-
-                    self.handle_lazy_function_call(func, local_value, const_val)?;
-                }
-                DenseInstruction {
-                    op_code: OpCode::CALLGLOBAL,
-                    payload_size,
-                    ..
-                } => {
-                    self.ip += 1;
-                    let next_inst = self.instructions[self.ip];
-                    self.handle_call_global(
-                        // next_inst.payload_size as usize,
-                        payload_size as usize,
-                        next_inst.payload_size as usize,
-                    )?;
-                }
-                DenseInstruction {
-                    op_code: OpCode::CALLGLOBALTAIL,
-                    payload_size,
-                    ..
-                } => {
-                    // println!("calling global tail");
-                    // crate::core::instructions::pretty_print_dense_instructions(&self.instructions);
-                    let next_inst = self.instructions[self.ip + 1];
-                    // dbg!(payload_size);
-                    // dbg!(next_inst.payload_size);
-                    // println!("Calling global tail");
-                    self.handle_tail_call_global(
-                        // next_inst.payload_size as usize,
-                        payload_size as usize,
-                        next_inst.payload_size as usize,
-                        // next_inst.payload_size as usize,
-                    )?;
-                }
-                DenseInstruction {
-                    op_code: OpCode::FUNC,
-                    payload_size,
-                    ..
-                } => {
-                    // TODO: @Matt -> don't pop the function off of the stack, just read it from there directly.
-                    let func = self.thread.stack.pop().unwrap();
-                    // println!("Calling: {}", func);
-                    // pretty_print_dense_instructions(&self.instructions);
-                    // println!("ip: {}", self.ip);
-                    self.handle_function_call(func, payload_size as usize)?;
-                }
-                // Tail call basically says "hey this function is exiting"
-                // In the closure case, transfer ownership of the stack to the called function
-                DenseInstruction {
-                    op_code: OpCode::TAILCALL,
-                    payload_size,
-                    ..
-                } => {
-                    let func = self.thread.stack.pop().unwrap();
-                    self.handle_tail_call(func, payload_size as usize)?
-                }
-                DenseInstruction {
-                    op_code: OpCode::IF,
-                    payload_size,
-                    ..
-                } => {
-                    // change to truthy...
-                    if self.thread.stack.pop().unwrap().is_truthy() {
-                        self.ip += 1;
-                    } else {
-                        self.ip = payload_size as usize;
-                    }
-                }
-                DenseInstruction {
-                    op_code: OpCode::TCOJMP,
-                    payload_size,
-                    ..
-                } => {
-                    let current_arity = payload_size as usize;
-                    // This is the number of (local) functions we need to pop to get back to the place we want to be at
-                    // let depth = self.instructions[self.ip + 1].payload_size as usize;
-
-                    // for _ in 0..depth {
-                    //     self.thread.stack_frames.pop();
-                    //     self.pop_count -= 1;
-                    // }
-
-                    let last_stack_frame = self.thread.stack_frames.last().unwrap();
-
-                    #[cfg(feature = "dynamic")]
-                    {
-                        last_stack_frame.function.increment_call_count();
-                    }
-
-                    self.instructions = last_stack_frame.function.body_exp();
-                    // self.spans = last_stack_frame.function.spans();
-                    self.sp = last_stack_frame.sp;
-
-                    // crate::core::instructions::pretty_print_dense_instructions(&self.instructions);
-
-                    // panic!("Stopping");
-
-                    self.ip = 0;
-
-                    let closure_arity = last_stack_frame.function.arity();
-
-                    if current_arity != closure_arity {
-                        stop!(ArityMismatch => format!("tco: function expected {closure_arity} arguments, found {current_arity}"); self.current_span());
-                    }
-
-                    // HACK COME BACK TO THIS
-                    // if self.ip == 0 && self.heap.len() > self.heap.limit() {
-                    // TODO collect here
-                    // self.heap.collect_garbage();
-                    // }
-                    // let offset = self.stack_index.last().copied().unwrap_or(0);
-                    let offset = last_stack_frame.sp;
-
-                    // We should have arity at this point, drop the stack up to this point
-                    // take the last arity off the stack, go back and replace those in order
-                    // [... arg1 arg2 arg3]
-                    //      ^^^ <- back = this index
-                    // offset = the start of the stack frame
-                    // Copy the arg1 arg2 arg3 values to
-                    // [... frame-start ... arg1 arg2 arg3]
-                    //      ^^^^^^~~~~~~~~
-                    let back = self.thread.stack.len() - current_arity;
-                    // for i in 0..current_arity {
-                    //     self.stack[offset + i] = self.stack[back + i].clone();
-                    // }
-
-                    // self.stack.truncate(offset + current_arity);
-
-                    let _ = self.thread.stack.drain(offset..back);
-
-                    // println!("stack after truncating: {:?}", self.stack);
-                }
-                DenseInstruction {
-                    op_code: OpCode::JMP,
-                    payload_size,
-                    ..
-                } => {
-                    self.ip = payload_size as usize;
-                }
-                DenseInstruction {
-                    op_code: OpCode::BEGINSCOPE,
-                    ..
-                } => {
-                    // todo!()
-                    self.ip += 1;
-                    // self.stack_index.push(self.stack.len());
-                }
-                DenseInstruction {
-                    op_code: OpCode::LetVar,
-                    ..
-                } => {
-                    // todo!()
-                    self.ip += 1;
-                    // self.stack_index.push(self.stack.len());
-                }
-                DenseInstruction {
-                    op_code: OpCode::SETALLOC,
-                    ..
-                } => set_alloc_handler(self)?,
-                DenseInstruction {
-                    op_code: OpCode::READALLOC,
-                    ..
-                } => read_alloc_handler(self)?,
-
-                DenseInstruction {
-                    op_code: OpCode::ALLOC,
-                    ..
-                } => alloc_handler(self)?,
-                // todo!("Implement patching in vars from the stack to the heap");
-                DenseInstruction {
-                    op_code: OpCode::LETENDSCOPE,
-                    ..
-                } => {
-                    let_end_scope_handler(self)?;
-                }
-                // DenseInstruction {
-                //     op_code: OpCode::POP,
-                //     payload_size,
-                //     ..
-                // } => {
-                //     if let Some(r) = self.handle_pop(payload_size) {
-                //         return r;
-                //     }
-                // }
-                DenseInstruction {
-                    op_code: OpCode::BIND,
-                    payload_size,
-                    ..
-                } => self.handle_bind(payload_size as usize),
-                // DenseInstruction {
-                //     op_code: OpCode::SCLOSURE,
-                //     payload_size,
-                //     ..
-                // } => self.handle_start_closure(payload_size as usize),
-                DenseInstruction {
-                    op_code: OpCode::NEWSCLOSURE,
-                    payload_size,
-                    ..
-                } => self.handle_new_start_closure(payload_size as usize)?,
-                DenseInstruction {
-                    op_code: OpCode::PUREFUNC,
-                    payload_size,
-                    ..
-                } => self.handle_pure_function(payload_size as usize),
-                DenseInstruction {
-                    op_code: OpCode::SDEF,
-                    ..
-                } => self.handle_start_def(),
-                DenseInstruction {
-                    op_code: OpCode::EDEF,
-                    ..
-                } => {
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::Arity,
-                    ..
-                } => {
-                    // println!("HITTING THIS - THIS SHOULDNT HAPPEN");
-                    self.ip += 1;
-                }
-                DenseInstruction {
-                    op_code: OpCode::PANIC,
-                    ..
-                } => self.handle_panic(self.current_span())?,
-                DenseInstruction {
-                    op_code: OpCode::PASS,
-                    ..
-                } => {
-                    // log::warn!("Hitting a pass - this shouldn't happen");
-                    self.ip += 1;
-                }
-
-                // match_dynamic_super_instructions!()
-                _ => {
-                    #[cfg(feature = "dynamic")]
-                    // TODO: Dispatch on the function here for super instructions!
-                    dynamic::vm_match_dynamic_super_instruction(self, instr)?;
-
-                    crate::core::instructions::pretty_print_dense_instructions(&self.instructions);
-                    panic!(
-                        "Unhandled opcode: {:?} @ {}",
-                        self.instructions[self.ip], self.ip
-                    );
-                }
-            }
-        }
-    }
-
-    fn move_from_stack(&mut self, offset: usize) -> SteelVal {
-        std::mem::replace(&mut self.thread.stack[offset], SteelVal::Void)
-    }
-
-    // #[inline(always)]
-    // TODO: This is definitely an issue - if the instruction stack is empty,
-    // We will probably end up grabbing a garbage span
-    fn current_span(&self) -> Span {
-        //// New way
-        // self.thread
-        //     .stack_frames
-        //     .last()
-        //     .and_then(|x| x.function.spans.get(self.ip))
-        //     .copied()
-        //     // .unwrap()
-        //     .unwrap_or_default()
-
-        // println!("Span vec: {:#?}", self.spans);
-
-        // self.spans.get(self.ip).copied().unwrap_or_default()
-
-        self.thread
-            .stack_frames
-            .last()
-            .map(|x| x.function.id)
-            .and_then(|x| {
-                self.thread
-                    .function_interner
-                    .spans
-                    .get(&x)
-                    .and_then(|x| x.get(self.ip))
-            })
-            .or_else(|| self.root_spans.get(self.ip))
-            .copied()
-            .unwrap_or_default()
-
-        // todo!()
-
-        // self.spans
-        //     .get(
-        //         self.instructions
-        //             .get(self.ip)
-        //             .map(|x| x.span_index)
-        //             .unwrap_or_default(),
-        //     )
-        //     // .flatten()
-        //     .copied()
-        //     .unwrap_or_default()
-
-        // Span::default()
-    }
-
-    fn enclosing_span(&self) -> Option<Span> {
-        if self.thread.stack_frames.len() > 1 {
-            let back_two = self.thread.stack_frames.len() - 2;
-
-            if let [second, last] = &self.thread.stack_frames[self.thread.stack_frames.len() - 2..]
-            {
-                // todo!();
-
-                let id = second.function.id;
-                let spans = self.thread.function_interner.spans.get(&second.function.id);
-
-                spans
-                    .and_then(|x| {
-                        if last.ip > 2 {
-                            x.get(last.ip - 2)
-                        } else {
-                            None
-                        }
-                    })
-                    .copied()
-            } else {
-                todo!()
-            }
-        } else {
-            self.thread
-                .stack_frames
-                .last()
-                .and_then(|frame| {
-                    if frame.ip > 2 {
-                        self.root_spans.get(frame.ip - 2)
-                    } else {
-                        None
-                    }
-                })
-                .copied()
-        }
-    }
-
-    fn close_continuation_marks(&self, last: &StackFrame) -> bool {
-        // TODO: @Matt - continuation marks should actually do something here
-        // What we'd like: This marks the stack frame going out of scope. Since it is going out of scope,
-        // the stack frame should check if there are marks here, specifying that we should grab
-        // the values out of the existing frame, and "close" the open continuation. That way the continuation (if called)
-        // does not need to actually copy the entire frame eagerly, but rather can do so lazily.
-
-        Continuation::close_marks(self, last)
-    }
-
-    #[inline(always)]
-    fn handle_pop_pure(&mut self) -> Option<Result<SteelVal>> {
-        // Check that the amount we're looking to pop and the function stack length are equivalent
-        // otherwise we have a problem
-
-        self.pop_count -= 1;
-
-        // unwrap just because we want to see if we have something here
-        // rolling back the function stack
-        // self.function_stack.pop();
-
-        let last = self.thread.stack_frames.pop();
-
-        // let should_return = self.stack_frames.is_empty();
-        let should_continue = self.pop_count != 0;
-
-        if should_continue {
-            // #[cfg(feature = "unsafe-internals")]
-            // let last = unsafe { last.unwrap_unchecked() };
-
-            // #[cfg(not(feature = "unsafe-internals"))]
-            let last = last.unwrap();
-
-            // Update the current frame to be the last one
-            //
-            // self.current_frame = last.clone();
-
-            // let ret_val = self.stack.pop().unwrap();
-
-            let rollback_index = last.sp;
-
-            // let ret_val = self.thread.stack.pop().unwrap();
-
-            // for _ in rollback_index..self.thread.stack.len() {
-            //     self.thread.stack.pop();
-            // }
-
-            // self.thread.stack.push(ret_val);
-
-            if self.close_continuation_marks(&last) {
-                // println!("Closed continuation mark");
-                // dbg!(&self.thread.stack);
-            }
-
-            // dbg!(self.thread.stack_frames.len());
-
-            // dbg!(rollback_index);
-            // dbg!(self.thread.stack.len());
-            // last.continuation_mark.map(|x| println!("{:p}", x.inner));
-
-            let _ = self
-                .thread
-                .stack
-                .drain(rollback_index..self.thread.stack.len() - 1);
-
-            // for value in values {
-            //     dbg!(value);
-            // }
-
-            // self.update_state_with_frame(last);
-            // self.close_continuation_marks(&last);
-
-            self.ip = last.ip;
-            self.instructions = last.instructions;
-
-            self.sp = self.get_last_stack_frame_sp();
-
-            // self.sp = last.index;
-
-            // self.sp = rollback_index;
-
-            None
-        } else {
-            let ret_val = self.thread.stack.pop().ok_or_else(|| {
-                SteelErr::new(ErrorKind::Generic, "stack empty at pop".to_string())
-                    .with_span(self.current_span())
-            });
-
-            last.as_ref().map(|x| {
-                if self.close_continuation_marks(x) {
-                    println!("%%%%%% closed frame %%%%%")
-                }
-            });
-
-            let rollback_index = last.map(|x| x.sp).unwrap_or(0);
-
-            // Move forward past the pop
-            self.ip += 1;
-
-            self.thread.stack.truncate(rollback_index);
-            self.sp = 0;
-
-            Some(ret_val)
-        }
-    }
-
-    #[inline(always)]
-    fn update_state_with_frame(&mut self, last: StackFrame) {
-        self.ip = last.ip;
-        self.instructions = last.instructions;
-        // self.spans = last.spans;
-    }
-
-    #[inline(always)]
-    fn get_last_stack_frame_sp(&self) -> usize {
-        self.thread.stack_frames.last().map(|x| x.sp).unwrap_or(0)
-    }
-
-    // #[inline(always)]
-    fn handle_panic(&mut self, span: Span) -> Result<()> {
-        let error_message = self.thread.stack.pop().unwrap();
-        stop!(Generic => error_message.to_string(); span);
-    }
-
-    // #[inline(always)]
-    fn handle_set(&mut self, index: usize) -> Result<()> {
-        let value_to_assign = self.thread.stack.pop().unwrap();
-
-        let value = self
-            .thread
-            .global_env
-            .repl_set_idx(index, value_to_assign)?;
-
-        self.thread.stack.push(value);
-        self.ip += 1;
-        Ok(())
-    }
-
-    #[inline(always)]
-    fn handle_call_global(&mut self, index: usize, payload_size: usize) -> Result<()> {
-        #[cfg(not(feature = "unsafe-internals"))]
-        {
-            let func = self.thread.global_env.repl_lookup_idx(index);
-            // TODO - handle this a bit more elegantly
-            // self.handle_function_call(func, payload_size, span)
-            self.handle_global_function_call(func, payload_size)
-        }
-        #[cfg(feature = "unsafe-internals")]
-        {
-            let func = self.thread.global_env.repl_lookup_idx(index);
-            // TODO - handle this a bit more elegantly
-            // self.handle_function_call(func, payload_size, span)
-            self.handle_global_function_call_by_reference(&func, payload_size)
-        }
-    }
-
-    #[inline(always)]
-    fn handle_tail_call_global(&mut self, index: usize, payload_size: usize) -> Result<()> {
-        let func = self.thread.global_env.repl_lookup_idx(index);
-        self.ip += 1;
-        self.handle_tail_call(func, payload_size)
-    }
-
-    #[inline(always)]
-    fn handle_push(&mut self, index: usize) -> Result<()> {
-        let value = self.thread.global_env.repl_lookup_idx(index);
-
-        self.thread.stack.push(value);
-        self.ip += 1;
-        Ok(())
-    }
-
-    #[inline(always)]
-    fn handle_local(&mut self, index: usize) -> Result<()> {
-        // println!("STACK HERE: {:?}", self.thread.stack);
-        // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-        let offset = self.get_offset();
-
-        // if index + offset >= self.thread.stack.len() {
-        // dbg!(&self.thread.stack.get(offset..));
-        //     // dbg!(&self.current_span());
-
-        //     pretty_print_dense_instructions(&self.instructions);
-        //     dbg!(self.ip);
-        // }
-
-        let value = self.thread.stack[index + offset].clone();
-
-        self.thread.stack.push(value);
-        self.ip += 1;
-        Ok(())
-    }
-
-    fn handle_read_captures(&mut self, index: usize) -> Result<()> {
-        let value = self.thread.stack_frames.last().unwrap().function.captures()[index].clone();
-
-        self.thread.stack.push(value);
-        self.ip += 1;
-        Ok(())
-    }
-
-    // #[inline(always)]
-    fn handle_move_local(&mut self, index: usize) -> Result<()> {
-        // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-        // let offset = self.stack_frames.last().unwrap().index;
-        let offset = self.get_offset();
-        let value = self.move_from_stack(index + offset);
-
-        self.thread.stack.push(value);
-        self.ip += 1;
-        Ok(())
-    }
-
-    fn handle_pure_function(&mut self, offset: usize) {
-        // println!("Hitting start closure");
-
-        // println!("Instruction: {:?}", self.instructions[self.ip]);
-
-        // if self.instructions[self.ip].payload_size == 1 {
-        //     println!("Found multi arity function");
-        // }
-
-        assert!(self.ip < self.instructions.len());
-
-        self.ip += 1;
-
-        let is_multi_arity = self.instructions[self.ip].payload_size == 1;
-
-        self.ip += 1;
-
-        // Check whether this is a let or a rooted function
-        let closure_id = self.instructions[self.ip].payload_size as usize;
-
-        // if is_multi_arity {
-        //     println!("Found multi arity function");
-        // }
-
-        self.ip += 1;
-
-        // TODO - used to be offset - 2, now 3 with the multi arity
-        let forward_jump = offset - 2;
-        // let forward_jump = offset;
-
-        // TODO clean this up a bit
-        // hold the spot for where we need to jump aftwards
-        let forward_index = self.ip + forward_jump;
-
-        let constructed_lambda = if let Some(prototype) = self
-            .thread
-            .function_interner
-            .pure_function_interner
-            .get(&closure_id)
-        {
-            prototype.clone()
-        } else {
-            // debug_assert!(self.instructions[forward_index - 1].op_code == OpCode::ECLOSURE);
-
-            // TODO -> this is probably quite slow
-            // If extraneous lets are lifted, we probably don't need this
-            // or if instructions get stored in some sort of shared memory so I'm not deep cloning the window
-
-            let forward_jump_index = self.ip + forward_jump - 1;
-
-            // Construct the closure body using the offsets from the payload
-            // used to be - 1, now - 2
-            let closure_body = self.instructions[self.ip..forward_jump_index].into();
-
-            let spans = if let Some(spans) = self
-                .thread
-                .stack_frames
-                .last()
-                .and_then(|x| self.thread.function_interner.spans.get(&x.function.id))
-            {
-                if forward_jump_index >= spans.len() {
-                    self.root_spans[self.ip..forward_jump_index].into()
-                } else {
-                    spans[self.ip..forward_jump_index].into()
-                }
-            } else {
-                self.root_spans[self.ip..forward_jump_index].into()
-            };
-
-            // if let Some(spans) = self.thread.function_interner.spans.get()
-
-            // let spans = self.spans[self.ip..forward_jump_index].into();
-
-            // snag the arity from the eclosure instruction
-            let arity = self.instructions[forward_index - 1].payload_size;
-
-            let constructed_lambda = Gc::new(ByteCodeLambda::new(
-                closure_id,
-                closure_body,
-                arity as usize,
-                is_multi_arity,
-                Vec::new(),
-                Vec::new(),
-                // Rc::clone(&spans),
-            ));
-
-            self.thread
-                .function_interner
-                .pure_function_interner
-                .insert(closure_id, Gc::clone(&constructed_lambda));
-
-            // Put the spans into the
-            self.thread
-                .function_interner
-                .spans
-                .insert(closure_id, spans);
-
-            constructed_lambda
-        };
-
-        self.thread
-            .stack
-            .push(SteelVal::Closure(constructed_lambda));
-
-        self.ip = forward_index;
-    }
-
-    fn handle_new_start_closure(&mut self, offset: usize) -> Result<()> {
-        // println!("Hitting start closure");
-
-        // println!("Instruction: {:?}", self.instructions[self.ip]);
-
-        // if self.instructions[self.ip].payload_size == 1 {
-        //     println!("Found multi arity function");
-        // }
-
-        assert!(self.ip < self.instructions.len());
-
-        self.ip += 1;
-
-        let is_multi_arity = self.instructions[self.ip].payload_size == 1;
-
-        self.ip += 1;
-
-        // Get the ID of the function
-        let closure_id = self.instructions[self.ip].payload_size as usize;
-
-        // if is_multi_arity {
-        //     println!("Found multi arity function");
-        // }
-
-        self.ip += 1;
-
-        // TODO - used to be offset - 2, now 3 with the multi arity
-        // let forward_jump = offset;
-        let forward_jump = offset - 3;
-        // println!("Forward jump: {}", forward_jump);
-
-        // Snag the number of upvalues here
-        let ndefs = self.instructions[self.ip].payload_size;
-        self.ip += 1;
-
-        // TODO preallocate size
-        let mut captures = Vec::with_capacity(ndefs as usize);
-
-        // TODO: This shouldn't be the same size as the captures
-        // let mut heap_vars = Vec::with_capacity(ndefs as usize);
-
-        let mut heap_vars = Vec::new();
-
-        // TODO clean this up a bit
-        // hold the spot for where we need to jump aftwards
-        let forward_index = self.ip + forward_jump;
-
-        // Insert metadata
-        // TODO: We probably can get a bit better than this.
-        // A lot of the captures are static, I'm not quite sure we necessarily need to patch down _every_ single one
-        // each time, especially since each lambda is a standalone instance of this.
-
-        // Top level %plain-let with closures will panic here:
-        // (%plain-let ((foo 10) (bar 20)) (lambda (+ foo bar)))
-        // So, this should probably do something like this:
-
-        if let Some(guard) = self.thread.stack_frames.last() {
-            let guard = self.thread.stack_frames.last().unwrap();
-            // let stack_index = self.stack_index.last().copied().unwrap_or(0);
-            // let stack_index = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-            let stack_index = self.get_offset();
-
-            for _ in 0..ndefs {
-                let instr = self.instructions[self.ip];
-                match (instr.op_code, instr.payload_size) {
-                    (OpCode::COPYCAPTURESTACK, n) => {
-                        let offset = stack_index;
-                        let value = self.thread.stack[n as usize + offset].clone();
-                        captures.push(value);
-                    }
-                    (OpCode::COPYCAPTURECLOSURE, n) => {
-                        debug_assert!(
-                            !self.thread.stack_frames.is_empty(),
-                            "Trying to capture from closure that doesn't exist",
-                        );
-
-                        debug_assert!((n as usize) < guard.function.captures().len());
-
-                        let value = guard.function.captures()[n as usize].clone();
-
-                        captures.push(value);
-                    }
-                    (l, _) => {
-                        panic!(
-                            "Something went wrong in closure construction!, found: {:?} @ {}",
-                            l, self.ip,
-                        );
-                    }
-                }
-                self.ip += 1;
-            }
-        } else {
-            // let stack_index = self.stack_index.last().copied().unwrap_or(0);
-            // let stack_index = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-            let stack_index = self.get_offset();
-
-            for _ in 0..ndefs {
-                let instr = self.instructions[self.ip];
-                match (instr.op_code, instr.payload_size) {
-                    (OpCode::COPYCAPTURESTACK, n) => {
-                        let offset = stack_index;
-                        let value = self.thread.stack[n as usize + offset].clone();
-                        captures.push(value);
-                    }
-                    // (OpCode::COPYCAPTURECLOSURE, n) => {
-                    //     debug_assert!(
-                    //         !self.thread.stack_frames.is_empty(),
-                    //         "Trying to capture from closure that doesn't exist",
-                    //     );
-
-                    //     debug_assert!((n as usize) < guard.function.captures().len());
-
-                    //     let value = guard.function.captures()[n as usize].clone();
-
-                    //     captures.push(value);
-                    // }
-                    (l, _) => {
-                        panic!(
-                            "Something went wrong in closure construction!, found: {:?} @ {}",
-                            l, self.ip,
-                        );
-                    }
-                }
-                self.ip += 1;
-            }
-        }
-
-        // TODO: Consider moving these captures into the interned closure directly
-        // Its possible we're just doing a lot of extra capturing that way if we repeatedly copy things
-        let constructed_lambda = if let Some(prototype) = self
-            .thread
-            .function_interner
-            .closure_interner
-            .get(&closure_id)
-        {
-            // log::trace!("Fetching closure from cache");
-
-            let mut prototype = prototype.clone();
-            prototype.set_captures(captures);
-            prototype.set_heap_allocated(heap_vars);
-            prototype
-        } else {
-            // log::trace!("Constructing closure for the first time");
-
-            debug_assert!(self.instructions[forward_index - 1].op_code == OpCode::ECLOSURE);
-
-            // debug_assert!(self.ip + forward_jump - 1 <= self.instructions.len())
-
-            if forward_index - 1 > self.instructions.len() {
-                crate::core::instructions::pretty_print_dense_instructions(
-                    self.instructions.as_ref(),
-                );
-                println!("Forward index: {}", self.ip + forward_jump - 1);
-                println!("Length: {}", self.instructions.len());
-                panic!("Out of bounds forward jump");
-            }
-
-            let forward_jump_index = forward_index - 1;
-
-            // Construct the closure body using the offsets from the payload
-            // used to be - 1, now - 2
-            let closure_body = self.instructions[self.ip..forward_jump_index].into();
-            // let spans = self.spans[self.ip..forward_jump_index].into();
-
-            let spans = if let Some(spans) = self
-                .thread
-                .stack_frames
-                .last()
-                .and_then(|x| self.thread.function_interner.spans.get(&x.function.id))
-            {
-                if forward_jump_index >= spans.len() {
-                    self.root_spans[self.ip..forward_jump_index].into()
-                } else {
-                    spans[self.ip..forward_jump_index].into()
-                }
-            } else {
-                self.root_spans[self.ip..forward_jump_index].into()
-            };
-
-            // snag the arity from the eclosure instruction
-            let arity = self.instructions[forward_jump_index].payload_size;
-
-            let mut constructed_lambda = ByteCodeLambda::new(
-                closure_id,
-                closure_body,
-                arity as usize,
-                is_multi_arity,
-                Vec::new(),
-                Vec::new(),
-            );
-
-            self.thread
-                .function_interner
-                .closure_interner
-                .insert(closure_id, constructed_lambda.clone());
-
-            // Put the spans into the interner
-            self.thread
-                .function_interner
-                .spans
-                .insert(closure_id, spans);
-
-            constructed_lambda.set_captures(captures);
-            constructed_lambda.set_heap_allocated(heap_vars);
-
-            constructed_lambda
-        };
-
-        self.thread
-            .stack
-            .push(SteelVal::Closure(Gc::new(constructed_lambda)));
-
-        self.ip = forward_index;
-        Ok(())
-    }
-
-    // Enter a new thread, passing values that can be serialized
-    // Resolve all references, attempt to instantiate a new engine on the other side?
-    fn new_thread(&mut self, function: Gc<ByteCodeLambda>) {
-        todo!()
-
-        // Analyze the dependencies of the function, and see if its safe to be spawned on another thread
-    }
-
-    // #[inline(always)]
-    fn handle_bind(&mut self, payload_size: usize) {
-        self.thread
-            .global_env
-            .repl_define_idx(payload_size, self.thread.stack.pop().unwrap());
-
-        self.ip += 1;
-    }
-
-    // #[inline(always)]
-    fn handle_set_local(&mut self, index: usize) {
-        let value_to_set = self.thread.stack.pop().unwrap();
-        let offset = self.get_offset();
-        // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-
-        let old_index = index + offset;
-
-        assert!(old_index < self.thread.stack.len());
-
-        let old_value = self.thread.stack[old_index].clone();
-
-        // Modify the stack and change the value to the new one
-        self.thread.stack[old_index] = value_to_set;
-
-        self.thread.stack.push(old_value);
-        self.ip += 1;
-    }
-
-    // Calls the given function in tail position.
-    fn new_handle_tail_call_closure(
-        &mut self,
-        closure: Gc<ByteCodeLambda>,
-        payload_size: usize,
-    ) -> Result<()> {
-        self.cut_sequence();
-
-        let mut new_arity = payload_size;
-
-        self.adjust_stack_for_multi_arity(&closure, payload_size, &mut new_arity)?;
-
-        // TODO: Try to figure out if we need to close this frame
-        // self.close_continuation_marks(self.thread.stack_frames.last().unwrap());
-
-        let last = self.thread.stack_frames.last_mut().unwrap();
-
-        let offset = last.sp;
-
-        // We should have arity at this point, drop the stack up to this point
-        // take the last arity off the stack, go back and replace those in order
-        let back = self.thread.stack.len() - new_arity;
-        let _ = self.thread.stack.drain(offset..back);
-
-        // TODO: Perhaps add call to minor collection here?
-        // Could be a good way to avoid running the whole mark and sweep,
-        // since values will have left the scope by now.
-
-        self.instructions = closure.body_exp();
-
-        last.set_function(closure);
-
-        self.ip = 0;
-        Ok(())
-    }
-
-    #[inline(always)]
-    fn adjust_stack_for_multi_arity(
-        &mut self,
-        closure: &Gc<ByteCodeLambda>,
-        payload_size: usize,
-        new_arity: &mut usize,
-    ) -> Result<()> {
-        if likely(!closure.is_multi_arity) {
-            if unlikely(closure.arity() != payload_size) {
-                stop!(ArityMismatch => format!("function expected {} arguments, found {}", closure.arity(), payload_size); self.current_span());
-            }
-        } else {
-            // println!(
-            //     "multi closure function, multi arity, arity: {:?}",
-            //     closure.arity()
-            // );
-
-            if payload_size < closure.arity() - 1 {
-                stop!(ArityMismatch => format!("function expected at least {} arguments, found {}", closure.arity(), payload_size); self.current_span());
-            }
-
-            // (define (test x . y))
-            // (test 1 2 3 4 5)
-            // in this case, arity = 2 and payload size = 5
-            // pop off the last 4, collect into a list
-            let amount_to_remove = 1 + payload_size - closure.arity();
-
-            let values = self
-                .thread
-                .stack
-                .split_off(self.thread.stack.len() - amount_to_remove);
-
-            let list = SteelVal::ListV(List::from(values));
-
-            self.thread.stack.push(list);
-
-            *new_arity = closure.arity();
-
-            // println!("Stack after list conversion: {:?}", self.stack);
-        }
-
-        // else if closure.arity() != payload_size {
-        //     stop!(ArityMismatch => format!("function expected {} arguments, found {}", closure.arity(), payload_size); self.current_span());
-        // }
-
-        Ok(())
-    }
-
-    #[inline(always)]
-    fn cut_sequence(&mut self) {
-        #[cfg(feature = "dynamic")]
-        if let Some(pat) = self.thread.profiler.cut_sequence(
-            &self.instructions,
-            self.thread.stack_frames.last().map(|x| x.function.as_ref()),
-        ) {
-            log::debug!(target: "super-instructions", "Found a hot pattern, creating super instruction...");
-            log::debug!(target: "super-instructions", "{:#?}", pat);
-
-            if USE_SUPER_INSTRUCTIONS {
-                // Index of the starting opcode
-                let start = pat.pattern.start;
-
-                let id = self.thread.super_instructions.len();
-
-                let guard = self.thread.stack_frames.last_mut().unwrap();
-
-                // We don't want to repeatedly thrash by calculating hashes for the block pattern, so
-                // we mark the tail of the block directly on the function itself.
-                // guard.function.mark_block_tail(self.ip);
-
-                // Next run should get the new sequence of opcodes
-                let (head, _) = guard.function.update_to_super_instruction(start, id);
-
-                let block = DynamicBlock::construct_basic_block(head, pat);
-                self.thread.super_instructions.push(Rc::new(block));
-            }
-        }
-    }
-
-    #[inline(always)]
-    fn handle_tail_call(&mut self, stack_func: SteelVal, payload_size: usize) -> Result<()> {
-        use SteelVal::*;
-        match stack_func {
-            BoxedFunction(f) => self.call_boxed_func(f.func(), payload_size),
-            FuncV(f) => self.call_primitive_func(f, payload_size),
-            MutFunc(f) => self.call_primitive_mut_func(f, payload_size),
-            // ContractedFunction(cf) => self.call_contracted_function_tail_call(&cf, payload_size),
-            ContinuationFunction(cc) => self.call_continuation(cc),
-            Closure(closure) => self.new_handle_tail_call_closure(closure, payload_size),
-            BuiltIn(f) => self.call_builtin_func(f, payload_size),
-            CustomStruct(s) => self.call_custom_struct(&s, payload_size),
-            _ => {
-                // println!("{:?}", self.stack);
-                // println!("{:?}", self.stack_index);
-                crate::core::instructions::pretty_print_dense_instructions(&self.instructions);
-                stop!(BadSyntax => format!("TailCall - Application not a procedure or function type not supported: {stack_func}"); self.current_span());
-            }
-        }
-    }
-
-    // #[inline(always)]
-    fn call_boxed_func(
-        &mut self,
-        func: &dyn Fn(&[SteelVal]) -> Result<SteelVal>,
-        payload_size: usize,
-    ) -> Result<()> {
-        // println!("{:?}, {:?}", self.thread.stack, payload_size);
-
-        let last_index = self.thread.stack.len() - payload_size;
-
-        let result = func(&self.thread.stack[last_index..])
-            .map_err(|x| x.set_span_if_none(self.current_span()))?;
-
-        self.thread.stack.truncate(last_index);
-
-        self.thread.stack.push(result);
-        self.ip += 1;
-        Ok(())
-    }
-
-    // NOTE: Here, the last element on the stack _is_ the function we're referring to. In this case, just avoid
-    // touching the last element and move on.
-    fn call_boxed_func_on_stack(
-        &mut self,
-        func: Rc<dyn Fn(&[SteelVal]) -> Result<SteelVal>>,
-        payload_size: usize,
-    ) -> Result<()> {
-        // stack is [args ... function]
-        let len = self.thread.stack.len();
-        // This is the start of the arguments
-        let last_index = len - payload_size - 1;
-
-        // Peek the range for the [args ... function]
-        //                        ~~~~~~~~~~
-        // let result = func(self.stack.peek_range_double(last_index..len))
-        //     .map_err(|x| x.set_span_if_none(self.current_span()))?;
-
-        let result = match func(&self.thread.stack[last_index..len]) {
-            Ok(value) => value,
-            Err(e) => return Err(e.set_span_if_none(self.current_span())),
-        };
-
-        // This is the old way, but now given that the function is included on the stack, this should work...
-        // self.stack.truncate(last_index);
-        // self.stack.push(result);
-
-        self.thread.stack.truncate(last_index + 1);
-        *self.thread.stack.last_mut().unwrap() = result;
-
-        self.ip += 1;
-        Ok(())
-    }
-
-    // #[inline(always)]
-    fn call_primitive_func_on_stack(
-        &mut self,
-        func: fn(&[SteelVal]) -> Result<SteelVal>,
-        payload_size: usize,
-    ) -> Result<()> {
-        // stack is [args ... function]
-        let len = self.thread.stack.len();
-        // This is the start of the arguments
-        let last_index = len - payload_size - 1;
-
-        // Peek the range for the [args ... function]
-        //                        ~~~~~~~~~~
-        // let result = func(self.stack.peek_range_double(last_index..len))
-        //     .map_err(|x| x.set_span_if_none(self.current_span()))?;
-
-        let result = match func(&self.thread.stack[last_index..len]) {
-            Ok(value) => value,
-            Err(e) => return Err(e.set_span_if_none(self.current_span())),
-        };
-
-        // This is the old way, but now given that the function is included on the stack, this should work...
-        // self.stack.truncate(last_index);
-        // self.stack.push(result);
-
-        self.thread.stack.truncate(last_index + 1);
-        *self.thread.stack.last_mut().unwrap() = result;
-
-        self.ip += 1;
-        Ok(())
-    }
-
-    // #[inline(always)]
-    fn call_builtin_func(&mut self, func: BuiltInSignature, payload_size: usize) -> Result<()> {
-        // println!("Calling builtin function");
-
-        // Note: We Advance the pointer here. In the event we're calling a builtin that fusses with
-        // the instruction pointer, we allow the function to override this. For example, call/cc will
-        // advance the pointer - or perhaps, even fuss with the control flow.
-        self.ip += 1;
-
-        // TODO: Don't do this - just read directly from the stack
-        let args = self
-            .thread
-            .stack
-            .split_off(self.thread.stack.len() - payload_size);
-
-        let result = func(self, &args).map(|x| {
-            x.map_err(|x| {
-                // TODO: @Matt 4/24/2022 -> combine this into one function probably
-                if x.has_span() {
-                    x
-                } else {
-                    x.set_span_if_none(self.current_span())
-                }
-                // x.set_span_if_none(self.current_span())
-            })
-        });
-
-        if let Some(result) = result {
-            self.thread.stack.push(result?);
-        }
-
-        Ok(())
-        // self.stack.push(result);
-        // Ok(())
-    }
-
-    // #[inline(always)]
-    fn call_primitive_mut_func(
-        &mut self,
-        f: fn(&mut [SteelVal]) -> Result<SteelVal>,
-        payload_size: usize,
-    ) -> Result<()> {
-        // println!("Stack: {:?}", self.stack);
-
-        let last_index = self.thread.stack.len() - payload_size;
-
-        let result = f(&mut self.thread.stack[last_index..])
-            .map_err(|x| x.set_span_if_none(self.current_span()))?;
-
-        // TODO -> this can actually just be something like:
-        // self.stack.truncate(self.stack.len() - payload_size + 1)
-        // self.stack[self.stack.len() - 1] = result
-        self.thread.stack.truncate(last_index);
-        self.thread.stack.push(result);
-
-        self.ip += 1;
-        Ok(())
-    }
-
-    // TODO: Clean up function calls and create a nice calling convention API?
-    fn call_custom_struct(&mut self, s: &UserDefinedStruct, payload_size: usize) -> Result<()> {
-        if let Some(procedure) = s.maybe_proc() {
-            if let SteelVal::HeapAllocated(h) = procedure {
-                self.handle_global_function_call(h.get(), payload_size)
-            } else {
-                self.handle_global_function_call(procedure.clone(), payload_size)
-            }
-        } else {
-            stop!(Generic => "Attempted to call struct as a function - no procedure found!");
-        }
-    }
-
-    // #[inline(always)]
-    fn call_primitive_func(
-        &mut self,
-        f: fn(&[SteelVal]) -> Result<SteelVal>,
-        payload_size: usize,
-    ) -> Result<()> {
-        let last_index = self.thread.stack.len() - payload_size;
-
-        let result = match f(&self.thread.stack[last_index..]) {
-            Ok(value) => value,
-            Err(e) => return Err(e.set_span_if_none(self.current_span())),
-        };
-
-        // This is the old way... lets see if the below way improves the speed
-        self.thread.stack.truncate(last_index);
-        self.thread.stack.push(result);
-
-        self.ip += 1;
-        Ok(())
-    }
-
-    // #[inline(always)]
-    // fn call_contracted_function(
-    //     &mut self,
-    //     cf: &ContractedFunction,
-    //     payload_size: usize,
-    // ) -> Result<()> {
-    //     if let Some(arity) = cf.arity() {
-    //         if arity != payload_size {
-    //             stop!(ArityMismatch => format!("function expected {arity} arguments, found {payload_size}"); self.current_span());
-    //         }
-    //     }
-
-    //     // if A::enforce_contracts() {
-    //     let args = self
-    //         .thread
-    //         .stack
-    //         .split_off(self.thread.stack.len() - payload_size);
-
-    //     let result = cf.apply(args, &self.current_span(), self)?;
-
-    //     self.thread.stack.push(result);
-    //     self.ip += 1;
-    //     Ok(())
-    //     // } else {
-    //     //     self.handle_function_call(cf.function.clone(), payload_size)
-    //     // }
-    // }
-
-    // // #[inline(always)]
-    // fn call_contracted_function_tail_call(
-    //     &mut self,
-    //     cf: &ContractedFunction,
-    //     payload_size: usize,
-    // ) -> Result<()> {
-    //     if let Some(arity) = cf.arity() {
-    //         if arity != payload_size {
-    //             stop!(ArityMismatch => format!("function expected {arity} arguments, found {payload_size}"); self.current_span());
-    //         }
-    //     }
-
-    //     // if A::enforce_contracts() {
-    //     let args = self
-    //         .thread
-    //         .stack
-    //         .split_off(self.thread.stack.len() - payload_size);
-
-    //     let result = cf.apply(args, &self.current_span(), self)?;
-
-    //     self.thread.stack.push(result);
-    //     self.ip += 1;
-    //     Ok(())
-    //     // } else {
-    //     // self.handle_tail_call(cf.function.clone(), payload_size)
-    //     // }
-    // }
-
-    fn call_future_func_on_stack(
-        &mut self,
-        func: Rc<dyn Fn(&[SteelVal]) -> Result<FutureResult>>,
-        payload_size: usize,
-    ) -> Result<()> {
-        // stack is [args ... function]
-        let len = self.thread.stack.len();
-        // This is the start of the arguments
-        let last_index = len - payload_size - 1;
-
-        // Peek the range for the [args ... function]
-        //                        ~~~~~~~~~~
-        // let result = func(self.stack.peek_range_double(last_index..len))
-        //     .map_err(|x| x.set_span_if_none(self.current_span()))?;
-
-        let result = match func(&self.thread.stack[last_index..len]) {
-            Ok(value) => value,
-            Err(e) => return Err(e.set_span_if_none(self.current_span())),
-        };
-
-        // This is the old way, but now given that the function is included on the stack, this should work...
-        // self.stack.truncate(last_index);
-        // self.stack.push(result);
-
-        self.thread.stack.truncate(last_index + 1);
-        *self.thread.stack.last_mut().unwrap() = SteelVal::FutureV(Gc::new(result));
-
-        self.ip += 1;
-        Ok(())
-    }
-
-    // #[inline(always)]
-    fn call_future_func(
-        &mut self,
-        f: Box<Rc<dyn Fn(&[SteelVal]) -> Result<FutureResult>>>,
-        payload_size: usize,
-    ) -> Result<()> {
-        let last_index = self.thread.stack.len() - payload_size;
-
-        let result = SteelVal::FutureV(Gc::new(f(&self.thread.stack[last_index..])?));
-
-        self.thread.stack.truncate(last_index);
-        self.thread.stack.push(result);
-        self.ip += 1;
-        Ok(())
-    }
-
-    // #[inline(always)]
-    // TODO: See if calling continuations can be implemented in terms of the core ABI
-    // That way, we dont need a special "continuation" function
-    fn call_continuation(&mut self, continuation: Continuation) -> Result<()> {
-        let last =
-            self.thread.stack.pop().ok_or_else(
-                throw!(ArityMismatch => "continuation expected 1 argument, found none"),
-            )?;
-
-        // println!("Calling continuation...");
-
-        Continuation::set_state_from_continuation(self, continuation);
-
-        // match Gc::try_unwrap(continuation) {
-        //     Ok(cont) => {
-        //         self.set_state_from_continuation(cont);
-        //     }
-
-        //     Err(unable_to_unwrap) => {
-        //         self.set_state_from_continuation(unable_to_unwrap.unwrap());
-        //     }
-        // }
-
-        // self.set_state_from_continuation(continuation.clone());
-
-        self.ip += 1;
-
-        self.thread.stack.push(last);
-        Ok(())
-    }
-
-    // #[inline(always)]
-    fn handle_lazy_closure(
-        &mut self,
-        closure: &Gc<ByteCodeLambda>,
-        local: SteelVal,
-        const_value: SteelVal,
-    ) -> Result<()> {
-        self.cut_sequence();
-
-        let prev_length = self.thread.stack.len();
-
-        // push them onto the stack if we need to
-        self.thread.stack.push(local);
-        self.thread.stack.push(const_value);
-
-        // Push new stack frame
-        self.thread.stack_frames.push(
-            StackFrame::new(
-                prev_length,
-                Gc::clone(closure),
-                self.ip + 4,
-                Rc::clone(&self.instructions),
-                // Rc::clone(&self.spans),
-            ), // .with_span(self.current_span()),
-        );
-
-        // self.current_frame.sp = prev_length;
-
-        // self.current_frame.ip += 4;
-
-        // // Set the sp to be the current values on this
-        // let mut current_frame = StackFrame::new(
-        //     prev_length,
-        //     Gc::clone(closure),
-        //     self.ip + 4,
-        //     Rc::clone(&self.instructions),
-        // )
-        // .with_span(self.current_span());
-
-        // std::mem::swap(&mut current_frame, &mut self.current_frame);
-        // self.stack_frames.push(current_frame);
-
-        self.sp = prev_length;
-
-        // Push on the function stack so we have access to it later
-        // self.function_stack
-        //     .push(CallContext::new(Gc::clone(closure)).with_span(self.current_span()));
-
-        if closure.is_multi_arity {
-            panic!("Calling lazy closure with multi arity");
-        }
-
-        if closure.arity() != 2 {
-            stop!(ArityMismatch => format!("function expected {} arguments, found {}", closure.arity(), 2); self.current_span());
-        }
-
-        // self.current_arity = Some(closure.arity());
-
-        self.check_stack_overflow()?;
-        self.pop_count += 1;
-
-        self.instructions = closure.body_exp();
-        // self.spans = closure.spans();
-        self.ip = 0;
-        Ok(())
-    }
-
-    #[inline(always)]
-    fn check_stack_overflow(&self) -> Result<()> {
-        if CHECK_STACK_OVERFLOW {
-            if unlikely(self.thread.stack_frames.len() >= STACK_LIMIT) {
-                crate::core::instructions::pretty_print_dense_instructions(&self.instructions);
-                println!("stack frame at exit: {:?}", self.thread.stack);
-                stop!(Generic => "stack overflowed!"; self.current_span());
-            }
-        }
-
-        Ok(())
-    }
-
-    #[inline(always)]
-    fn get_offset(&self) -> usize {
-        self.sp
-        // self.stack_frames.last().map(|x| x.index).unwrap_or(0)
-    }
-
-    // #[inline(always)]
-    fn handle_lazy_function_call(
-        &mut self,
-        stack_func: SteelVal,
-        local: SteelVal,
-        const_value: SteelVal,
-    ) -> Result<()> {
-        use SteelVal::*;
-
-        match &stack_func {
-            BoxedFunction(f) => {
-                self.thread.stack.push(
-                    f.func()(&[local, const_value])
-                        .map_err(|x| x.set_span_if_none(self.current_span()))?,
-                );
-                self.ip += 4;
-            }
-            FuncV(f) => {
-                // self.stack
-                //     .push(f(&[local, const_value]).map_err(|x| x.set_span_if_none(self.current_span()))?);
-                // self.ip += 4;
-
-                match f(&[local, const_value]) {
-                    Ok(value) => self.thread.stack.push(value),
-                    Err(e) => return Err(e.set_span_if_none(self.current_span())),
-                }
-
-                // self.stack
-                // .push(f(&[local, const_value]).map_err(|x| x.set_span_if_none(self.current_span()))?);
-                self.ip += 4;
-            }
-            FutureFunc(f) => {
-                let result = SteelVal::FutureV(Gc::new(
-                    f(&[local, const_value])
-                        .map_err(|x| x.set_span_if_none(self.current_span()))?,
-                ));
-
-                self.thread.stack.push(result);
-                self.ip += 4;
-            }
-            // ContractedFunction(cf) => {
-            //     if let Some(arity) = cf.arity() {
-            //         if arity != 2 {
-            //             stop!(ArityMismatch => format!("function expected {} arguments, found {}", arity, 2); self.current_span());
-            //         }
-            //     }
-
-            //     // if A::enforce_contracts() {
-            //     let result = cf.apply(vec![local, const_value], &self.current_span(), self)?;
-
-            //     self.thread.stack.push(result);
-            //     self.ip += 4;
-            //     // } else {
-            //     // self.handle_lazy_function_call(cf.function.clone(), local, const_value)?;
-            //     // }
-            // }
-            // Contract(c) => self.call_contract(c, payload_size, span)?,
-            ContinuationFunction(_cc) => {
-                unimplemented!("calling continuation lazily not yet handled");
-            }
-            Closure(closure) => self.handle_lazy_closure(closure, local, const_value)?,
-            MutFunc(func) => {
-                let mut args = [local, const_value];
-                self.thread
-                    .stack
-                    .push(func(&mut args).map_err(|x| x.set_span_if_none(self.current_span()))?);
-
-                self.ip += 4;
-            }
-            CustomStruct(s) => {
-                if let Some(proc) = s.maybe_proc() {
-                    return self.handle_lazy_function_call(proc.clone(), local, const_value);
-                } else {
-                    stop!(Generic => "attempted to call struct as function, but the struct does not have a function to call!")
-                }
-            }
-            // BuiltIn(func) => {
-            //     let args = [local, const_value];
-            //     let result =
-            //         func(self, &args).map_err(|x| x.set_span_if_none(self.current_span()))?;
-            //     self.stack.push(result);
-            //     self.ip += 4;
-            // }
-            _ => {
-                log::error!("{stack_func:?}");
-                stop!(BadSyntax => format!("Function application not a procedure or function type not supported, {stack_func}"); self.current_span());
-            }
-        }
-        Ok(())
-    }
-
-    // // #[inline(always)]
-    fn handle_function_call_closure(
-        &mut self,
-        closure: Gc<ByteCodeLambda>,
-        payload_size: usize,
-    ) -> Result<()> {
-        self.cut_sequence();
-
-        // crate::core::instructions::pretty_print_dense_instructions(&self.instructions);
-
-        // println!("Handling function call for multi arity function");
-
-        // Jit profiling
-
-        #[cfg(feature = "jit")]
-        {
-            closure.increment_call_count();
-        }
-
-        self.adjust_stack_for_multi_arity(&closure, payload_size, &mut 0)?;
-
-        self.sp = self.thread.stack.len() - closure.arity();
-
-        // {
-        //     // Current frame already has the instructions
-        //     self.current_frame.ip += 1;
-        //     self.current_frame = self.stack.len() - closure.arity();
-
-        //     self.stack_frames.push(self.current_frame);
-
-        //     let instructions = closure.body_exp();
-
-        //     self.current_frame = StackFrame::new(self.sp, closure, 0, instructions)
-        // }
-
-        let instructions = closure.body_exp();
-        // let spans = closure.spans();
-
-        self.thread.stack_frames.push(
-            StackFrame::new(
-                self.sp,
-                closure,
-                self.ip + 1,
-                Rc::clone(&self.instructions),
-                // Rc::clone(&self.spans),
-            ), // .with_span(self.current_span()),
-        );
-
-        // self.current_arity = Some(closure.arity());
-
-        self.check_stack_overflow()?;
-
-        // self.stack_index.push(self.stack.len() - closure.arity());
-
-        // TODO use new heap
-        // self.heap
-        //     .gather_mark_and_sweep_2(&self.global_env, &inner_env);
-        // self.heap.collect_garbage();
-
-        // self.instruction_stack.push(InstructionPointer::new(
-        //     self.ip + 1,
-        //     Rc::clone(&self.instructions),
-        // ));
-        self.pop_count += 1;
-
-        // Move args into the stack, push stack onto stacks
-        // let stack = std::mem::replace(&mut self.stack, args.into());
-        // self.stacks.push(stack);
-
-        self.instructions = instructions;
-        // self.spans = spans;
-
-        self.ip = 0;
-        Ok(())
-    }
-
-    // #[cfg(feature = "jit")]
-    // // #[inline(always)]
-    // fn call_compiled_function(
-    //     &mut self,
-    //     function: &JitFunctionPointer,
-    //     payload_size: usize,
-    // ) -> Result<()> {
-    //     if function.arity() != payload_size {
-    //         stop!(ArityMismatch => format!("function expected {} arguments, found {}", function.arity(), payload_size); self.current_span());
-    //     }
-
-    //     let result = function.call_func(&mut self.thread.stack);
-
-    //     // println!("Calling function!");
-
-    //     self.thread.stack.push(result);
-    //     self.ip += 1;
-
-    //     Ok(())
-    // }
-
-    // TODO improve this a bit
-    #[inline(always)]
-    fn handle_function_call_closure_jit_without_profiling(
-        &mut self,
-        mut closure: Gc<ByteCodeLambda>,
-        payload_size: usize,
-    ) -> Result<()> {
-        self.adjust_stack_for_multi_arity(&closure, payload_size, &mut 0)?;
-
-        self.sp = self.thread.stack.len() - closure.arity();
-
-        let mut instructions = closure.body_exp();
-        // let mut spans = closure.spans();
-
-        std::mem::swap(&mut instructions, &mut self.instructions);
-        // std::mem::swap(&mut spans, &mut self.spans);
-
-        // Do this _after_ the multi arity business
-        // TODO: can these rcs be avoided
-        self.thread.stack_frames.push(
-            StackFrame::new(self.sp, closure, self.ip + 1, instructions), // .with_span(self.current_span()),
-        );
-
-        // self.current_arity = Some(closure.arity());
-
-        self.check_stack_overflow()?;
-
-        // closure arity here is the number of true arguments
-        // self.stack_index.push(self.stack.len() - closure.arity());
-
-        // TODO use new heap
-        // self.heap
-        //     .gather_mark_and_sweep_2(&self.global_env, &inner_env);
-        // self.heap.collect_garbage();
-
-        self.pop_count += 1;
-
-        // self.instructions = instructions;
-        // self.spans = spans;
-        self.ip = 0;
-        Ok(())
-    }
-
-    #[inline(always)]
-    fn handle_function_call_closure_jit_without_profiling_ref(
-        &mut self,
-        mut closure: &Gc<ByteCodeLambda>,
-        payload_size: usize,
-    ) -> Result<()> {
-        self.adjust_stack_for_multi_arity(closure, payload_size, &mut 0)?;
-
-        self.sp = self.thread.stack.len() - closure.arity();
-
-        let mut instructions = closure.body_exp();
-        // let mut spans = closure.spans();
-
-        std::mem::swap(&mut instructions, &mut self.instructions);
-        // std::mem::swap(&mut spans, &mut self.spans);
-
-        // Do this _after_ the multi arity business
-        // TODO: can these rcs be avoided
-        self.thread.stack_frames.push(
-            StackFrame::new_rooted(
-                self.sp,
-                // Almost assuredly UB - there really just needs to be a runtime reference
-                // on the value that gets passed around, or we just need to
-                #[cfg(feature = "unsafe-internals")]
-                crate::gc::unsafe_roots::MaybeRooted::from_root(closure),
-                #[cfg(not(feature = "unsafe-internals"))]
-                closure.clone(),
-                self.ip + 1,
-                instructions,
-            ), // .with_span(self.current_span()),
-        );
-
-        // self.current_arity = Some(closure.arity());
-
-        self.check_stack_overflow()?;
-
-        // closure arity here is the number of true arguments
-        // self.stack_index.push(self.stack.len() - closure.arity());
-
-        // TODO use new heap
-        // self.heap
-        //     .gather_mark_and_sweep_2(&self.global_env, &inner_env);
-        // self.heap.collect_garbage();
-
-        self.pop_count += 1;
-
-        // self.instructions = instructions;
-        // self.spans = spans;
-        self.ip = 0;
-        Ok(())
-    }
-
-    // TODO improve this a bit
-    // #[inline(always)]
-    #[inline(always)]
-    fn handle_function_call_closure_jit(
-        &mut self,
-        closure: Gc<ByteCodeLambda>,
-        payload_size: usize,
-    ) -> Result<()> {
-        // Record the end of the existing sequence
-        self.cut_sequence();
-
-        // Jit profiling -> Make sure that we really only trace once we pass a certain threshold
-        // For instance, if this function
-        #[cfg(feature = "dynamic")]
-        {
-            closure.increment_call_count();
-        }
-
-        self.handle_function_call_closure_jit_without_profiling(closure, payload_size)
-    }
-
-    #[inline(always)]
-    fn handle_function_call_closure_jit_ref(
-        &mut self,
-        closure: &Gc<ByteCodeLambda>,
-        payload_size: usize,
-    ) -> Result<()> {
-        // Record the end of the existing sequence
-        self.cut_sequence();
-
-        // Jit profiling -> Make sure that we really only trace once we pass a certain threshold
-        // For instance, if this function
-        #[cfg(feature = "dynamic")]
-        {
-            closure.increment_call_count();
-        }
-
-        self.handle_function_call_closure_jit_without_profiling_ref(closure, payload_size)
-    }
-
-    #[inline(always)]
-    fn handle_global_function_call_by_reference(
-        &mut self,
-        stack_func: &SteelVal,
-        payload_size: usize,
-    ) -> Result<()> {
-        use SteelVal::*;
-
-        match stack_func {
-            Closure(closure) => self.handle_function_call_closure_jit_ref(closure, payload_size)?,
-            FuncV(f) => self.call_primitive_func(*f, payload_size)?,
-            BoxedFunction(f) => self.call_boxed_func(f.func(), payload_size)?,
-            MutFunc(f) => self.call_primitive_mut_func(*f, payload_size)?,
-            FutureFunc(f) => self.call_future_func(f.clone(), payload_size)?,
-            // ContractedFunction(cf) => self.call_contracted_function(&cf, payload_size)?,
-            ContinuationFunction(cc) => self.call_continuation(cc.clone())?,
-            // #[cfg(feature = "jit")]
-            // CompiledFunction(function) => self.call_compiled_function(function, payload_size)?,
-            // Contract(c) => self.call_contract(&c, payload_size)?,
-            BuiltIn(f) => self.call_builtin_func(*f, payload_size)?,
-            // CustomStruct(s) => self.call_custom_struct_global(&s.borrow(), payload_size)?,
-            _ => {
-                // Explicitly mark this as unlikely
-                cold();
-                log::error!("{stack_func:?}");
-                log::error!("Stack: {:?}", self.thread.stack);
-                stop!(BadSyntax => "Function application not a procedure or function type not supported"; self.current_span());
-            }
-        }
-        Ok(())
-    }
-
-    #[inline(always)]
-    fn handle_global_function_call(
-        &mut self,
-        stack_func: SteelVal,
-        payload_size: usize,
-    ) -> Result<()> {
-        use SteelVal::*;
-
-        // println!("Calling global: {}", stack_func);
-
-        match stack_func {
-            Closure(closure) => self.handle_function_call_closure_jit(closure, payload_size),
-            FuncV(f) => self.call_primitive_func(f, payload_size),
-            BoxedFunction(f) => self.call_boxed_func(f.func(), payload_size),
-            MutFunc(f) => self.call_primitive_mut_func(f, payload_size),
-            FutureFunc(f) => self.call_future_func(f, payload_size),
-            // ContractedFunction(cf) => self.call_contracted_function(&cf, payload_size),
-            ContinuationFunction(cc) => self.call_continuation(cc),
-            // Contract(c) => self.call_contract(&c, payload_size),
-            BuiltIn(f) => {
-                // self.ip -= 1;
-                self.call_builtin_func(f, payload_size)
-            }
-            CustomStruct(s) => self.call_custom_struct(&s, payload_size),
-            _ => {
-                // Explicitly mark this as unlikely
-                cold();
-                log::error!("{stack_func:?}");
-                log::error!("Stack: {:?}", self.thread.stack);
-                stop!(BadSyntax => format!("Function application not a procedure or function type not supported: {}", stack_func); self.current_span());
-            }
-        }
-    }
-
-    #[inline(always)]
-    fn handle_non_instr_global_function_call(
-        &mut self,
-        stack_func: SteelVal,
-        args: &mut [SteelVal],
-    ) -> Result<SteelVal> {
-        use SteelVal::*;
-
-        self.ip += 1;
-
-        match &stack_func {
-            BoxedFunction(f) => f.func()(args),
-            MutFunc(f) => f(args),
-            FuncV(f) => f(args),
-            FutureFunc(f) => Ok(SteelVal::FutureV(Gc::new(f(args)?))),
-            _ => {
-                log::error!("{stack_func:?}");
-                log::error!("Stack: {:?}", self.thread.stack);
-                stop!(BadSyntax => format!("Function application not a procedure or function type not supported: {stack_func}"); self.current_span());
-            }
-        }
-
-        // Ok(())
-    }
-
-    #[inline(always)]
-    fn handle_non_instr_global_function_call_lazy_push(
-        &mut self,
-        stack_func: SteelVal,
-        args: &mut [SteelVal],
-    ) -> Result<()> {
-        use SteelVal::*;
-
-        // self.ip += 1;
-
-        match stack_func {
-            BoxedFunction(f) => {
-                self.ip += 1;
-                self.thread.stack.push(f.func()(args)?)
-            }
-            MutFunc(f) => {
-                self.ip += 1;
-                self.thread.stack.push(f(args)?)
-            }
-            FuncV(f) => {
-                self.ip += 1;
-                self.thread.stack.push(f(args)?)
-            }
-            FutureFunc(f) => {
-                self.ip += 1;
-                self.thread.stack.push(SteelVal::FutureV(Gc::new(f(args)?)))
-            }
-            Closure(closure) => {
-                let arity = args.len();
-
-                self.thread.stack.reserve(arity);
-
-                for arg in args {
-                    self.thread.stack.push(arg.clone());
-                }
-
-                // If we're here, we're already done profiling, and don't need to profile anymore
-                self.handle_function_call_closure_jit(closure, arity)?;
-            }
-            // BuiltIn(f) => f(self, args),
-            _ => {
-                log::error!("Lazy push: {stack_func:?}");
-                log::error!("Stack: {:?}", self.thread.stack);
-                stop!(BadSyntax => format!("Function application not a procedure or function type not supported: {stack_func}"); self.current_span());
-            }
-        }
-
-        Ok(())
-    }
-
-    // #[inline(always)]
-    // fn call_contract(&mut self, contract: &Gc<ContractType>, payload_size: usize) -> Result<()> {
-    //     match contract.as_ref() {
-    //         ContractType::Flat(f) => self.handle_function_call(f.predicate.clone(), payload_size),
-    //         _ => {
-    //             stop!(BadSyntax => "Function application not a procedure - cannot apply function contract to argument");
-    //         }
-    //     }
-    // }
-
-    // #[inline(always)]
-    fn handle_function_call(&mut self, stack_func: SteelVal, payload_size: usize) -> Result<()> {
-        use SteelVal::*;
-
-        match stack_func {
-            BoxedFunction(f) => self.call_boxed_func(f.func(), payload_size),
-            FuncV(f) => self.call_primitive_func(f, payload_size),
-            FutureFunc(f) => self.call_future_func(f, payload_size),
-            MutFunc(f) => self.call_primitive_mut_func(f, payload_size),
-            // ContractedFunction(cf) => self.call_contracted_function(&cf, payload_size),
-            ContinuationFunction(cc) => self.call_continuation(cc),
-            Closure(closure) => self.handle_function_call_closure(closure, payload_size),
-            // #[cfg(feature = "jit")]
-            // CompiledFunction(function) => self.call_compiled_function(function, payload_size)?,
-            // Contract(c) => self.call_contract(&c, payload_size),
-            BuiltIn(f) => {
-                // println!("Calling builtin function, non tail call");
-                // self.ip += 1;
-                self.call_builtin_func(f, payload_size)
-            }
-            CustomStruct(s) => self.call_custom_struct(&s, payload_size),
-            _ => {
-                log::error!("{stack_func:?}");
-                log::error!("stack: {:?}", self.thread.stack);
-                stop!(BadSyntax => format!("Function application not a procedure or function type not supported: {stack_func}"); self.current_span());
-            }
-        }
-    }
-
-    // #[inline(always)]
-    fn handle_start_def(&mut self) {
-        self.ip += 1;
-    }
-}
-
-pub fn current_function_span(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    if !args.is_empty() {
-        builtin_stop!(ArityMismatch => format!("current-function-span requires no arguments, found {}", args.len()))
-    }
-
-    // println!("Enclosing span: {:?}", ctx.enclosing_span());
-
-    match ctx.enclosing_span() {
-        Some(s) => Some(Span::into_steelval(s)),
-        None => Some(Ok(SteelVal::Void)),
-    }
-}
-
-/// Inspect the locals at the given function. Probably need to provide a way to
-/// loop this back into the sources, in order to resolve any span information.
-pub fn breakpoint(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    let offset = ctx.get_offset();
-
-    println!("----- Locals -----");
-    for (slot, i) in (offset..ctx.thread.stack.len()).enumerate() {
-        println!("x{} = {:?}", slot, &ctx.thread.stack[i]);
-    }
-
-    Some(Ok(SteelVal::Void))
-}
-
-pub fn call_with_exception_handler(
-    ctx: &mut VmCore,
-    args: &[SteelVal],
-) -> Option<Result<SteelVal>> {
-    if args.len() != 2 {
-        builtin_stop!(ArityMismatch => format!("with-handler expects two arguments, found: {}", args.len()); ctx.current_span());
-    }
-
-    let handler = args[0].clone();
-    let thunk = args[1].clone();
-
-    // let guard = ctx.stack_frames.last_mut().unwrap();
-    // guard.attach_handler(handler);
-
-    match thunk {
-        SteelVal::Closure(closure) => {
-            if ctx.thread.stack_frames.len() == STACK_LIMIT {
-                println!("stack frame at exit: {:?}", ctx.thread.stack);
-                builtin_stop!(Generic => "call/cc: stack overflowed!"; ctx.current_span());
-            }
-
-            if closure.arity() != 0 {
-                builtin_stop!(Generic => "call-with-exception-handler expects a thunk with arity 0");
-            }
-
-            // Roll back one level
-            ctx.ip -= 1;
-
-            ctx.sp = ctx.thread.stack.len();
-
-            // Push the previous state on
-            ctx.thread.stack_frames.push(
-                StackFrame::new(
-                    ctx.sp,
-                    Gc::clone(&closure),
-                    ctx.ip + 1,
-                    Rc::clone(&ctx.instructions),
-                )
-                .with_handler(handler),
-            );
-
-            // ctx.stack_index.push(ctx.stack.len());
-
-            // Put the continuation as the argument
-            // Previously we put the continuation directly on the stack ourselves, but instead we now return as an argument
-            // ctx.stack.push(continuation);
-
-            // self.global_env = inner_env;
-            // ctx.instruction_stack.push(InstructionPointer::new(
-            //     ctx.ip + 1,
-            //     Rc::clone(&ctx.instructions),
-            // ));
-            ctx.pop_count += 1;
-
-            ctx.instructions = closure.body_exp();
-            // ctx.spans = closure.spans();
-            // ctx.function_stack
-            //     .push(CallContext::new(closure).with_span(ctx.current_span()));
-
-            ctx.ip = 0;
-        }
-
-        _ => {
-            builtin_stop!(TypeMismatch => format!("call-with-exception-handler expects a thunk as an argument, found: {thunk}"); ctx.current_span())
-        }
-    }
-
-    // Some(Ok(SteelVal::Void))
-    None
-}
-
-pub fn oneshot_call_cc(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    todo!("Create continuation that can only be used once!")
-}
-
-pub fn call_cc(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    /*
-    - Construct the continuation
-    - Get the function that has been passed in (off the stack)
-    - Apply the function with the continuation
-    - Handle continuation function call separately in the handle_func_call
-    */
-
-    // Roll back one because we advanced prior to entering the builtin
-    ctx.ip -= 1;
-
-    if args.len() != 1 {
-        builtin_stop!(ArityMismatch => format!("call/cc expects one argument, found: {}", args.len()); ctx.current_span());
-    }
-
-    // let function = ctx.stack.pop().unwrap();
-
-    let function = args[0].clone();
-
-    // validate_closure_for_call_cc(&function, self.current_span())?;
-
-    match &function {
-        SteelVal::Closure(c) => {
-            if c.arity() != 1 {
-                builtin_stop!(Generic => "function arity in call/cc must be 1"; ctx.current_span())
-            }
-        }
-        SteelVal::ContinuationFunction(_) => {}
-        SteelVal::FuncV(_) => {}
-        _ => {
-            builtin_stop!(Generic => format!("call/cc expects a function, found: {function}"); ctx.current_span())
-        }
-    }
-
-    // dbg!(&ctx.thread.stack_frames.last().map(|x| &x.continuation_mark));
-
-    let continuation = ctx.construct_continuation_function();
-
-    match function {
-        SteelVal::Closure(closure) => {
-            if ctx.thread.stack_frames.len() == STACK_LIMIT {
-                log::error!("stack frame at exit: {:?}", ctx.thread.stack);
-                builtin_stop!(Generic => "call/cc: stack overflowed!"; ctx.current_span());
-            }
-
-            if closure.arity() != 1 {
-                builtin_stop!(Generic => "call/cc expects a function with arity 1");
-            }
-
-            ctx.sp = ctx.thread.stack.len();
-
-            // ctx.thread
-            //     .stack_frames
-            //     .last_mut()
-            //     .map(|x| x.set_continuation(continuation.clone()));
-
-            ctx.thread.stack_frames.push(
-                StackFrame::new(
-                    ctx.sp,
-                    Gc::clone(&closure),
-                    ctx.ip + 1,
-                    Rc::clone(&ctx.instructions),
-                    // Rc::clone(&ctx.spans),
-                ) // .with_span(ctx.current_span()),
-                .with_continuation_mark(continuation.clone()),
-            );
-
-            ctx.pop_count += 1;
-
-            ctx.instructions = closure.body_exp();
-
-            ctx.ip = 0;
-
-            // let last = ctx.thread.stack_frames.last_mut().unwrap();
-
-            // let offset = last.sp;
-
-            // let back = ctx.thread.stack.len();
-            // let _ = ctx.thread.stack.drain(offset..back);
-            // ctx.instructions = closure.body_exp();
-
-            // last.set_function(closure);
-            // last.set_continuation(continuation.clone());
-
-            // ctx.ip = 0;
-        }
-        SteelVal::ContinuationFunction(cc) => {
-            // ctx.set_state_from_continuation(cc.unwrap());
-
-            // println!("Setting state from continuation...");
-
-            Continuation::set_state_from_continuation(ctx, cc);
-
-            ctx.ip += 1;
-            // ctx.stack.push(continuation);
-        }
-        SteelVal::FuncV(f) => return Some(f(&[SteelVal::ContinuationFunction(continuation)])),
-
-        _ => {
-            builtin_stop!(Generic => format!("call/cc expects a function, found: {function}"));
-        }
-    }
-
-    Some(Ok(SteelVal::ContinuationFunction(continuation)))
-}
-
-// TODO: Come back and finish this
-pub(crate) const APPLY_DOC: DocTemplate<'static> = DocTemplate {
-    signature: "(apply function lst) -> any",
-    params: &["function : function?", "lst : list?"],
-    description: r#"Applies the given `function` with arguments as the contents of the `lst`."#,
-    examples: &[
-        ("λ > (apply + (list 1 2 3 4))", "=> 10"),
-        ("λ > (apply list (list 1 2 3 4))", "=> '(1 2 3 4)"),
-    ],
-};
-
-pub(crate) fn get_test_mode(ctx: &mut VmCore, _args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    Some(Ok(ctx.thread.runtime_options.test.into()))
-}
-
-pub(crate) fn set_test_mode(ctx: &mut VmCore, _args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    ctx.thread.runtime_options.test = true;
-
-    Some(Ok(ctx.thread.runtime_options.test.into()))
-}
-
-pub(crate) fn list_modules(ctx: &mut VmCore, _args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    use crate::rvals::AsRefSteelVal;
-    use crate::steel_vm::builtin::BuiltInModule;
-
-    let mut nursery = ();
-
-    // Find all of the modules that are
-    let modules = ctx
-        .thread
-        .global_env
-        .roots()
-        .filter(|x| BuiltInModule::as_ref(x, &mut nursery).is_ok())
-        .cloned()
-        .collect();
-
-    Some(Ok(SteelVal::ListV(modules)))
-}
-
-// TODO: This apply does not respect tail position
-// Something like this: (define (loop) (apply loop '()))
-// _should_ result in an infinite loop. In the current form, this is a Rust stack overflow.
-// Similarly, care should be taken to check out transduce, because nested calls to that will
-// result in a stack overflow with sufficient depth on the recursive calls
-pub(crate) fn apply(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    // arity_check!(apply, args, 2);
-
-    // println!("Calling apply!");
-    // println!("Current instruction: {:?}", ctx.instructions[ctx.ip]);
-
-    // ctx.ip -= 1;
-
-    let current_instruction = ctx.instructions[ctx.ip - 1];
-
-    let tail_call = matches!(
-        current_instruction.op_code,
-        OpCode::TAILCALL | OpCode::CALLGLOBALTAIL
-    );
-
-    // dbg!(tail_call);
-
-    // println!("Current instruction: {:?}", ctx.instructions[ctx.ip]);
-
-    if args.len() != 2 {
-        builtin_stop!(ArityMismatch => "apply expected 2 arguments");
-    }
-
-    let mut arg_iter = args.iter();
-    let arg1 = arg_iter.next().unwrap();
-    let arg2 = arg_iter.next().unwrap();
-
-    if let SteelVal::ListV(l) = arg2 {
-        if arg1.is_function() {
-            // println!("Calling apply with args: {:?}, {:?}", arg1, arg2);
-            // ctx.call_function_many_args(&arg1, l.clone())
-
-            match arg1 {
-                SteelVal::Closure(closure) => {
-                    for arg in l {
-                        ctx.thread.stack.push(arg.clone());
-                    }
-
-                    let res = if tail_call {
-                        ctx.new_handle_tail_call_closure(closure.clone(), l.len())
-                    } else {
-                        ctx.ip -= 1;
-
-                        ctx.handle_function_call_closure(closure.clone(), l.len())
-                    };
-
-                    // TODO: Fix this unwrap
-                    // let res = ctx.handle_function_call_closure(closure.clone(), l.len());
-                    // let res = ctx.new_handle_tail_call_closure(closure.clone(), l.len());
-
-                    if res.is_err() {
-                        // This is explicitly unreachable, since we're checking
-                        // that this is an error variant
-                        return Some(res.map(|_| unreachable!()));
-                    }
-
-                    None
-                }
-                SteelVal::ContinuationFunction(cc) => {
-                    // ctx.set_state_from_continuation(cc.unwrap());
-
-                    Continuation::set_state_from_continuation(ctx, cc.clone());
-
-                    ctx.ip += 1;
-
-                    None
-                    // ctx.stack.push(continuation);
-                }
-                // TODO: Reuse the allocation for apply
-                SteelVal::FuncV(f) => {
-                    let args = l.into_iter().cloned().collect::<Vec<_>>();
-
-                    let result = f(&args).map_err(|e| e.set_span_if_none(ctx.current_span()));
-
-                    Some(result)
-                }
-                SteelVal::MutFunc(f) => {
-                    let mut args = l.into_iter().cloned().collect::<Vec<_>>();
-
-                    let result = f(&mut args).map_err(|e| e.set_span_if_none(ctx.current_span()));
-
-                    Some(result)
-                }
-                SteelVal::BoxedFunction(f) => {
-                    let mut args = l.into_iter().cloned().collect::<Vec<_>>();
-
-                    let result =
-                        f.func()(&args).map_err(|e| e.set_span_if_none(ctx.current_span()));
-
-                    Some(result)
-                }
-
-                // Calling a builtin here might involve a little recursion business
-                SteelVal::BuiltIn(f) => {
-                    // println!("Calling a builtin with apply!");
-
-                    let args = l.into_iter().cloned().collect::<Vec<_>>();
-
-                    // ctx.ip += 1;
-
-                    // TODO: Don't do this - just read directly from the stack
-
-                    let result = f(ctx, &args).map(|x| {
-                        x.map_err(|x| {
-                            // TODO: @Matt 4/24/2022 -> combine this into one function probably
-                            if x.has_span() {
-                                x
-                            } else {
-                                x.set_span_if_none(ctx.current_span())
-                            }
-                            // x.set_span_if_none(self.current_span())
-                        })
-                    });
-
-                    // TODO: Check if this is right - I think we really just want to return the value?
-                    if let Some(result) = result {
-                        match result {
-                            Ok(value) => ctx.thread.stack.push(value),
-                            e @ Err(_) => return Some(e),
-                        }
-                    }
-
-                    // ctx.ip += 1;
-
-                    None
-                }
-
-                // SteelVal::CustomStruct(s) => {
-                //     let args = l.into_iter().cloned().collect::<Vec<_>>();
-
-                // }
-                _ => {
-                    builtin_stop!(Generic => format!("apply expects a function, found: {arg1}"));
-                }
-            }
-        } else {
-            builtin_stop!(TypeMismatch => "apply expected a function, found: {}", arg1);
-        }
-    } else {
-        builtin_stop!(TypeMismatch => "apply expects a list, found: {}", arg2);
-    }
-}
-
-#[derive(PartialEq, Eq, Hash, Clone, PartialOrd, Ord, Debug)]
-pub struct InstructionPattern {
-    pub(crate) block: Rc<[(OpCode, usize)]>,
-    pub(crate) pattern: BlockPattern,
-}
-
-impl InstructionPattern {
-    pub fn new(block: Rc<[(OpCode, usize)]>, pattern: BlockPattern) -> Self {
-        Self { block, pattern }
-    }
-}
-
-#[derive(PartialEq, Eq, Hash, Clone, PartialOrd, Ord, Debug)]
-pub struct BlockPattern {
-    start: usize,
-    end: usize,
-}
-
-#[derive(Debug, Clone, Default, PartialOrd, Ord, PartialEq, Eq, Hash)]
-pub struct BlockMetadata {
-    count: usize,
-    length: usize,
-    created: bool,
-}
-
-#[derive(Clone)]
-pub struct OpCodeOccurenceProfiler {
-    occurrences: HashMap<(OpCode, usize), usize>,
-    time: HashMap<(OpCode, usize), std::time::Duration>,
-    starting_index: Option<usize>,
-    ending_index: Option<usize>,
-    sample_count: usize,
-}
-
-impl OpCodeOccurenceProfiler {
-    pub fn new() -> Self {
-        OpCodeOccurenceProfiler {
-            occurrences: HashMap::new(),
-            time: HashMap::new(),
-            starting_index: None,
-            ending_index: None,
-            sample_count: 0,
-        }
-    }
-
-    pub fn reset(&mut self) {
-        self.occurrences.clear();
-        self.time.clear();
-    }
-
-    // Process the op code and the associated payload
-    // TODO: Get this to just use offsets, don't actually clone the instruction set directly
-    #[cfg(feature = "dynamic")]
-    pub fn process_opcode(
-        &mut self,
-        opcode: &OpCode,
-        // payload: usize,
-        index: usize,
-        instructions: &[DenseInstruction],
-        function: Option<&ByteCodeLambda>,
-    ) -> Option<InstructionPattern> {
-        // *self.occurrences.entry((*opcode, payload)).or_default() += 1;
-
-        let function = function?;
-
-        // Trace once it becomes hot
-        let call_count = function.call_count();
-        // If we're in the special zone, profile, otherwise don't
-        if call_count < 1000 || call_count > 10000 {
-            self.starting_index = None;
-            self.ending_index = None;
-            return None;
-        }
-
-        match opcode {
-            OpCode::SDEF | OpCode::EDEF => return None,
-            _ => {}
-        }
-
-        if self.starting_index.is_none() {
-            self.starting_index = Some(index);
-        }
-
-        self.ending_index = Some(index);
-
-        match opcode {
-            OpCode::JMP
-            | OpCode::IF
-            // | OpCode::CALLGLOBAL
-            | OpCode::CALLGLOBALTAIL
-            | OpCode::TAILCALL
-            | OpCode::TCOJMP
-            | OpCode::POPPURE
-            | OpCode::LTEIMMEDIATEIF
-            // | OpCode::FUNC 
-            => {
-
-                let block_pattern = BlockPattern {
-                    start: self.starting_index.unwrap(),
-                    end: index
-                };
-
-                let mut guard = function.blocks.borrow_mut();
-
-
-                if let Some((_, metadata)) = guard.iter_mut().find(|x| x.0 == block_pattern) {
-
-                    // self.sample_count += 1;
-                    // println!("Sampling on op code: {:?}", opcode);
-
-                    metadata.count += 1;
-                    metadata.length = index - block_pattern.start;
-                    // self.last_sequence = Some(pattern);
-
-                    if metadata.count > 1000 && !metadata.created {
-                        metadata.created = true;
-
-                        // println!("{} {}", block_pattern.start, index);
-
-                        let sequence = instructions[block_pattern.start..=index]
-                            .iter()
-                            .map(|x| (x.op_code, x.payload_size as usize))
-                            .filter(|x| !x.0.is_ephemeral_opcode() && x.0 != OpCode::POPPURE)
-                            .collect();
-
-                        self.starting_index = None;
-                        self.ending_index = None;
-
-
-                        // println!("Pattern finished");
-
-                        return Some(InstructionPattern::new(sequence, block_pattern));
-                    }
-
-                } else if index - block_pattern.start > 2 {
-                    guard.push((block_pattern, BlockMetadata::default()));
-                }
-
-                self.starting_index = None;
-                self.ending_index = None;
-
-                // println!("Pattern finished");
-            }
-            _ => {
-                // println!("Updating end to be: {}", index);
-                self.ending_index = Some(index);
-                // self.sequence.push((*opcode, index));
-            }
-        }
-
-        None
-    }
-
-    #[cfg(feature = "dynamic")]
-    pub fn cut_sequence(
-        &mut self,
-        instructions: &[DenseInstruction],
-        function: Option<&ByteCodeLambda>,
-    ) -> Option<InstructionPattern> {
-        // println!(
-        //     "Cutting sequence: {:?} {:?} {:?}",
-        //     function_id, self.starting_index, self.ending_index
-        // );
-
-        let function = function?;
-
-        // Trace once it becomes hot
-        let call_count = function.call_count();
-
-        // If we're in the special zone, profile, otherwise don't
-        if !(1000..=10000).contains(&call_count) {
-            self.starting_index = None;
-            self.ending_index = None;
-            return None;
-        }
-
-        let start = self.starting_index?;
-        let index = self.ending_index?;
-
-        let block_pattern = BlockPattern { start, end: index };
-
-        // if function.check_tail(&block_pattern) {
-        //     self.starting_index = None;
-        //     self.ending_index = None;
-        //     return None;
-        // }
-
-        let mut guard = function.blocks.borrow_mut();
-
-        if let Some((_, metadata)) = guard.iter_mut().find(|x| x.0 == block_pattern) {
-            metadata.count += 1;
-            metadata.length = index - block_pattern.start;
-            // self.last_sequence = Some(pattern);
-
-            // self.sample_count += 1;
-            // println!("Sampling on op code: {:?}", instructions[index].op_code);
-
-            if metadata.count > 1000 && !metadata.created {
-                metadata.created = true;
-
-                let sequence = instructions[block_pattern.start..=index]
-                    .iter()
-                    .map(|x| (x.op_code, x.payload_size as usize))
-                    .filter(|x| !x.0.is_ephemeral_opcode() && x.0 != OpCode::POPPURE)
-                    .collect();
-
-                self.starting_index = None;
-                self.ending_index = None;
-
-                // println!("Pattern finished");
-
-                return Some(InstructionPattern::new(sequence, block_pattern));
-            }
-        } else if index - block_pattern.start > 3 {
-            guard.push((block_pattern, BlockMetadata::default()));
-        }
-
-        self.starting_index = None;
-        self.ending_index = None;
-
-        // println!("Pattern finished");
-
-        None
-    }
-
-    pub fn add_time(&mut self, opcode: &OpCode, payload: usize, time: std::time::Duration) {
-        *self.time.entry((*opcode, payload)).or_default() += time;
-    }
-
-    // pub fn report_basic_blocks(&self) {
-    //     println!("--------------- Basic Blocks ---------------");
-
-    //     let mut blocks = self
-    //         .super_instructions
-    //         .basic_blocks
-    //         .iter()
-    //         .collect::<Vec<_>>();
-
-    //     blocks.sort_by_key(|x| x.1);
-    //     blocks.reverse();
-
-    //     for block in blocks.iter().take(10) {
-    //         if block.1.count > 0 {
-    //             println!("{:#?}", block)
-    //         }
-    //     }
-
-    //     println!("--------------------------------------------")
-    // }
-
-    pub fn report_time_spend(&self) {
-        let total_time: u128 = self.time.values().map(|x| x.as_micros()).sum();
-
-        let mut counts = self
-            .time
-            .iter()
-            .map(|x| (x.0, (x.1.as_micros() as f64 / total_time as f64) * 100.0))
-            .filter(|x| !f64::is_nan(x.1))
-            .collect::<Vec<(&(OpCode, usize), f64)>>();
-
-        counts.sort_by(|x, y| y.1.partial_cmp(&x.1).unwrap());
-
-        println!("------- Time Spent: Profiling Report -------");
-        for row in counts {
-            println!("{:?} => {:.2}%", row.0, row.1);
-        }
-        println!("--------------------------------------------")
-    }
-
-    pub fn report(&self) {
-        let total: usize = self.occurrences.values().sum();
-
-        let mut counts = self
-            .occurrences
-            .iter()
-            .map(|x| (x.0, (*x.1 as f64 / total as f64) * 100.0))
-            .collect::<Vec<(&(OpCode, usize), f64)>>();
-
-        counts.sort_by(|x, y| y.1.partial_cmp(&x.1).unwrap());
-
-        println!("------- Profiling Report -------");
-        println!("Total instructions executed: {total}");
-        for row in counts {
-            println!("{:?} => {:.2}%", row.0, row.1);
-        }
-        println!("--------------------------------")
-
-        // println!("{:#?}", counts);
-    }
-}
-
-// If the op code requires the original payload from the instruction that we're overwriting, we should
-// attach it to the basic block, because otherwise we'll have lost the payload
-fn op_code_requires_payload(
-    op_code: OpCode,
-) -> Option<for<'r> fn(&'r mut VmCore<'_>, usize) -> Result<()>> {
-    match op_code {
-        OpCode::VOID => None,
-        OpCode::PUSH => Some(push_handler_with_payload),
-        OpCode::IF => todo!(),
-        OpCode::JMP => todo!(),
-        OpCode::FUNC => Some(func_handler_with_payload),
-        OpCode::SCLOSURE => todo!(),
-        OpCode::ECLOSURE => todo!(),
-        OpCode::BIND => Some(bind_handler_with_payload),
-        OpCode::SDEF => todo!(),
-        OpCode::EDEF => todo!(),
-        OpCode::POPPURE => todo!(),
-        OpCode::PASS => todo!(),
-        OpCode::PUSHCONST => Some(push_const_handler_with_payload),
-        OpCode::NDEFS => todo!(),
-        OpCode::PANIC => None,
-        OpCode::TAILCALL => todo!(),
-        OpCode::SET => Some(set_handler_with_payload),
-        OpCode::READLOCAL => Some(local_handler_with_payload),
-        OpCode::READLOCAL0 => None,
-        OpCode::READLOCAL1 => None,
-        OpCode::READLOCAL2 => None,
-        OpCode::READLOCAL3 => None,
-        OpCode::SETLOCAL => Some(set_local_handler_with_payload),
-        OpCode::COPYCAPTURESTACK => todo!(),
-        OpCode::COPYCAPTURECLOSURE => todo!(),
-        OpCode::COPYHEAPCAPTURECLOSURE => todo!(),
-        OpCode::FIRSTCOPYHEAPCAPTURECLOSURE => todo!(),
-        OpCode::TCOJMP => todo!(),
-        OpCode::CALLGLOBAL => Some(call_global_handler_with_payload),
-        OpCode::CALLGLOBALTAIL => todo!(),
-        OpCode::LOADINT0 => None,
-        OpCode::LOADINT1 => None,
-        OpCode::LOADINT2 => None,
-        OpCode::CGLOCALCONST => todo!(),
-        OpCode::MOVEREADLOCAL => Some(move_local_handler_with_payload),
-        OpCode::MOVEREADLOCAL0 => None,
-        OpCode::MOVEREADLOCAL1 => None,
-        OpCode::MOVEREADLOCAL2 => None,
-        OpCode::MOVEREADLOCAL3 => None,
-        OpCode::READCAPTURED => Some(read_captured_handler_with_payload),
-        OpCode::BEGINSCOPE => None,
-        OpCode::LETENDSCOPE => Some(let_end_scope_handler_with_payload),
-        OpCode::PUREFUNC => Some(pure_function_handler_with_payload),
-        OpCode::ADD => Some(add_handler_payload),
-        OpCode::SUB => Some(sub_handler_payload),
-        OpCode::MUL => Some(multiply_handler_payload),
-        OpCode::DIV => Some(division_handler_payload),
-        OpCode::EQUAL => Some(equality_handler_payload),
-        OpCode::LTE => Some(lte_handler_payload),
-        OpCode::NEWSCLOSURE => Some(new_sclosure_handler_with_payload),
-        OpCode::ADDREGISTER => todo!(),
-        OpCode::SUBREGISTER => todo!(),
-        OpCode::LTEREGISTER => todo!(),
-        OpCode::SUBREGISTER1 => todo!(),
-        OpCode::ALLOC => None,
-        OpCode::READALLOC => Some(read_alloc_handler_with_payload),
-        OpCode::SETALLOC => Some(set_alloc_handler_with_payload),
-        // OpCode::GIMMICK => todo!(),
-        // OpCode::MOVEREADLOCALCALLGLOBAL => Some(move_read_local_call_global_handler_payload),
-        OpCode::DynSuperInstruction => todo!(),
-        _ => None,
-    }
-}
-
-// Table to map opcode discriminant directly to an individual handler function
-// Why do we want this? When generating dynamic super instructions, we create
-// basic blocks, and from there transfer contexts away from the core vm loop, and instead
-// over to a basic block sequence of handler function, which we will call directly
-// on the main VM context. In order to construct these sequences, we will need to be able
-// to grab a basic block from the running sequence, and directly patch an instruction set
-// on the fly, to transfer context over to that sequence.
-static OP_CODE_TABLE: [for<'r> fn(&'r mut VmCore<'_>) -> Result<()>; 66] = [
-    void_handler,
-    push_handler,
-    if_handler,   // If
-    jump_handler, // jmp
-    func_handler,
-    dummy, // sclosure
-    dummy, // eclosure
-    bind_handler,
-    dummy, // sdef
-    dummy, // edef
-    dummy, // pop
-    dummy, // popn
-    dummy, // pass
-    push_const_handler,
-    dummy, // ndefs,
-    panic_handler,
-    tail_call_handler, // tailcall
-    set_handler,
-    local_handler,
-    local_handler0,
-    local_handler1,
-    local_handler2,
-    local_handler3,
-    set_local_handler,
-    dummy,            // copycapturestack
-    dummy,            // copycaptureclosure
-    dummy,            // copyheapcaptureclosure
-    dummy,            // firstcopyheapcaptureclosure
-    tco_jump_handler, // tcojmp
-    call_global_handler,
-    call_global_tail_handler, // callglobaltail
-    handle_load_int0,
-    handle_load_int1,
-    handle_load_int2,
-    dummy, // cglocalconst
-    move_local_handler,
-    move_local_handler0,
-    move_local_handler1,
-    move_local_handler2,
-    move_local_handler3,
-    read_captured_handler,
-    begin_scope_handler,
-    let_end_scope_handler,
-    pure_function_handler,
-    add_handler,
-    sub_handler,
-    multiply_handler,
-    division_handler,
-    equality_handler,
-    lte_handler,
-    new_sclosure_handler,
-    dummy, // addregister
-    dummy, // subregister
-    dummy, // lteregister
-    dummy, // subregister
-    alloc_handler,
-    read_alloc_handler,
-    set_alloc_handler,
-    // dummy,                               // gimmick
-    // move_read_local_call_global_handler, // movereadlocalcallglobal,
-    dummy, // dynsuperinstruction,
-    dummy,
-    dummy,
-    dummy,
-    dummy,
-    dummy,
-    binop_add_handler,
-    dummy,
-];
-
-macro_rules! opcode_to_function {
-    (VOID) => {
-        void_handler
-    };
-    (PUSH) => {
-        push_handler
-    };
-    (FUNC) => {
-        func_handler
-    };
-    (BIND) => {
-        bind_handler
-    };
-    (PUSHCONST) => {
-        push_const_handler
-    };
-    (PANIC) => {
-        panic_handler
-    };
-    (SET) => {
-        set_handler
-    };
-    (READLOCAL0) => {
-        local_handler0
-    };
-    (LOADINT2) => {
-        handle_load_int2
-    };
-    (LTE) => {
-        lte_handler
-    };
-    (MOVEREADLOCAL0) => {
-        move_local_handler0
-    };
-    (SUB) => {
-        sub_handler
-    };
-    (LOADINT1) => {
-        handle_load_int1
-    };
-    (MUL) => {
-        multiply_handler
-    };
-    (MOVEREADLOCAL1) => {
-        move_local_handler1
-    };
-    (READLOCAL1) => {
-        local_handler1
-    };
-    (READLOCAL2) => {
-        local_handler2
-    };
-    (READLOCAL3) => {
-        local_handler3
-    };
-    (LOADINT0) => {
-        handle_load_int0
-    };
-    (CALLGLOBAL) => {
-        call_global_handler
-    };
-    (READCAPTURED) => {
-        read_captured_handler
-    };
-    (IF) => {
-        if_handler
-    };
-    (EQUAL) => {
-        equality_handler
-    };
-    (JMP) => {
-        jump_handler
-    };
-    (ADD) => {
-        add_handler
-    };
-    (TAILCALL) => {
-        tail_call_handler
-    };
-}
-
-static SUPER_PATTERNS: Lazy<
-    std::collections::HashMap<Vec<OpCode>, for<'r> fn(&'r mut VmCore<'_>) -> Result<()>>,
-> = Lazy::new(|| create_super_instruction_map());
-
-// lazy_static! {
-//     static ref SUPER_PATTERNS: std::collections::HashMap<
-//         Vec<(OpCode, Option<usize>)>,
-//         for<'r> fn(&'r mut VmCore<'_>) -> Result<()>,
-//     > = create_super_instruction_map();
-// }
-
-fn create_super_instruction_map(
-) -> std::collections::HashMap<Vec<OpCode>, for<'r> fn(&'r mut VmCore<'_>) -> Result<()>> {
-    use OpCode::*;
-
-    let mut map = HashMap::new();
-
-    macro_rules! create_super_pattern {
-        ($($args:tt),*) => {
-
-            // fn func(ctx: &mut VmCore<'_>) -> Result<()> {
-            //     $(
-            //         OP_CODE_TABLE[$args as usize](ctx)?;
-            //     )*
-
-            //     Ok(())
-            // }
-
-            // TODO: This isn't actually doing the correct mapping. Set up a const mapping instead using macros
-            map.insert(vec![
-                $($args,)*
-            ], |ctx: &mut VmCore<'_>| -> Result<()> {
-                $(
-                    opcode_to_function!($args)(ctx)?;
-                )*
-
-                Ok(())
-            } as for<'r> fn(&'r mut VmCore<'_>) -> Result<()>);
-        };
-    }
-
-    // Fib patterns identified from the benchmarks
-    // yes, this is explicitly gaming the benchmarks. But the idea is sound,
-    // and this is just a start.
-    // create_super_pattern!(READLOCAL0, LOADINT2, LTE, IF);
-
-    map.insert(
-        vec![READLOCAL0, LOADINT2, LTE, IF],
-        specialized_lte0 as for<'r> fn(&'r mut VmCore<'_>) -> Result<()>,
-    );
-
-    map.insert(
-        vec![MOVEREADLOCAL0, LOADINT2, SUB, CALLGLOBAL],
-        specialized_sub02 as for<'r> fn(&'r mut VmCore<'_>) -> Result<()>,
-    );
-
-    map.insert(
-        vec![READLOCAL0, LOADINT1, SUB, CALLGLOBAL],
-        specialized_sub01 as for<'r> fn(&'r mut VmCore<'_>) -> Result<()>,
-    );
-
-    // create_super_pattern!(MOVEREADLOCAL0, LOADINT2, SUB, CALLGLOBAL);
-    // create_super_pattern!(READLOCAL0, LOADINT1, SUB, CALLGLOBAL);
-
-    // bin trees patterns
-    create_super_pattern!(
-        READLOCAL0,
-        LOADINT2,
-        MUL,
-        MOVEREADLOCAL1,
-        LOADINT1,
-        SUB,
-        READLOCAL2,
-        LOADINT1,
-        SUB,
-        READLOCAL3,
-        CALLGLOBAL
-    );
-
-    create_super_pattern!(READLOCAL1, LOADINT0, CALLGLOBAL, IF);
-    create_super_pattern!(MOVEREADLOCAL0, LOADINT0, READCAPTURED, TAILCALL);
-    create_super_pattern!(MOVEREADLOCAL0, LOADINT2, READCAPTURED, TAILCALL);
-
-    // Ack patterns
-    create_super_pattern!(READLOCAL0, LOADINT0, EQUAL, IF);
-
-    create_super_pattern!(READLOCAL1, LOADINT0, EQUAL, IF);
-
-    create_super_pattern!(
-        READLOCAL0,
-        LOADINT1,
-        SUB,
-        MOVEREADLOCAL0,
-        MOVEREADLOCAL1,
-        LOADINT1,
-        SUB,
-        CALLGLOBAL
-    );
-
-    create_super_pattern!(READLOCAL1, LOADINT1, ADD, JMP);
-
-    map
-}
-
-/*
-
-TODO:
-* https://www3.hhu.de/stups/downloads/pdf/BoCuFiRi09_246.pdf
-* https://github.com/playXE/stack2ssa/blob/main/src/lower.rs
-
-^^ The above actually seems to generate an honest to god JIT backend. What I'm suggesting
-is to still just use the runtime, but instead to profile guided optimization to constantly be
-creating sequences of instructions that speed things up.
-
-Develop a DSL for generating super instructions, via macros.
-
-If the op code handler pushes a value to the stack, it should be declared like so:
-
-fn returns_value(ctx: &mut VmCore<'_>) -> Result<SteelVal> {
-    ...
-}
-
-if its a bin op, make it look like this:
-
-fn bin_op(ctx: &mut VmCore<'_>) -> Result<SteelVal> {
-    ...
-}
-
-if we know it returns a bool, have it just return a bool:
-
-fn bool(ctx: &mut VmCore<'_>) -> Result<bool> {
-    ...
-}
-
-Then, with a sequence of fairly silly macros transformations, we could define a sequence of meta
-instructions with some funny macros:
-
-super_instruction! {
-    READLOCAL0,
-    LOADINT1,
-    SUB,
-    MOVEREADLOCAL0,
-    MOVEREADLOCAL1,
-    LOADINT1,
-    SUB,
-    CALLGLOBAL
-}
-
-could translate directly to something like (where we have comp time fresh vars, somehow):
-
-let x = read_local_0(ctx);
-let y = 1;
-let z = x - y // somehow
-
-let foo = move_read_local_0(ctx);
-let bar = move_read_local_1(ctx);
-let baz = 1;
-
-let quux = bar - baz;
-let call_global = call_global(ctx, ...)
-
-ret call_global
-
-We would have to perform stack to ssa conversion, such that its implicitly possible to reconstruct
-the call stack, and then we can "compile" this directly to the rust code that manipulates the state
-of the VM context.
-
-"Unlocking" the state by removing from the state of the
-
-*/
-
-fn specialized_lte0(ctx: &mut VmCore<'_>) -> Result<()> {
-    // let offset = ctx.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    let offset = ctx.get_offset();
-    let value = ctx.thread.stack[offset].clone();
-
-    let result = lte_binop(value, 2);
-    ctx.ip += 4;
-
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    // change to truthy...
-    if result {
-        ctx.ip += 1;
-    } else {
-        ctx.ip = payload_size as usize;
-    }
-
-    Ok(())
-}
-
-fn specialized_sub02(ctx: &mut VmCore<'_>) -> Result<()> {
-    // let offset = ctx.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    let offset = ctx.get_offset();
-    let value = ctx.thread.stack[offset].clone();
-
-    ctx.thread.stack.push(sub_binop(value, 2)?);
-    ctx.ip += 4;
-    Ok(())
-}
-
-fn specialized_sub01(ctx: &mut VmCore<'_>) -> Result<()> {
-    let offset = ctx.get_offset();
-    // let offset = ctx.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    let value = ctx.thread.stack[offset].clone();
-
-    ctx.thread.stack.push(sub_binop(value, 1)?);
-    ctx.ip += 4;
-
-    call_global_handler(ctx)
-}
-
-pub fn lte_binop(l: SteelVal, r: isize) -> bool {
-    match l {
-        SteelVal::IntV(l) => l <= r,
-        _ => false,
-    }
-}
-
-pub fn sub_binop(l: SteelVal, r: isize) -> Result<SteelVal> {
-    match l {
-        SteelVal::IntV(l) => Ok(SteelVal::IntV(l - r)),
-        SteelVal::NumV(l) => Ok(SteelVal::NumV(l - r as f64)),
-        _ => stop!(TypeMismatch => "sub given wrong types"),
-    }
-}
-
-fn dummy(_: &mut VmCore<'_>) -> Result<()> {
-    panic!("Unimplemented op code handler!")
-}
-
-#[inline(always)]
-fn handle_push_no_stack(ctx: &mut VmCore<'_>, index: usize) -> Result<SteelVal> {
-    let value = ctx.thread.global_env.repl_lookup_idx(index);
-    ctx.ip += 1;
-    Ok(value)
-}
-
-#[inline(always)]
-fn handle_local_no_stack(ctx: &mut VmCore<'_>, index: usize) -> Result<SteelVal> {
-    let offset = ctx.get_offset();
-    let value = ctx.thread.stack[index + offset].clone();
-    ctx.ip += 1;
-    Ok(value)
-}
-
-#[inline(always)]
-fn handle_read_captures_no_stack(ctx: &mut VmCore<'_>, index: usize) -> Result<SteelVal> {
-    let value = ctx.thread.stack_frames.last().unwrap().function.captures()[index].clone();
-
-    ctx.ip += 1;
-    Ok(value)
-}
-
-#[inline(always)]
-fn handle_move_local_no_stack(ctx: &mut VmCore<'_>, index: usize) -> Result<SteelVal> {
-    // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    // let offset = ctx.stack_frames.last().unwrap().index;
-    let offset = ctx.get_offset();
-    let value = ctx.move_from_stack(index + offset);
-    ctx.ip += 1;
-    Ok(value)
-}
-
-#[inline(always)]
-fn handle_move_local_0_no_stack(ctx: &mut VmCore<'_>) -> Result<SteelVal> {
-    // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    // let offset = ctx.stack_frames.last().unwrap().index;
-    let offset = ctx.get_offset();
-    let value = ctx.move_from_stack(offset);
-    ctx.ip += 1;
-    Ok(value)
-}
-
-#[inline(always)]
-fn handle_move_local_1_no_stack(ctx: &mut VmCore<'_>) -> Result<SteelVal> {
-    // let offset = self.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    // let offset = ctx.stack_frames.last().unwrap().index;
-    let offset = ctx.get_offset();
-    let value = ctx.move_from_stack(offset + 1);
-    ctx.ip += 1;
-    Ok(value)
-}
-
-#[inline(always)]
-fn handle_local_0_no_stack(ctx: &mut VmCore<'_>) -> Result<SteelVal> {
-    let offset = ctx.get_offset();
-    let value = ctx.thread.stack[offset].clone();
-    ctx.ip += 1;
-    Ok(value)
-}
-
-#[inline(always)]
-fn handle_local_1_no_stack(ctx: &mut VmCore<'_>) -> Result<SteelVal> {
-    let offset = ctx.get_offset();
-    let value = ctx.thread.stack[offset + 1].clone();
-    ctx.ip += 1;
-    Ok(value)
-}
-
-// OpCode::VOID
-fn void_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.thread.stack.push(SteelVal::Void);
-    ctx.ip += 1;
-    Ok(())
-}
-
-// OpCode::PUSH
-fn push_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let index = ctx.instructions[ctx.ip].payload_size;
-    ctx.handle_push(index as usize)
-}
-
-// OpCode::PUSH
-fn push_handler_with_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    ctx.handle_push(payload)
-}
-
-// OpCode::FUNC
-fn func_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let func = ctx.thread.stack.pop().unwrap();
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    ctx.handle_function_call(func, payload_size as usize)
-}
-
-// OpCode::FUNC
-fn func_handler_with_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    let func = ctx.thread.stack.pop().unwrap();
-    ctx.handle_function_call(func, payload)
-}
-
-// OpCode::BIND
-fn bind_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let index = ctx.instructions[ctx.ip].payload_size;
-    ctx.handle_bind(index as usize);
-    Ok(())
-}
-
-// OpCode::BIND
-fn bind_handler_with_payload(ctx: &mut VmCore<'_>, index: usize) -> Result<()> {
-    ctx.handle_bind(index);
-    Ok(())
-}
-
-// OpCode::PUSHCONST
-fn push_const_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    let val = ctx.constants.get(payload_size as usize);
-    ctx.thread.stack.push(val);
-    ctx.ip += 1;
-    Ok(())
-}
-
-fn push_const_handler_no_stack(ctx: &mut VmCore<'_>) -> Result<SteelVal> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    let val = ctx.constants.get(payload_size as usize);
-    ctx.ip += 1;
-    Ok(val)
-}
-
-// OpCode::PUSHCONST
-fn push_const_handler_with_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    let val = ctx.constants.get(payload);
-    ctx.thread.stack.push(val);
-    ctx.ip += 1;
-    Ok(())
-}
-
-// OpCode::PANIC
-fn panic_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.handle_panic(ctx.current_span())
-}
-
-// OpCode::SET
-fn set_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let index = ctx.instructions[ctx.ip].payload_size;
-    ctx.handle_set(index as usize)
-}
-
-// OpCode::SET
-fn set_handler_with_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    ctx.handle_set(payload)
-}
-
-// OpCode::READLOCAL
-#[inline(always)]
-fn local_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let index = ctx.instructions[ctx.ip].payload_size;
-    ctx.handle_local(index as usize)
-}
-
-// OpCode::READLOCAL
-fn local_handler_with_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    ctx.handle_local(payload)
-}
-
-// OpCode::READLOCAL0
-#[inline(always)]
-fn local_handler0(ctx: &mut VmCore<'_>) -> Result<()> {
-    // let offset = ctx.get_offset();
-    // dbg!(&ctx.thread.stack.get(offset..));
-    ctx.handle_local(0)
-}
-
-// OpCode::READLOCAL1
-fn local_handler1(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.handle_local(1)
-}
-
-// OpCode::READLOCAL2
-fn local_handler2(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.handle_local(2)
-}
-
-// OpCode::READLOCAL3
-fn local_handler3(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.handle_local(3)
-}
-
-// OpCode::SETLOCAL
-fn set_local_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let offset = ctx.instructions[ctx.ip].payload_size;
-    ctx.handle_set_local(offset as usize);
-    Ok(())
-}
-
-// OpCode::SETLOCAL
-fn set_local_handler_with_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    ctx.handle_set_local(payload);
-    Ok(())
-}
-
-// OpCode::CALLGLOBAL
-fn call_global_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    // assert!(ctx.ip + 1 < ctx.instructions.len());
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    ctx.ip += 1;
-    let next_inst = ctx.instructions[ctx.ip];
-
-    ctx.handle_call_global(payload_size as usize, next_inst.payload_size as usize)
-}
-
-// OpCode::CALLGLOBAL
-// TODO: Fix this!
-fn call_global_handler_with_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    ctx.ip += 1;
-    let next_inst = ctx.instructions[ctx.ip];
-    ctx.handle_call_global(payload, next_inst.payload_size as usize)
-}
-
-// TODO: Have a way to know the correct arity?
-fn call_global_handler_no_stack(ctx: &mut VmCore<'_>, args: &mut [SteelVal]) -> Result<SteelVal> {
-    // ctx.ip += 1;
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    ctx.ip += 1;
-
-    // TODO: Track the op codes of the surrounding values as well
-    // let next_inst = ctx.instructions[ctx.ip];
-
-    // println!("Looking up a function at index: {}", payload_size as usize);
-
-    let func = ctx.thread.global_env.repl_lookup_idx(payload_size as usize);
-    ctx.handle_non_instr_global_function_call(func, args)
-}
-
-// Call a global function with the given arguments, but only push the args to the stack
-// if we need to
-
-#[inline(always)]
-fn call_global_handler_with_args(ctx: &mut VmCore<'_>, args: &mut [SteelVal]) -> Result<()> {
-    // ctx.ip += 1;
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    ctx.ip += 1;
-
-    // TODO: Track the op codes of the surrounding values as well
-    // let next_inst = ctx.instructions[ctx.ip];
-
-    // println!("Looking up a function at index: {}", payload_size as usize);
-    // panic!("Call global handler with args");
-
-    let func = ctx.thread.global_env.repl_lookup_idx(payload_size as usize);
-    ctx.handle_non_instr_global_function_call_lazy_push(func, args)
-}
-
-// OpCode::LOADINT0
-fn handle_load_int0(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.thread.stack.push(SteelVal::INT_ZERO);
-    ctx.ip += 1;
-    Ok(())
-}
-
-// OpCode::LOADINT1
-fn handle_load_int1(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.thread.stack.push(SteelVal::INT_ONE);
-    ctx.ip += 1;
-    Ok(())
-}
-
-// OpCode::LOADINT2
-fn handle_load_int2(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.thread.stack.push(SteelVal::INT_TWO);
-    ctx.ip += 1;
-    Ok(())
-}
-
-// OpCode::MOVEREADLOCAL
-fn move_local_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let index = ctx.instructions[ctx.ip].payload_size;
-    ctx.handle_move_local(index as usize)
-}
-
-// OpCode::MOVEREADLOCAL
-fn move_local_handler_with_payload(ctx: &mut VmCore<'_>, index: usize) -> Result<()> {
-    ctx.handle_move_local(index)
-}
-
-// OpCode::MOVEREADLOCAL0
-fn move_local_handler0(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.handle_move_local(0)
-}
-
-// OpCode::MOVEREADLOCAL1
-fn move_local_handler1(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.handle_move_local(1)
-}
-
-// OpCode::MOVEREADLOCAL2
-fn move_local_handler2(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.handle_move_local(2)
-}
-
-// OpCode::MOVEREADLOCAL3
-fn move_local_handler3(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.handle_move_local(3)
-}
-
-// OpCode::READCAPTURED
-fn read_captured_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    ctx.handle_read_captures(payload_size as usize)
-}
-
-// OpCode::READCAPTURED
-fn read_captured_handler_with_payload(ctx: &mut VmCore<'_>, payload_size: usize) -> Result<()> {
-    ctx.handle_read_captures(payload_size)
-}
-
-// OpCode::BEGINSCOPE
-fn begin_scope_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    ctx.ip += 1;
-    Ok(())
-}
-
-// OpCode::LETENDSCOPE
-fn let_end_scope_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let beginning_scope = ctx.instructions[ctx.ip].payload_size as usize;
-    let_end_scope_handler_with_payload(ctx, beginning_scope)
-}
-
-// OpCode::LETENDSCOPE
-fn let_end_scope_handler_with_payload(ctx: &mut VmCore<'_>, beginning_scope: usize) -> Result<()> {
-    // let offset = ctx.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    let offset = ctx.get_offset();
-    // let offset = ctx.sp;
-
-    // Move to the pop
-    ctx.ip += 1;
-
-    let rollback_index = beginning_scope + offset;
-
-    // let rollback_index = offset;
-
-    // dbg!(beginning_scope, offset);
-    // dbg!(rollback_index);
-    // dbg!(ctx
-    //     .thread
-    //     .stack
-    //     .get(rollback_index..ctx.thread.stack.len() - 1));
-    // dbg!(ctx.thread.stack.len() - 1);
-
-    // dbg!(&ctx.thread.stack);
-
-    let _ = ctx
-        .thread
-        .stack
-        .drain(rollback_index..ctx.thread.stack.len() - 1);
-
-    // dbg!(dropped_locals.collect::<Vec<_>>());
-
-    // let last = ctx.stack.pop().expect("stack empty at pop");
-
-    // ctx.stack.truncate(rollback_index);
-    // ctx.stack.push(last);
-
-    Ok(())
-}
-
-// OpCode::PUREFUNC
-fn pure_function_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size as usize;
-    ctx.handle_pure_function(payload_size);
-    Ok(())
-}
-
-// OpCode::PUREFUNC
-fn pure_function_handler_with_payload(ctx: &mut VmCore<'_>, payload_size: usize) -> Result<()> {
-    ctx.handle_pure_function(payload_size);
-    Ok(())
-}
-
-macro_rules! handler_inline_primitive {
-    ($ctx:expr, $name:tt) => {{
-        let payload_size = $ctx.instructions[$ctx.ip].payload_size as usize;
-        let last_index = $ctx.thread.stack.len() - payload_size as usize;
-
-        let result = match $name(&mut $ctx.thread.stack[last_index..]) {
-            Ok(value) => value,
-            Err(e) => return Err(e.set_span_if_none($ctx.current_span())),
-        };
-
-        // This is the old way... lets see if the below way improves the speed
-        // $ctx.thread.stack.truncate(last_index);
-        // $ctx.thread.stack.push(result);
-
-        $ctx.thread.stack.truncate(last_index + 1);
-        *$ctx.thread.stack.last_mut().unwrap() = result;
-
-        $ctx.ip += 2;
-    }};
-}
-
-macro_rules! handler_inline_primitive_payload {
-    ($ctx:expr, $name:tt, $payload_size: expr) => {{
-        let last_index = $ctx.thread.stack.len() - $payload_size as usize;
-
-        let result = match $name(&mut $ctx.thread.stack[last_index..]) {
-            Ok(value) => value,
-            Err(e) => return Err(e.set_span_if_none($ctx.current_span())),
-        };
-
-        // This is the old way... lets see if the below way improves the speed
-        // $ctx.thread.stack.truncate(last_index);
-        // $ctx.thread.stack.push(result);
-
-        $ctx.thread.stack.truncate(last_index + 1);
-        *$ctx.thread.stack.last_mut().unwrap() = result;
-
-        $ctx.ip += 2;
-    }};
-}
-
-// OpCode::ADD
-fn add_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive!(ctx, add_primitive);
-    Ok(())
-}
-
-fn binop_add_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let last_index = ctx.thread.stack.len() - 2;
-
-    let right = ctx.thread.stack.pop().unwrap();
-    let left = ctx.thread.stack.last().unwrap();
-
-    let result = match add_handler_none_none(left, &right) {
-        Ok(value) => value,
-        Err(e) => return Err(e.set_span_if_none(ctx.current_span())),
-    };
-
-    // let result = match $name(&mut $ctx.thread.stack[last_index..]) {
-    //     Ok(value) => value,
-    //     Err(e) => return Err(e.set_span_if_none($ctx.current_span())),
-    // };
-
-    // This is the old way... lets see if the below way improves the speed
-    // $ctx.thread.stack.truncate(last_index);
-    // $ctx.thread.stack.push(result);
-
-    // self.thread.stack.truncate(last_index + 1);
-    // *self.thread.stack.last_mut().unwrap() = result;
-
-    *ctx.thread.stack.last_mut().unwrap() = result;
-
-    ctx.ip += 2;
-
-    Ok(())
-}
-
-fn cons_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, cons, 2);
-    Ok(())
-}
-
-fn new_box_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    // let last_index = ctx.thread.stack.len() - 1;
-
-    let last = ctx.thread.stack.pop().unwrap();
-
-    let allocated_var = ctx.thread.heap.allocate(
-        last,
-        ctx.thread.stack.iter(),
-        ctx.thread.stack_frames.iter().map(|x| x.function.as_ref()),
-        ctx.thread.global_env.roots(),
-    );
-
-    let result = SteelVal::HeapAllocated(allocated_var);
-
-    // This is the old way... lets see if the below way improves the speed
-    // $ctx.thread.stack.truncate(last_index);
-    // $ctx.thread.stack.push(result);
-
-    // ctx.thread.stack.truncate(last_index + 1);
-    // *ctx.thread.stack.last_mut().unwrap() = result;
-
-    ctx.thread.stack.push(result);
-
-    ctx.ip += 2;
-    Ok(())
-}
-
-fn unbox_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, steel_unbox_mutable, 1);
-    Ok(())
-}
-
-fn setbox_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, steel_set_box_mutable, 2);
-    Ok(())
-}
-
-fn car_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, steel_car, 1);
-    Ok(())
-}
-
-fn cons_handler_no_stack(ctx: &mut VmCore<'_>) -> Result<()> {
-    todo!()
-}
-
-fn list_handler(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, new_list, payload);
-    Ok(())
-}
-
-fn list_handler_no_stack(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    todo!()
-}
-
-// OpCode::ADD
-fn add_handler_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, special_add, payload);
-    Ok(())
-}
-
-// OpCode::SUB
-#[inline(always)]
-fn sub_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive!(ctx, subtract_primitive);
-    Ok(())
-}
-
-// OpCode::SUB
-#[inline(always)]
-fn sub_handler_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, subtract_primitive, payload);
-    Ok(())
-}
-
-// OpCode::MULT
-fn multiply_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive!(ctx, multiply_primitive);
-    Ok(())
-}
-
-// OpCode::MULT
-fn multiply_handler_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, multiply_primitive, payload);
-    Ok(())
-}
-
-// OpCode::DIV
-#[inline(always)]
-fn division_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive!(ctx, divide_primitive);
-    Ok(())
-}
-
-// OpCode::DIV
-fn division_handler_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, divide_primitive, payload);
-    Ok(())
-}
-
-// OpCode::EQUAL
-#[inline(always)]
-fn equality_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive!(ctx, equality_primitive);
-    Ok(())
-}
-
-// OpCode::EQUAL
-fn equality_handler_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, equality_primitive, payload);
-    Ok(())
-}
-
-// OpCode::LTE
-#[inline(always)]
-fn lte_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    handler_inline_primitive!(ctx, lte_primitive);
-    Ok(())
-}
-
-// OpCode::LTE
-fn lte_handler_payload(ctx: &mut VmCore<'_>, payload: usize) -> Result<()> {
-    handler_inline_primitive_payload!(ctx, lte_primitive, payload);
-    Ok(())
-}
-
-// OpCode::ALLOC
-fn alloc_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    // let offset = ctx.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    let offset = ctx.get_offset();
-
-    let allocated_var = ctx.thread.heap.allocate(
-        ctx.thread.stack[offset].clone(), // TODO: Could actually move off of the stack entirely
-        ctx.thread.stack.iter(),
-        ctx.thread.stack_frames.iter().map(|x| x.function.as_ref()),
-        ctx.thread.global_env.roots(),
-    );
-
-    ctx.thread
-        .stack_frames
-        .last_mut()
-        .unwrap()
-        .function
-        .heap_allocated
-        .borrow_mut()
-        .push(allocated_var);
-
-    ctx.ip += 1;
-
-    Ok(())
-}
-
-// OpCode::READALLOC
-#[inline(always)]
-fn read_alloc_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size as usize;
-
-    let value = ctx
-        .thread
-        .stack_frames
-        .last()
-        .unwrap()
-        .function
-        .heap_allocated()
-        .borrow()[payload_size]
-        .get();
-
-    // dbg!(payload_size);
-
-    // dbg!(ctx
-    //     .thread
-    //     .stack_frames
-    //     .last()
-    //     .unwrap()
-    //     .function
-    //     .heap_allocated()
-    //     .borrow()
-    //     .iter()
-    //     .map(|x| x.get())
-    //     .collect::<Vec<_>>());
-
-    // dbg!(&value);
-
-    ctx.thread.stack.push(value);
-    ctx.ip += 1;
-
-    Ok(())
-}
-
-// OpCode::READALLOC
-#[inline(always)]
-fn read_alloc_handler_with_payload(ctx: &mut VmCore<'_>, payload_size: usize) -> Result<()> {
-    let value = ctx
-        .thread
-        .stack_frames
-        .last()
-        .unwrap()
-        .function
-        .heap_allocated()
-        .borrow()[payload_size]
-        .get();
-
-    ctx.thread.stack.push(value);
-    ctx.ip += 1;
-
-    Ok(())
-}
-
-// OpCode::SETALLOC
-#[inline(always)]
-fn set_alloc_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size as usize;
-    let value_to_assign = ctx.thread.stack.pop().unwrap();
-
-    let old_value = ctx
-        .thread
-        .stack_frames
-        .last()
-        .unwrap()
-        .function
-        .heap_allocated()
-        .borrow_mut()[payload_size]
-        .set(value_to_assign);
-
-    ctx.thread.stack.push(old_value);
-    ctx.ip += 1;
-
-    Ok(())
-}
-
-// OpCode::SETALLOC
-#[inline(always)]
-fn set_alloc_handler_with_payload(ctx: &mut VmCore<'_>, payload_size: usize) -> Result<()> {
-    let value_to_assign = ctx.thread.stack.pop().unwrap();
-
-    let old_value = ctx
-        .thread
-        .stack_frames
-        .last()
-        .unwrap()
-        .function
-        .heap_allocated()
-        .borrow_mut()[payload_size]
-        .set(value_to_assign);
-
-    ctx.thread.stack.push(old_value);
-    ctx.ip += 1;
-
-    Ok(())
-}
-
-// OpCode::NEWSCLOSURE
-fn new_sclosure_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size as usize;
-
-    ctx.handle_new_start_closure(payload_size)
-}
-
-// OpCode::NEWSCLOSURE
-fn new_sclosure_handler_with_payload(ctx: &mut VmCore<'_>, payload_size: usize) -> Result<()> {
-    ctx.handle_new_start_closure(payload_size)
-}
-
-#[inline(always)]
-fn jump_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    ctx.ip = payload_size as usize;
-    Ok(())
-}
-
-#[inline(always)]
-fn if_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    // change to truthy...
-    if ctx.thread.stack.pop().unwrap().is_truthy() {
-        ctx.ip += 1;
-    } else {
-        ctx.ip = payload_size as usize;
-    }
-    Ok(())
-}
-
-#[inline(always)]
-fn raw_if_handler(ctx: &mut VmCore<'_>, arg: SteelVal) {
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    // change to truthy...
-    if arg.is_truthy() {
-        ctx.ip += 1;
-    } else {
-        ctx.ip = payload_size as usize;
-    }
-}
-
-#[inline(always)]
-fn if_handler_with_bool(ctx: &mut VmCore<'_>, condition: bool) {
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    // change to truthy...
-    if condition {
-        ctx.ip += 1;
-    } else {
-        ctx.ip = payload_size as usize;
-    }
-}
-
-#[inline(always)]
-fn call_global_tail_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    // assert!(ctx.ip + 1 < ctx.instructions.len());
-
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    // ctx.ip += 1;
-    let next_inst = ctx.instructions[ctx.ip + 1];
-
-    // println!("{:?}, {:?}", payload_size, next_inst.payload_size);
-
-    ctx.handle_tail_call_global(payload_size as usize, next_inst.payload_size as usize)
-
-    // ctx.handle_tail_call_global(payload_size as usize, next_inst.payload_size as usize)
-}
-
-#[inline(always)]
-fn tail_call_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-    let func = ctx.thread.stack.pop().unwrap();
-    ctx.handle_tail_call(func, payload_size as usize)
-}
-
-#[inline(always)]
-fn tco_jump_handler(ctx: &mut VmCore<'_>) -> Result<()> {
-    // println!("At tco jump");
-
-    let payload_size = ctx.instructions[ctx.ip].payload_size;
-
-    let current_arity = payload_size as usize;
-    // This is the number of (local) functions we need to pop to get back to the place we want to be at
-    let depth = ctx.instructions[ctx.ip + 1].payload_size as usize;
-
-    // println!("Depth: {:?}", depth);
-    // println!("Function stack length: {:?}", self.function_stack.len());
-    // println!("Stack index: {:?}", self.stack_index);
-    // println!(
-    //     "Instruction stack length: {:?}",
-    //     self.instruction_stack.len()
-    // );
-
-    // for function in function_stack {
-
-    // }
-
-    // for _ in 0..depth {
-    // println!("Popping");
-    // self.function_stack.pop();
-    // self.stack_index.pop();
-    // ctx.thread.stack_frames.pop();
-    // self.instruction_stack.pop();
-    // ctx.pop_count -= 1;
-    // }
-
-    let last_stack_frame = ctx.thread.stack_frames.last().unwrap();
-
-    ctx.instructions = last_stack_frame.function.body_exp();
-    // ctx.spans = last_stack_frame.function.spans();
-    ctx.sp = last_stack_frame.sp;
-
-    // crate::core::instructions::pretty_print_dense_instructions(&self.instructions);
-
-    // panic!("Stopping");
-
-    ctx.ip = 0;
-
-    let closure_arity = last_stack_frame.function.arity();
-
-    if current_arity != closure_arity {
-        stop!(ArityMismatch => format!("tco: function expected {closure_arity} arguments, found {current_arity}"); ctx.current_span());
-    }
-
-    // HACK COME BACK TO THIS
-    // if self.ip == 0 && self.heap.len() > self.heap.limit() {
-    // TODO collect here
-    // self.heap.collect_garbage();
-    // }
-    // let offset = self.stack_index.last().copied().unwrap_or(0);
-    // let offset = ctx.stack_frames.last().map(|x| x.index).unwrap_or(0);
-    let offset = ctx.sp;
-
-    // We should have arity at this point, drop the stack up to this point
-    // take the last arity off the stack, go back and replace those in order
-    // [... arg1 arg2 arg3]
-    //      ^^^ <- back = this index
-    // offset = the start of the stack frame
-    // Copy the arg1 arg2 arg3 values to
-    // [... frame-start ... arg1 arg2 arg3]
-    //      ^^^^^^~~~~~~~~
-    // let back = ctx.stack.len() - current_arity;
-    // for i in 0..current_arity {
-    //     ctx.stack[offset + i] = ctx.stack[back + i].clone();
-    // }
-
-    // // self.stack.truncate(offset + current_arity);
-    // ctx.stack.truncate(offset + current_arity);
-
-    let back = ctx.thread.stack.len() - current_arity;
-    // for i in 0..current_arity {
-    //     self.stack[offset + i] = self.stack[back + i].clone();
-    // }
-
-    // self.stack.truncate(offset + current_arity);
-
-    let _ = ctx.thread.stack.drain(offset..back);
-
-    Ok(())
-}
-
-// #[inline(always)]
-// fn pop_pure_handler(ctx: &mut VmCore<'_>) ->
-
-// | OpCode::CALLGLOBALTAIL
-// | OpCode::TAILCALL
-// | OpCode::TCOJMP
-// | OpCode::POPPURE
-
-// MUL | SUB | DIV
-
-#[inline(always)]
-fn add_handler_int_int(_: &mut VmCore<'_>, l: isize, r: isize) -> isize {
-    l + r
-}
-
-#[inline(always)]
-fn add_handler_int_float(_: &mut VmCore<'_>, l: isize, r: f64) -> f64 {
-    l as f64 + r
-}
-
-#[inline(always)]
-fn add_handler_float_int(_: &mut VmCore<'_>, l: f64, r: isize) -> f64 {
-    l + r as f64
-}
-
-#[inline(always)]
-fn add_handler_float_float(_: &mut VmCore<'_>, l: f64, r: f64) -> f64 {
-    l + r
-}
-
-#[inline(always)]
-fn sub_handler_int_int(_: &mut VmCore<'_>, l: isize, r: isize) -> isize {
-    l - r
-}
-
-#[inline(always)]
-fn sub_handler_int_none(_: &mut VmCore<'_>, l: isize, r: SteelVal) -> Result<SteelVal> {
-    match r {
-        SteelVal::IntV(n) => Ok(SteelVal::IntV(l - n)),
-        SteelVal::NumV(r) => Ok(SteelVal::NumV(l as f64 - r)),
-        _ => stop!(TypeMismatch => "sub expected a number, found: {}", r),
-    }
-}
-
-#[inline(always)]
-fn sub_handler_none_int(_: &mut VmCore<'_>, l: SteelVal, r: isize) -> Result<SteelVal> {
-    match l {
-        SteelVal::IntV(l) => Ok(SteelVal::IntV(l - r)),
-        SteelVal::NumV(l) => Ok(SteelVal::NumV(l - r as f64)),
-        _ => {
-            cold();
-            stop!(TypeMismatch => "sub expected a number, found: {}", l)
-        }
-    }
-}
-
-#[inline(always)]
-fn sub_handler_int_float(_: &mut VmCore<'_>, l: isize, r: f64) -> f64 {
-    l as f64 - r
-}
-
-#[inline(always)]
-fn sub_handler_float_int(_: &mut VmCore<'_>, l: f64, r: isize) -> f64 {
-    l - r as f64
-}
-
-#[inline(always)]
-fn sub_handler_float_float(_: &mut VmCore<'_>, l: f64, r: f64) -> f64 {
-    l - r
-}
-
-#[inline(always)]
-fn multiply_handler_int_int(_: &mut VmCore<'_>, l: isize, r: isize) -> isize {
-    l * r
-}
-
-#[inline(always)]
-fn multiply_handler_int_float(_: &mut VmCore<'_>, l: isize, r: f64) -> f64 {
-    l as f64 * r
-}
-
-#[inline(always)]
-fn multiply_handler_float_int(_: &mut VmCore<'_>, l: f64, r: isize) -> f64 {
-    l * r as f64
-}
-
-#[inline(always)]
-fn multiply_handler_float_float(_: &mut VmCore<'_>, l: f64, r: f64) -> f64 {
-    l * r
-}
-
-#[inline(always)]
-fn multiply_handler_int_none(_: &mut VmCore<'_>, l: isize, r: SteelVal) -> Result<SteelVal> {
-    match r {
-        SteelVal::NumV(r) => Ok(SteelVal::NumV(l as f64 * r)),
-        SteelVal::IntV(n) => {
-            if let Some(res) = l.checked_mul(n) {
-                Ok(SteelVal::IntV(res))
-            } else {
-                let mut res = num::BigInt::from(l);
-                res *= n;
-                Ok(SteelVal::BigNum(Gc::new(res)))
-            }
-        }
-        _ => stop!(TypeMismatch => "multiply expected an number, found: {}", r),
-    }
-}
-
-#[inline(always)]
-fn div_handler_int_int(_: &mut VmCore<'_>, l: isize, r: isize) -> isize {
-    l / r
-}
-
-#[inline(always)]
-fn div_handler_int_float(_: &mut VmCore<'_>, l: isize, r: f64) -> f64 {
-    l as f64 / r
-}
-
-#[inline(always)]
-fn div_handler_float_int(_: &mut VmCore<'_>, l: f64, r: isize) -> f64 {
-    l / r as f64
-}
-
-#[inline(always)]
-fn div_handler_float_float(_: &mut VmCore<'_>, l: f64, r: f64) -> f64 {
-    l / r
-}
-
-#[inline(always)]
-fn lte_handler_none_int(_: &mut VmCore<'_>, l: SteelVal, r: isize) -> Result<bool> {
-    match l {
-        SteelVal::IntV(l) => Ok(l <= r),
-        SteelVal::NumV(l) => Ok(l <= r as f64),
-        _ => stop!(TypeMismatch => "lte expected an number, found: {}", r),
-    }
-}
-
-#[inline(always)]
-fn add_handler_none_none(l: &SteelVal, r: &SteelVal) -> Result<SteelVal> {
-    match (l, r) {
-        (SteelVal::IntV(l), SteelVal::IntV(r)) => {
-            if let Some(res) = l.checked_add(*r) {
-                Ok(SteelVal::IntV(res))
-            } else {
-                let mut big = num::BigInt::default();
-
-                big += *l;
-                big += *r;
-
-                big.into_steelval()
-            }
-        }
-        (SteelVal::IntV(l), SteelVal::NumV(r)) => Ok(SteelVal::NumV(*l as f64 + r)),
-        (SteelVal::NumV(l), SteelVal::IntV(r)) => Ok(SteelVal::NumV(l + *r as f64)),
-        (SteelVal::NumV(l), SteelVal::NumV(r)) => Ok(SteelVal::NumV(l + r)),
-
-        (SteelVal::BigNum(l), SteelVal::BigNum(r)) => (l.as_ref() + r.as_ref()).into_steelval(),
-
-        (SteelVal::IntV(l), SteelVal::BigNum(r)) => (r.as_ref() + *l).into_steelval(),
-
-        (SteelVal::BigNum(l), SteelVal::IntV(r)) => (l.as_ref() + *r).into_steelval(),
-
-        (SteelVal::NumV(l), SteelVal::BigNum(r)) => Ok(SteelVal::NumV(r.to_f64().unwrap() + *l)),
-        (SteelVal::BigNum(l), SteelVal::NumV(r)) => Ok(SteelVal::NumV(l.to_f64().unwrap() + *r)),
-
-        _ => stop!(TypeMismatch => "+ expected two numbers, found: {} and {}", l, r),
-    }
-}
-
-#[cfg(feature = "dynamic")]
-pub(crate) use dynamic::pattern_exists;
-
-#[macro_use]
-#[cfg(feature = "dynamic")]
-mod dynamic {
-    use super::*;
-
-    #[macro_export]
-    macro_rules! binop_opcode_to_ssa_handler {
-        (ADD2, Int, Int) => {
-            add_handler_int_int
-        };
-
-        (ADD2, Int, Float) => {
-            add_handler_int_float
-        };
-
-        (ADD2, Float, Int) => {
-            add_handler_int_float
-        };
-
-        (ADD2, Float, Float) => {
-            add_handler_float_float
-        };
-
-        (MUL2, Int, Int) => {
-            multiply_handler_int_int
-        };
-
-        (MUL2, Int, Float) => {
-            multiply_handler_int_float
-        };
-
-        (MUL2, Float, Int) => {
-            multiply_handler_int_float
-        };
-
-        (MUL2, Float, Float) => {
-            multiply_handler_float_float
-        };
-
-        (SUB2, Int, Int) => {
-            sub_handler_int_int
-        };
-
-        (SUB2, Int, None) => {
-            sub_handler_int_none
-        };
-
-        (SUB2, None, Int) => {
-            sub_handler_none_int
-        };
-
-        (SUB2, Int, Float) => {
-            sub_handler_int_float
-        };
-
-        (SUB2, Float, Int) => {
-            sub_handler_float_int
-        };
-
-        (SUB2, Float, Float) => {
-            sub_handler_float_float
-        };
-
-        (DIV2, Int, Int) => {
-            div_handler_int_int
-        };
-
-        (DIV2, Int, Float) => {
-            div_handler_int_float
-        };
-
-        (DIV2, Float, Int) => {
-            div_handler_float_int
-        };
-
-        (DIV2, Float, Float) => {
-            div_handler_float_float
-        };
-
-        (LTE2, None, Int) => {
-            lte_handler_none_int
-        };
-    }
-
-    macro_rules! if_to_ssa_handler {
-        (IF, Bool) => {
-            if_handler_with_bool
-        };
-        (IF) => {
-            raw_if_handler
-        };
-    }
-
-    macro_rules! opcode_to_ssa_handler {
-        (CALLGLOBAL) => {
-            call_global_handler_no_stack
-        };
-
-        (CALLGLOBAL, Tail) => {
-            call_global_handler_with_args
-        };
-
-        (PUSHCONST) => {
-            push_const_handler_no_stack
-        };
-
-        (MOVEREADLOCAL0) => {
-            handle_move_local_0_no_stack
-        };
-
-        (MOVEREADLOCAL1) => {
-            handle_move_local_1_no_stack
-        };
-
-        (READLOCAL0) => {
-            handle_local_0_no_stack
-        };
-
-        (READLOCAL1) => {
-            handle_local_1_no_stack
-        };
-    }
-
-    // Includes the module as a dependency, that being said - this should
-    // probably get generated into some specific sub module directly?
-    include!(concat!(env!("OUT_DIR"), "/dynamic.rs"));
-}
diff --git a/crates/steel-core/src/steel_vm/vm/threads.rs b/crates/steel-core/src/steel_vm/vm/threads.rs
deleted file mode 100644
index 74d6b0074..000000000
--- a/crates/steel-core/src/steel_vm/vm/threads.rs
+++ /dev/null
@@ -1,534 +0,0 @@
-use std::collections::HashSet;
-
-use fxhash::FxHashMap;
-
-use crate::{
-    rvals::{Custom, HeapSerializer, SerializableSteelVal, SerializedHeapRef},
-    steel_vm::{builtin::BuiltInModule, register_fn::RegisterFn},
-    values::{functions::SerializedLambdaPrototype, structs::VTable},
-};
-
-use super::*;
-
-// TODO: Do proper logging here for thread spawning
-macro_rules! time {
-    ($label:expr, $e:expr) => {{
-        let now = std::time::Instant::now();
-
-        let e = $e;
-
-        log::debug!(target: "threads", "{}: {:?}", $label, now.elapsed());
-
-        e
-    }};
-}
-
-pub struct ThreadHandle {
-    // If this can hold a native steelerr object that would be nice
-    handle: Option<std::thread::JoinHandle<std::result::Result<(), String>>>,
-}
-
-impl ThreadHandle {
-    pub fn is_finished(&self) -> bool {
-        self.handle
-            .as_ref()
-            .map(|x| x.is_finished())
-            .unwrap_or(true)
-    }
-}
-
-impl crate::rvals::Custom for ThreadHandle {}
-
-pub(crate) fn thread_join(handle: &mut ThreadHandle) -> Result<()> {
-    if let Some(handle) = handle.handle.take() {
-        handle
-            .join()
-            .map_err(|_| SteelErr::new(ErrorKind::Generic, "thread panicked!".to_string()))?
-            .map_err(|x| SteelErr::new(ErrorKind::Generic, x.to_string()))
-    } else {
-        stop!(ContractViolation => "thread handle has already been joined!");
-    }
-}
-
-thread_local! {
-    static CACHED_CLOSURES: RefCell<FxHashMap<usize, SerializedLambdaPrototype>> = RefCell::new(FxHashMap::default());
-}
-
-pub fn closure_into_serializable(
-    c: &ByteCodeLambda,
-    serializer: &mut std::collections::HashMap<usize, SerializableSteelVal>,
-    visited: &mut std::collections::HashSet<usize>,
-) -> Result<SerializedLambda> {
-    if let Some(mut prototype) = CACHED_CLOSURES.with(|x| x.borrow().get(&c.id).cloned()) {
-        let mut prototype = SerializedLambda {
-            id: prototype.id,
-            body_exp: prototype.body_exp,
-            arity: prototype.arity,
-            is_multi_arity: prototype.is_multi_arity,
-            captures: Vec::new(),
-        };
-
-        prototype.captures = c
-            .captures
-            .iter()
-            .cloned()
-            .map(|x| into_serializable_value(x, serializer, visited))
-            .collect::<Result<_>>()?;
-
-        Ok(prototype)
-    } else {
-        let mut prototype = SerializedLambdaPrototype {
-            id: c.id,
-
-            #[cfg(not(feature = "dynamic"))]
-            body_exp: c.body_exp.into_iter().cloned().collect(),
-
-            #[cfg(feature = "dynamic")]
-            body_exp: c.body_exp.borrow().iter().cloned().collect(),
-
-            arity: c.arity,
-            is_multi_arity: c.is_multi_arity,
-        };
-
-        CACHED_CLOSURES.with(|x| x.borrow_mut().insert(c.id, prototype.clone()));
-
-        let mut prototype = SerializedLambda {
-            id: prototype.id,
-            body_exp: prototype.body_exp,
-            arity: prototype.arity,
-            is_multi_arity: prototype.is_multi_arity,
-            captures: Vec::new(),
-        };
-
-        prototype.captures = c
-            .captures
-            .iter()
-            .cloned()
-            .map(|x| into_serializable_value(x, serializer, visited))
-            .collect::<Result<_>>()?;
-
-        Ok(prototype)
-    }
-}
-
-/// This will naively deep clone the environment, by attempting to translate every value into a `SerializableSteelVal`
-/// While this does work, it does result in a fairly hefty deep clone of the environment. It does _not_ smartly attempt
-/// to keep track of what values this function could touch - rather it assumes every value is possible to be touched
-/// by the child thread. In addition - closures which capture mutable variables are unable to be moved across threads.
-/// Only pure functions and/or functions which capture immutable can be moved.
-fn spawn_thread_result(ctx: &mut VmCore, args: &[SteelVal]) -> Result<SteelVal> {
-    use crate::rvals::SerializableSteelVal;
-
-    let now = std::time::Instant::now();
-
-    // Need a new:
-    // Stack
-    // Heap
-    // global env - This we can do (hopefully) lazily. Only clone the values that actually
-    // get referenced. We can also just straight up reject any closures that cannot be moved
-    // across threads
-    struct MovableThread {
-        constants: Vec<SerializableSteelVal>,
-        global_env: Vec<SerializableSteelVal>,
-        function_interner: MovableFunctionInterner,
-        runtime_options: RunTimeOptions,
-    }
-
-    struct MovableFunctionInterner {
-        closure_interner: fxhash::FxHashMap<usize, SerializedLambda>,
-        pure_function_interner: fxhash::FxHashMap<usize, SerializedLambda>,
-        spans: fxhash::FxHashMap<usize, Vec<Span>>,
-        instructions: fxhash::FxHashMap<usize, Vec<DenseInstruction>>,
-    }
-
-    if args.len() != 1 {
-        stop!(ArityMismatch => "spawn-thread! accepts one argument, found: {}", args.len())
-    }
-
-    let mut initial_map = HashMap::new();
-    let mut visited = HashSet::new();
-
-    // If it is a native function, theres no reason we can't just call it on a new thread, most likely.
-    // There might be some funny business with thread local values, but for now we'll just accept it.
-    let function: SerializedLambda = match &args[0] {
-        SteelVal::FuncV(f) => {
-            let func = *f;
-
-            let handle =
-                std::thread::spawn(move || func(&[]).map(|_| ()).map_err(|e| e.to_string()));
-
-            return ThreadHandle {
-                handle: Some(handle),
-            }
-            .into_steelval();
-
-            // todo!()
-        }
-        SteelVal::MutFunc(f) => {
-            let func = *f;
-
-            let handle =
-                std::thread::spawn(move || func(&mut []).map(|_| ()).map_err(|e| e.to_string()));
-
-            return ThreadHandle {
-                handle: Some(handle),
-            }
-            .into_steelval();
-        }
-
-        // Probably rename unwrap to something else
-        SteelVal::Closure(f) => closure_into_serializable(&f, &mut initial_map, &mut visited)?,
-        illegal => {
-            stop!(TypeMismatch => "Cannot spawn value on another thread: {}", illegal);
-        }
-    };
-
-    let constants = time!("Constant map serialization", {
-        let constants = ctx
-            .thread
-            .constant_map
-            .to_serializable_vec(&mut initial_map, &mut visited);
-
-        constants
-    });
-
-    let thread = MovableThread {
-        constants,
-
-        // Void in this case, is a poisoned value. We need to trace the closure
-        // (and all of its references) - to find any / all globals that _could_ be
-        // referenced.
-        global_env: time!(
-            "Global env serialization",
-            ctx.thread
-                .global_env
-                .bindings_vec
-                .iter()
-                .cloned()
-                .map(|x| into_serializable_value(x, &mut initial_map, &mut visited))
-                .map(|x| x.unwrap_or(SerializableSteelVal::Void))
-                .collect()
-        ),
-        // Populate with the values after moving into the thread, spawn accordingly
-        // TODO: Move this out of here
-        function_interner: time!(
-            "Function interner serialization",
-            MovableFunctionInterner {
-                closure_interner: ctx
-                    .thread
-                    .function_interner
-                    .closure_interner
-                    .iter()
-                    .map(|(k, v)| {
-                        let v_prime: SerializedLambda =
-                            closure_into_serializable(v, &mut initial_map, &mut visited)
-                                .expect("This shouldn't fail!");
-                        (*k, v_prime)
-                    })
-                    .collect(),
-                pure_function_interner: ctx
-                    .thread
-                    .function_interner
-                    .pure_function_interner
-                    .iter()
-                    .map(|(k, v)| {
-                        let v_prime: SerializedLambda =
-                            closure_into_serializable(v, &mut initial_map, &mut visited)
-                                .expect("This shouldn't fail!");
-                        (*k, v_prime)
-                    })
-                    .collect(),
-                spans: ctx
-                    .thread
-                    .function_interner
-                    .spans
-                    .iter()
-                    .map(|(k, v)| (*k, v.iter().copied().collect()))
-                    .collect(),
-                instructions: ctx
-                    .thread
-                    .function_interner
-                    .instructions
-                    .iter()
-                    .map(|(k, v)| (*k, v.iter().copied().collect()))
-                    .collect(),
-            }
-        ),
-
-        runtime_options: ctx.thread.runtime_options.clone(),
-    };
-
-    let sendable_vtable_entries = VTable::sendable_entries(&mut initial_map, &mut visited)?;
-
-    // TODO: Spawn a bunch of threads at the start to handle requests. That way we don't need to do this
-    // the whole time they're in there.
-    let handle = std::thread::spawn(move || {
-        let mut heap = time!("Heap Creation", Heap::new());
-
-        // Move across threads?
-        let mut mapping = initial_map
-            .into_iter()
-            .map(|(key, value)| (key, SerializedHeapRef::Serialized(Some(value))))
-            .collect();
-
-        let mut patcher = HashMap::new();
-        let mut built_functions = HashMap::new();
-
-        let mut serializer = HeapSerializer {
-            heap: &mut heap,
-            fake_heap: &mut mapping,
-            values_to_fill_in: &mut patcher,
-            built_functions: &mut built_functions,
-        };
-
-        // Moved over the thread. We now have
-        let closure: ByteCodeLambda = ByteCodeLambda::from_serialized(&mut serializer, function);
-
-        VTable::initialize_new_thread(sendable_vtable_entries, &mut serializer);
-
-        let constant_map = time!(
-            "Constant map deserialization",
-            ConstantMap::from_vec(
-                thread
-                    .constants
-                    .into_iter()
-                    .map(|x| from_serializable_value(&mut serializer, x))
-                    .collect(),
-            )
-        );
-
-        let global_env = time!(
-            "Global env creation",
-            Env {
-                bindings_vec: thread
-                    .global_env
-                    .into_iter()
-                    .map(|x| from_serializable_value(&mut serializer, x))
-                    .collect(),
-            }
-        );
-
-        let function_interner = time!(
-            "Function interner time",
-            FunctionInterner {
-                closure_interner: thread
-                    .function_interner
-                    .closure_interner
-                    .into_iter()
-                    .map(|(k, v)| (k, ByteCodeLambda::from_serialized(&mut serializer, v)))
-                    .collect(),
-                pure_function_interner: thread
-                    .function_interner
-                    .pure_function_interner
-                    .into_iter()
-                    .map(|(k, v)| (
-                        k,
-                        if let Some(exists) = serializer.built_functions.get(&v.id) {
-                            exists.clone()
-                        } else {
-                            Gc::new(ByteCodeLambda::from_serialized(&mut serializer, v))
-                        }
-                    ))
-                    .collect(),
-                spans: thread
-                    .function_interner
-                    .spans
-                    .into_iter()
-                    .map(|(k, v)| (k, v.into()))
-                    .collect(),
-                instructions: thread
-                    .function_interner
-                    .instructions
-                    .into_iter()
-                    .map(|(k, v)| (k, v.into()))
-                    .collect(),
-            }
-        );
-
-        // Patch over the values in the final heap!
-
-        time!("Patching over heap values", {
-            for (key, value) in serializer.values_to_fill_in {
-                if let Some(cycled) = serializer.fake_heap.get(key) {
-                    match cycled {
-                        SerializedHeapRef::Serialized(_) => todo!(),
-                        // Patch over the cycle
-                        SerializedHeapRef::Closed(c) => {
-                            value.set(c.get());
-                        }
-                    }
-                } else {
-                    todo!()
-                }
-            }
-        });
-
-        // New thread! It will result in a run time error if the function references globals that cannot be shared
-        // between threads. This is a bit of an unfortunate occurrence - we probably _should_ just have the engine share
-        // as much as possible between threads.
-        let mut thread = SteelThread {
-            global_env,
-            stack: Vec::with_capacity(64),
-            profiler: OpCodeOccurenceProfiler::new(),
-            function_interner,
-            super_instructions: Vec::new(),
-            heap,
-            runtime_options: thread.runtime_options,
-            current_frame: StackFrame::main(),
-            stack_frames: Vec::with_capacity(32),
-            constant_map,
-        };
-
-        log::info!(target: "threads", "Time taken to spawn thread: {:?}", now.elapsed());
-
-        // Call the function!
-        thread
-            .call_function(
-                thread.constant_map.clone(),
-                SteelVal::Closure(Gc::new(closure)),
-                Vec::new(),
-            )
-            .map(|_| ())
-            .map_err(|e| e.to_string())
-    });
-
-    return ThreadHandle {
-        handle: Some(handle),
-    }
-    .into_steelval();
-}
-
-// Use internal spawn_thread function
-pub(crate) fn spawn_thread(ctx: &mut VmCore, args: &[SteelVal]) -> Option<Result<SteelVal>> {
-    Some(spawn_thread_result(ctx, args))
-}
-
-// Move values back and forth across threads!
-impl Custom for std::sync::mpsc::Sender<SerializableSteelVal> {
-    fn into_serializable_steelval(&mut self) -> Option<SerializableSteelVal> {
-        Some(SerializableSteelVal::Custom(Box::new(self.clone())))
-    }
-}
-
-struct SReceiver {
-    receiver: Option<std::sync::mpsc::Receiver<SerializableSteelVal>>,
-}
-
-impl Custom for SReceiver {
-    fn into_serializable_steelval(&mut self) -> Option<SerializableSteelVal> {
-        let inner = self.receiver.take();
-
-        let new_channel = SReceiver { receiver: inner };
-
-        Some(SerializableSteelVal::Custom(Box::new(new_channel)))
-    }
-}
-
-impl Custom for std::thread::ThreadId {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("#<{:?}>", self)))
-    }
-}
-
-// TODO: Document these
-pub fn threading_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/threads");
-
-    module
-        .register_value(
-            "spawn-thread!",
-            SteelVal::BuiltIn(crate::steel_vm::vm::spawn_thread),
-        )
-        .register_fn("thread-join!", crate::steel_vm::vm::thread_join)
-        .register_fn("thread-finished?", ThreadHandle::is_finished)
-        .register_fn("make-channels", || {
-            let (left, right) = std::sync::mpsc::channel::<SerializableSteelVal>();
-
-            crate::list![
-                left,
-                SReceiver {
-                    receiver: Some(right)
-                }
-            ]
-        })
-        .register_fn(
-            "channel->send",
-            |channel: &std::sync::mpsc::Sender<SerializableSteelVal>,
-             val: SteelVal|
-             -> Result<()> {
-                let mut map = HashMap::new();
-                let mut visited = HashSet::new();
-
-                // TODO: Handle this here somehow, we don't want to use an empty map
-                let serializable =
-                    crate::rvals::into_serializable_value(val, &mut map, &mut visited)?;
-
-                if !map.is_empty() {
-                    stop!(Generic => "Unable to send mutable variable over a channel");
-                }
-
-                channel
-                    .send(serializable)
-                    .map_err(|e| SteelErr::new(ErrorKind::Generic, e.to_string()))
-            },
-        )
-        // TODO: These need to be fucntions that take the context
-        .register_fn("channel->recv", |channel: &SReceiver| -> Result<SteelVal> {
-            let receiver = channel
-                .receiver
-                .as_ref()
-                .expect("Channel should not be dropped here!");
-
-            let value = receiver
-                .recv()
-                .map_err(|e| SteelErr::new(ErrorKind::Generic, e.to_string()))?;
-
-            let mut heap = Heap::new_empty();
-            let mut fake_heap = HashMap::new();
-            let mut patcher = HashMap::new();
-            let mut built_functions = HashMap::new();
-            let mut serializer = HeapSerializer {
-                heap: &mut heap,
-                fake_heap: &mut fake_heap,
-                values_to_fill_in: &mut patcher,
-                built_functions: &mut built_functions,
-            };
-
-            let value = crate::rvals::from_serializable_value(&mut serializer, value);
-
-            Ok(value)
-        })
-        .register_fn(
-            "channel->try-recv",
-            |channel: &SReceiver| -> Result<Option<SteelVal>> {
-                let receiver = channel
-                    .receiver
-                    .as_ref()
-                    .expect("Channel should not be dropped here!");
-
-                let value = receiver.try_recv();
-
-                let mut heap = Heap::new_empty();
-                let mut fake_heap = HashMap::new();
-                let mut patcher = HashMap::new();
-                let mut built_functions = HashMap::new();
-                let mut serializer = HeapSerializer {
-                    heap: &mut heap,
-                    fake_heap: &mut fake_heap,
-                    values_to_fill_in: &mut patcher,
-                    built_functions: &mut built_functions,
-                };
-
-                match value {
-                    Ok(v) => Ok(Some(crate::rvals::from_serializable_value(
-                        &mut serializer,
-                        v,
-                    ))),
-                    Err(std::sync::mpsc::TryRecvError::Empty) => Ok(None),
-                    Err(e) => Err(SteelErr::new(ErrorKind::Generic, e.to_string())),
-                }
-            },
-        )
-        .register_fn("thread::current/id", || std::thread::current().id());
-    module
-}
diff --git a/crates/steel-core/src/tests/failure/capped_depth_defmacro.scm b/crates/steel-core/src/tests/failure/capped_depth_defmacro.scm
deleted file mode 100644
index 74c38b0fa..000000000
--- a/crates/steel-core/src/tests/failure/capped_depth_defmacro.scm
+++ /dev/null
@@ -1,4 +0,0 @@
-;; Should stop before we get a stack overflow
-(defmacro (foo x) x)
-
-(foo (define bar 10))
diff --git a/crates/steel-core/src/tests/failure/function_used_before_definition.scm b/crates/steel-core/src/tests/failure/function_used_before_definition.scm
deleted file mode 100644
index 3f8cfb027..000000000
--- a/crates/steel-core/src/tests/failure/function_used_before_definition.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(foo 1 2 3)
-(define (foo x y z)
-    (+ x y z n m))
-
-(define m 10)
-(define n 20)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/failure/global_env.scm b/crates/steel-core/src/tests/failure/global_env.scm
deleted file mode 100644
index be8db4f3d..000000000
--- a/crates/steel-core/src/tests/failure/global_env.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-(define (foo x)
-  (#%black-box)
-  (list x 20 30 40))
-
-(define list (void))
-
-(foo 10)
diff --git a/crates/steel-core/src/tests/failure/identifier_used_before_definition.scm b/crates/steel-core/src/tests/failure/identifier_used_before_definition.scm
deleted file mode 100644
index 12bd7f7fe..000000000
--- a/crates/steel-core/src/tests/failure/identifier_used_before_definition.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-(define n 10)
-(range n m)
-(define m 20)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/failure/local_struct_inaccessible.scm b/crates/steel-core/src/tests/failure/local_struct_inaccessible.scm
deleted file mode 100644
index 658646fc5..000000000
--- a/crates/steel-core/src/tests/failure/local_struct_inaccessible.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define (foo)
-    (struct Applesauce (a b c))
-    (Applesauce 1 2 3))
-
-(Applesauce 1 2 3)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/failure/require_only_in_missing_identifier.scm b/crates/steel-core/src/tests/failure/require_only_in_missing_identifier.scm
deleted file mode 100644
index dcaaf7663..000000000
--- a/crates/steel-core/src/tests/failure/require_only_in_missing_identifier.scm
+++ /dev/null
@@ -1,8 +0,0 @@
-(require (only-in "steel/result" map-ok Ok Err))
-
-(define my-result (Ok 10))
-
-(assert! (equal? (map-ok my-result (lambda (x) (+ x 10))) (Ok 20)))
-(assert! (equal? (map-ok (Err 10) (lambda (x) (+ x 10))) (Err 10)))
-
-(assert! (equal? (unwrap-ok my-result) 10))
diff --git a/crates/steel-core/src/tests/mod.rs b/crates/steel-core/src/tests/mod.rs
deleted file mode 100644
index 21dc30a1f..000000000
--- a/crates/steel-core/src/tests/mod.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use crate::steel_vm::engine::Engine;
-
-fn generate_asserting_machine() -> Engine {
-    let vm = Engine::new();
-    vm
-}
-
-pub(crate) fn assert_script<T: AsRef<str>>(script: T) {
-    let mut vm = generate_asserting_machine();
-    assert!(vm.compile_and_run_raw_program(script.as_ref()).is_ok());
-}
-
-pub(crate) fn assert_script_error<T: AsRef<str>>(script: T) {
-    let mut vm = generate_asserting_machine();
-    assert!(vm.compile_and_run_raw_program(script.as_ref()).is_err());
-}
-
-macro_rules! test_harness_success {
-    ($($file_name:ident),* $(,)?) => {
-        #[cfg(test)]
-        mod integration_success {
-            use super::*;
-            $(
-                #[test]
-                fn $file_name() {
-                    let script = include_str!(concat!("success/", stringify!($file_name), ".scm"));
-                    assert_script(script);
-                }
-            )*
-        }
-    };
-}
-
-macro_rules! test_harness_failure {
-    ($($file_name:ident),* $(,)?) => {
-        #[cfg(test)]
-        mod integration_failure {
-            use super::*;
-            $(
-                #[test]
-                fn $file_name() {
-                    let script = include_str!(concat!("failure/", stringify!($file_name), ".scm"));
-                    assert_script_error(script);
-                }
-            )*
-        }
-    };
-}
-
-test_harness_success! {
-    abc_problem,
-    apply_more_complex,
-    babbage_problem,
-    balanced_brackets,
-    basic_apply,
-    bignum,
-    calculator,
-    capture_upvalue,
-    capture_upvalues_arity_two,
-    close_upvalue,
-    closure_value_capture,
-    comma_quibbling,
-    complex_lets,
-    defmacro,
-    delim_control,
-    delim_control_n,
-    define_normal,
-    dfs,
-    dll,
-    empty,
-    ellipses,
-    fib,
-    generator,
-    generic_execution_dropping,
-    generic_execution_output_different_type,
-    generic_execution,
-    generic_transducer_with_different_functions,
-    generic_transducer,
-    heap_sort,
-    help,
-    html_table,
-    list_functions,
-    letrec_mutual_recursion,
-    letrec_simple_recursion,
-    local_struct,
-    matcher,
-    maxsubseq,
-    merge_sort,
-    numbers,
-    ncsubseq,
-    pascals,
-    permutations,
-    quicksort,
-    read,
-    require_alias,
-    require_only_in,
-    require_prefix,
-    result,
-    search,
-    set_local,
-    set_tail_call,
-    shift_reset,
-    sicp_example,
-    sieve,
-    simple_stream_with_map,
-    simple_stream_with_mapping,
-    simple_stream_with_transduce_operation,
-    simple_stream_with_transducer,
-    simple_stream,
-    stack_state,
-    stack_struct,
-    stack_test_with_contract,
-    string_append,
-    structs,
-    // TODO: @Matt 11/11/2023
-    threads,
-    transducer_over_streams,
-    tree_traversal,
-    trie_sort,
-    y_combinator,
-}
-
-test_harness_failure! {
-    capped_depth_defmacro,
-    function_used_before_definition,
-    identifier_used_before_definition,
-    local_struct_inaccessible,
-    global_env,
-    require_only_in_missing_identifier,
-}
diff --git a/crates/steel-core/src/tests/success/abc_problem.scm b/crates/steel-core/src/tests/success/abc_problem.scm
deleted file mode 100644
index b4f8e6879..000000000
--- a/crates/steel-core/src/tests/success/abc_problem.scm
+++ /dev/null
@@ -1,56 +0,0 @@
-(define *blocks*
-  '((#\B #\O) (#\X #\K) (#\D #\Q) (#\C #\P) (#\N #\A)
-    (#\G #\T) (#\R #\E) (#\T #\G) (#\Q #\D) (#\F #\S)
-    (#\J #\W) (#\H #\U) (#\V #\I) (#\A #\N) (#\O #\B)
-    (#\E #\R) (#\F #\S) (#\L #\Y) (#\P #\C) (#\Z #\M)))
-
-(define (exists p? li)
-  (and (not (null? li))
-       (or (p? (car li))
-           (exists p? (cdr li)))))
-
-(define (remove-one x li)
-  (cond
-    ((null? li) '())
-    ((equal? (car li) x) (cdr li))
-    (else (cons (car li) (remove-one x (cdr li))))))
-
-(define (can-make-list? li blocks)
-  (or (null? li)
-      (exists
-       (lambda (block)
-         (and
-          (member (char-upcase (car li)) block)
-          (can-make-list? (cdr li) (remove-one block blocks))))
-       blocks)))
-
-(define (can-make-word? word)
-  (can-make-list? (string->list word) *blocks*))
- 
- 
-(define *words*
-  '("A" "Bark" "book" "TrEaT" "COMMON" "squaD" "CONFUSE"))
-
-(define can-make-words
-    '("A" "Bark" "TrEaT" "squaD" "CONFUSE"))
-
-(assert! (equal? (filter can-make-word? *words*)))
-
-; (define (for-each func lst)
-;     (if (null? lst) 
-;         void
-;         (begin
-;             (func (car lst))
-;             (if (null? lst)
-;                 void
-;                 (for-each func (cdr lst))))))
-
-
-; (for-each
-;  (lambda (word)
-;    (display (if (can-make-word? word)
-;                 "   Can make word: "
-;                 "Cannot make word: "))
-;    (display word)
-;    (newline))
-;  *words*)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/apply_more_complex.scm b/crates/steel-core/src/tests/success/apply_more_complex.scm
deleted file mode 100644
index c712a0b8b..000000000
--- a/crates/steel-core/src/tests/success/apply_more_complex.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-;; TODO this should get fixed when lists are fully implemented using the new backing
-(define result (apply map (list (lambda (x) 10) (list 1 2 3 4))))
-(assert! (equal? result (list 10 10 10 10)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/babbage_problem.scm b/crates/steel-core/src/tests/success/babbage_problem.scm
deleted file mode 100644
index efdc12c69..000000000
--- a/crates/steel-core/src/tests/success/babbage_problem.scm
+++ /dev/null
@@ -1,24 +0,0 @@
-(define (digits n)
-  (string->list (int->string n)))
-
-(define (ends-with list tail)
-  ;; does list end with tail?
-  (starts-with (reverse list)
-               (reverse tail)))
-
-(define (starts-with list head)
-  (cond ((null? head)
-         #t)
-        ((null? list)
-         #f)
-        ((equal? (car list) (car head))
-         (starts-with (cdr list) (cdr head)))
-        (else
-         #f)))
-
-(define (babbage i)
-  (if (ends-with (digits (* i i)) (digits 269696))
-      i
-      (babbage (+ i 1))))
-
-(assert! (equal? 25264 (babbage 1)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/balanced_brackets.scm b/crates/steel-core/src/tests/success/balanced_brackets.scm
deleted file mode 100644
index f7d2d52fe..000000000
--- a/crates/steel-core/src/tests/success/balanced_brackets.scm
+++ /dev/null
@@ -1,20 +0,0 @@
-(define (balanced-brackets string)
-  (define (b chars sum)
-    (cond
-      [(< sum 0) #f]
-      [(and (null? chars) (= 0 sum)) #t]
-      [(null? chars) #f]
-      [(equal? #\[ (car chars)) (b (cdr chars) (+ sum 1))]
-      [(equal? #\] (car chars)) (b (cdr chars) (- sum 1))]
-      [else #f]))
-  (b (string->list string) 0))
-
-(assert! (balanced-brackets ""))
-
-(assert! (balanced-brackets "[]"))
-(assert! (balanced-brackets "[][]"))
-(assert! (balanced-brackets "[[][]]"))
-
-(assert! (not (balanced-brackets "][")))
-(assert! (not (balanced-brackets "][][")))
-(assert! (not (balanced-brackets "[]][[]")))
diff --git a/crates/steel-core/src/tests/success/basic_apply.scm b/crates/steel-core/src/tests/success/basic_apply.scm
deleted file mode 100644
index e185ef98a..000000000
--- a/crates/steel-core/src/tests/success/basic_apply.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-;; TODO this should get fixed when lists are implemented using the new backing
-(define result (apply + (list 1 2 3 4)))
-(assert! (equal? 10 result))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/bignum.scm b/crates/steel-core/src/tests/success/bignum.scm
deleted file mode 100644
index dd696aeb6..000000000
--- a/crates/steel-core/src/tests/success/bignum.scm
+++ /dev/null
@@ -1,16 +0,0 @@
-;; Basic addition of bigints
-(assert! (equal? (+ 9223372036854775808) 9223372036854775808))
-
-(assert! (equal? (+ 9223372036854775808 9223372036854775808) 18446744073709551616))
-
-(assert! (equal? (+ 9223372036854775808 9223372036854775808 9223372036854775808)
-                 27670116110564327424))
-
-;; Promotion from int -> bignum, one over int max
-(assert! (equal? (+ 1 9223372036854775807) 9223372036854775808))
-
-;; Promotion from int -> bignum, with multiplication
-(assert! (equal? (* 2 9223372036854775807) 18446744073709551614))
-
-(assert! (equal? (- -1) 1))
-(assert! (equal? (- -9223372036854775808) 9223372036854775808))
diff --git a/crates/steel-core/src/tests/success/binary_search.scm b/crates/steel-core/src/tests/success/binary_search.scm
deleted file mode 100644
index f0334aac2..000000000
--- a/crates/steel-core/src/tests/success/binary_search.scm
+++ /dev/null
@@ -1,16 +0,0 @@
-(define (binary-search value vector)
-  (define (helper low high)
-      (if (< high low)
-        #f
-        (let ((middle (quotient (+ low high) 2)))
-          (cond ((> (vector-ref vector middle) value)
-                 (helper low (- middle 1)))
-                ((< (vector-ref vector middle) value)
-                 (helper (+ middle 1) high))
-                (else middle)))))
-
-  (helper 0 (- (vector-length vector) 1)))
-
-
-(assert! (equal? 4 (binary-search 6 (vector 1 3 4 5 6 7 8 9 10))))
-(assert! (not (binary-search 2 (vector 1 3 4 5 6 7 8 9 10))))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/calculator.scm b/crates/steel-core/src/tests/success/calculator.scm
deleted file mode 100644
index cf973156f..000000000
--- a/crates/steel-core/src/tests/success/calculator.scm
+++ /dev/null
@@ -1,63 +0,0 @@
-(struct node (datum children))
-
-(define (parse expr)
-(parse-helper expr '() '()))
-
-(define (parse-helper expr operators operands)
-    (cond ((null? expr)
-            (if (null? operators)
-                (car operands)
-                (handle-op '() operators operands)))
-            ((number? (car expr))
-            (parse-helper (cdr expr)
-                        operators
-                        (cons (node (car expr) '()) operands)))
-            ((list? (car expr))
-            (parse-helper (cdr expr)
-                        operators
-                        (cons (parse (car expr)) operands)))
-            (else (if (or (null? operators)
-                        (> (precedence (car expr))
-                            (precedence (car operators))))
-                    (parse-helper (cdr expr)
-                                    (cons (car expr) operators)
-                                    operands)
-                    (handle-op expr operators operands)))))
-
-(define (handle-op expr operators operands)
-    (parse-helper expr
-                    (cdr operators)
-                    (cons (node (car operators)
-                                    (list (cadr operands) (car operands)))
-                        (cddr operands))))
-
-(define (member? x los)
-    (cond
-        ((null? los) #f)
-        ((equal? x (car los)) #t)
-        (else (member? x (cdr los)))))
-
-
-(define (precedence oper)
-    (if (member? oper '(+ -))
-        1
-        2))
-
-
-(define (compute tree)
-    (if (number? (node-datum tree))
-        (node-datum tree)
-        ((function-named-by (node-datum tree))
-            (compute (car (node-children tree)))
-            (compute (cadr (node-children tree))))))
-
-(define (function-named-by oper)
-    (cond ((equal? oper '+) +)
-            ((equal? oper '-) -)
-            ((equal? oper '*) *)
-            ((equal? oper '/) /)
-            (else (error! "no such operator as" oper))))
-
-; (define expr (parse '(1 + 2)))
-
-(assert! (equal? 10 (compute (parse '(1 + 2 + 3 + 4))))) ;; => 10
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/capture_upvalue.scm b/crates/steel-core/src/tests/success/capture_upvalue.scm
deleted file mode 100644
index 344329261..000000000
--- a/crates/steel-core/src/tests/success/capture_upvalue.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-(define test ((lambda (x) (lambda (y) (+ x y))) 10))
-(assert! (equal? 25 (test 15)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/capture_upvalues_arity_two.scm b/crates/steel-core/src/tests/success/capture_upvalues_arity_two.scm
deleted file mode 100644
index 344329261..000000000
--- a/crates/steel-core/src/tests/success/capture_upvalues_arity_two.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-(define test ((lambda (x) (lambda (y) (+ x y))) 10))
-(assert! (equal? 25 (test 15)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/close_upvalue.scm b/crates/steel-core/src/tests/success/close_upvalue.scm
deleted file mode 100644
index 5bd1b6ff9..000000000
--- a/crates/steel-core/src/tests/success/close_upvalue.scm
+++ /dev/null
@@ -1,8 +0,0 @@
-(define value 
-    ((((lambda (x) 
-        (lambda (y) 
-            (lambda (z) (+ x y z)))) 
-                10) 
-                20) 
-                30))
-(assert! (equal? 60 value))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/closure_value_capture.scm b/crates/steel-core/src/tests/success/closure_value_capture.scm
deleted file mode 100644
index f410b3e77..000000000
--- a/crates/steel-core/src/tests/success/closure_value_capture.scm
+++ /dev/null
@@ -1,13 +0,0 @@
-(define (build-list-of-functions n i list)
-  (if (< i n)
-      (build-list-of-functions n (+ i 1) (cons (lambda () (* (- n i) (- n i))) list))
-      list))
-
-(define list-of-functions (build-list-of-functions 10 1 '()))
-
-(assert! (equal?
-            (map (lambda (f) (f)) list-of-functions)
-            '(1 4 9 16 25 36 49 64 81)))
-
-(assert! (equal? ((list-ref list-of-functions 8))
-                 81))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/comma_quibbling.scm b/crates/steel-core/src/tests/success/comma_quibbling.scm
deleted file mode 100644
index ada373593..000000000
--- a/crates/steel-core/src/tests/success/comma_quibbling.scm
+++ /dev/null
@@ -1,32 +0,0 @@
-;; Make this macro compile!
-(define-syntax do
-  (syntax-rules ()
-    [(do ((var init step ...) ...) (test expr ...) command ...)
-     (letrec* ([loop
-                (lambda (var ...)
-                  (if test
-                      (begin
-                        expr ...)
-                      (begin
-                        command ...
-                        (loop (do "step" var step ...) ...))))])
-              (loop init ...))]
-    [(do "step" x) x]
-    [(do "step" x y) y]))
-
-(define (quibble . args)
-  (display "{")
-  (do ((rem args (cdr rem))
-       ;; (foo bar baz) ;; Checking macro expansion
-       )
-      ((null? rem) (display "}\n"))
-      (display (car rem))
-      (cond
-        [(= 1 (length rem))]
-        [(= 2 (length rem)) (display " and ")]
-        [else (display ", ")])))
-
-(quibble)
-(quibble "ABC")
-(quibble "ABC" "DEF")
-(quibble "ABC" "DEF" "G" "H")
diff --git a/crates/steel-core/src/tests/success/complex_lets.scm b/crates/steel-core/src/tests/success/complex_lets.scm
deleted file mode 100644
index c044571e9..000000000
--- a/crates/steel-core/src/tests/success/complex_lets.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-(define (test)
-    (let ((apples (begin (displayln 10) (displayln 20) 10))
-            (bananas (begin (displayln 10) (displayln 20) 30))
-            (foo (begin (displayln 10) (displayln 20) 40)))
-        (+ apples bananas foo)))
-
-(assert! (equal? (test) 80))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/define_normal.scm b/crates/steel-core/src/tests/success/define_normal.scm
deleted file mode 100644
index f2db9d08e..000000000
--- a/crates/steel-core/src/tests/success/define_normal.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-(define n 10)
-(define m 20)
-(assert! (equal? (range n m) (list 10 11 12 13 14 15 16 17 18 19)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/defmacro.scm b/crates/steel-core/src/tests/success/defmacro.scm
deleted file mode 100644
index d6dda54bd..000000000
--- a/crates/steel-core/src/tests/success/defmacro.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-(begin-for-syntax
-  (define (my-function x)
-    (displayln x)))
-
-(defmacro (leave-alone x) (cadr (syntax-e x)))
-
-(leave-alone (define foo-bar 100))
-
-(defmacro (print-value x) (my-function x) (cadr (syntax-e x)))
-
-(print-value (define baz 100))
-
-(assert! (equal? foo-bar 100))
-(assert! (equal? baz 100))
diff --git a/crates/steel-core/src/tests/success/delim_control.scm b/crates/steel-core/src/tests/success/delim_control.scm
deleted file mode 100644
index f1617ff51..000000000
--- a/crates/steel-core/src/tests/success/delim_control.scm
+++ /dev/null
@@ -1,173 +0,0 @@
-; #lang racket
-
-; Generic implementation of all four delimited control operators
-;    shift/reset, prompt/control, shift0/reset0 and prompt0/control0
-;                   aka. -F- through +F+   
-;
-; The code below is parameterized by two boolean flags:
-; is-shift and keep-delimiter-upon-effect.
-; Each flag is present in the code exactly once, in a trivial
-; context. In particular, the difference between shift and control is
-; one statement: (hole-push! (cell-new k-return is-shift))
-; which tells whether the created hole is delimiting or not.
-; All four combinations of the two flags correspond to four
-; delimited control operators,  -F- through +F+
-;
-; The code relies on call/cc for capturing undelimited
-; continuations, and uses one global mutable cell. It turns out, this
-; is sufficient for implementing not only shift/reset (Danvy/Filinski)
-; but also for control/prompt and the other F operators. That has not
-; been known before. In particular, the implementation of
-; control/prompt needs no eq? operations.
-;
-; This implementation immediately leads to a CPS transform for
-; control/prompt (which has not been known before either). That
-; transform turns almost identical to the one discussed in the
-; forth-coming paper ``A Monadic Framework for Delimited
-; Continuations'' by R. Kent Dybvig, Simon Peyton Jones and Amr Sabry
-;
-; This code is inspired by CC_Ref.hs -- contexts with holes, while reading
-; Dorai Sitaram and Matthias Felleisen paper (Lisp and symbolic computation,
-; 1990)
-; A hole has a continuation and a mark. The mark, if #t, says if the hole
-; is a delimiting hole.
-; Non-delimiting hole is just like the return from a regular function.
-;
-; $Id: delim-control-n.scm 815 2005-09-05 23:02:12Z oleg $
-
-; Two parameterizing boolean flags. We can change them at run-time
-; and so mutate shift into control at run-time! The regression test code below
-; does exactly that, so it can test all four *F* operators.
-(define is-shift #f)
-(define keep-delimiter-upon-effect #t)
-
-; This is one single global mutable cell
-(define holes '())
-(define (hole-push! hole) (set! holes (cons hole holes)))
-(define (hole-pop!) (let ((hole (car holes))) (set! holes (cdr holes)) hole))
-
-(define (cell-new v mark) (cons v mark))
-(define (cell-ref c) (car c))
-(define (cell-marked? c) (cdr c))
-
-; Essentially this is the ``return from the function''
-(define (abort-top! v) ((cell-ref (hole-pop!)) v))
-(define (unwind-till-marked!)
-  (when (null? holes) (error "No prompt set"))
-  (let ((hole (hole-pop!)))
-    (if (cell-marked? hole)		; if marked, it's prompt's hole
-      (begin (hole-push!		; put it back
-	       (if keep-delimiter-upon-effect hole
-		 (cell-new (cell-ref hole) #f))) ; make the hole non-delimiting
-	'())	
-      (cons hole (unwind-till-marked!)))))
-
-(define (prompt* thunk)
-  (call-with-current-continuation
-    (lambda (outer-k)
-      (hole-push! (cell-new outer-k #t)) ; it's prompt's hole
-      (abort-top! (thunk)))))
-      
-(define (control* f)
-  (call-with-current-continuation
-    (lambda (k-control)
-      (let* ((holes-prefix (reverse (unwind-till-marked!)))
-	     (invoke-subcont 
-	       (lambda (v)
-		 (call-with-current-continuation
-		   (lambda (k-return)
-		     (hole-push! (cell-new k-return is-shift))
-		     (for-each hole-push! holes-prefix)
-		     (k-control v))))))
-	(abort-top! (f invoke-subcont))))))
-
-(define (abort v) (control* (lambda (k) v)))
-
-; Some syntactic sugar
-(define-syntax prompt
-  (syntax-rules ()
-    ((prompt e) (prompt* (lambda () e)))))
-
-(define-syntax control
-  (syntax-rules ()
-    ((control f e) (control* (lambda (f) e)))))
-
-
-(define (void) void)
-
-(define (for-each func lst)
-    (if (null? lst) 
-        void
-        (begin
-            (func (car lst))
-            (if (null? lst) 
-                (void)
-                (for-each func (cdr lst))))))
-
-
-;------------------------------------------------------------------------
-;			Shift tests
-(display "shift tests") (newline)
-
-(set! is-shift #t)
-(set! keep-delimiter-upon-effect #t)
-
-; introduce convenient synonyms
-
-(define-syntax reset
-  (syntax-rules ()
-    ((reset e) (prompt e))))
-
-(define-syntax shift
-  (syntax-rules ()
-    ((shift f e) (control f e))))
-
-(display (+ 10 (reset (+ 2 (shift k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (* 10 (reset (* 2 (shift g (reset 
-				   (* 5 (shift f (+ (f 1) 1)))))))))
-(newline)
-; --> 60
-
-(display (let ((f (lambda (x) (shift k (k (k x))))))
-	   (+ 1 (reset (+ 10 (f 100))))))
-(newline)
-; --> 121
-
-(display (reset
-	   (let ((x (shift f (cons 'a (f '())))))
-	     (shift g x))))
-(newline)
-; ==> '(a)
-
-(define (p x) (if (eq? x p) '(p p) `(p ,x)))
-(define (shift* p) (shift f (p f)))
-(reset (display (let ((x 'abcde)) (eq? x ((shift* shift*) x)))))
-(reset (let ((x 'abcde)) (eq? x ((shift* shift*) x))))
-(newline)
-
-(define visit
-    (lambda (xs)
-        (if (null? xs)
-        '()
-        (visit (control*
-            (lambda (k)
-                (cons (car xs) (k (cdr xs)))))))))
-
-(define (traverse xs)
-    ; (define visit
-    ;     (lambda (xs)
-    ;         (if (null? xs)
-    ;         '()
-    ;         (visit (control*
-    ;             (lambda (k)
-    ;                 (cons (car xs) (k (cdr xs)))))))))
-    (prompt*
-        (lambda ()
-            (visit xs))))
-
-(display "Ex by Olivier Danvy") (newline)
-(display (traverse '(1 2 3 4 5)))
-(newline)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/delim_control_n.scm b/crates/steel-core/src/tests/success/delim_control_n.scm
deleted file mode 100644
index 01a21e4e5..000000000
--- a/crates/steel-core/src/tests/success/delim_control_n.scm
+++ /dev/null
@@ -1,261 +0,0 @@
-; Generic implementation of all four delimited control operators
-;    shift/reset, prompt/control, shift0/reset0 and prompt0/control0
-;                   aka. -F- through +F+
-;
-; The code below is parameterized by two boolean flags:
-; is-shift and keep-delimiter-upon-effect.
-; Each flag is present in the code exactly once, in a trivial
-; context. In particular, the difference between shift and control is
-; one statement: (hole-push! (cell-new k-return is-shift))
-; which tells whether the created hole is delimiting or not.
-; All four combinations of the two flags correspond to four
-; delimited control operators,  -F- through +F+
-;
-; The code relies on call/cc for capturing undelimited
-; continuations, and uses one global mutable cell. It turns out, this
-; is sufficient for implementing not only shift/reset (Danvy/Filinski)
-; but also for control/prompt and the other F operators. That has not
-; been known before. In particular, the implementation of
-; control/prompt needs no eq? operations.
-;
-; This implementation immediately leads to a CPS transform for
-; control/prompt (which has not been known before either). That
-; transform turns almost identical to the one discussed in the
-; forth-coming paper ``A Monadic Framework for Delimited
-; Continuations'' by R. Kent Dybvig, Simon Peyton Jones and Amr Sabry
-;
-; This code is inspired by CC_Ref.hs -- contexts with holes, while reading
-; Dorai Sitaram and Matthias Felleisen paper (Lisp and symbolic computation,
-; 1990)
-; A hole has a continuation and a mark. The mark, if #t, says if the hole
-; is a delimiting hole.
-; Non-delimiting hole is just like the return from a regular function.
-;
-; $Id: delim-control-n.scm 815 2005-09-05 23:02:12Z oleg $
-
-(define (for-each func lst)
-  (if (null? lst)
-      void
-      (begin
-        (func (car lst))
-        (when (null? lst)
-          (return! void))
-        (for-each func (cdr lst)))))
-
-; Two parameterizing boolean flags. We can change them at run-time
-; and so mutate shift into control at run-time! The regression test code below
-; does exactly that, so it can test all four *F* operators.
-(define is-shift #f)
-(define keep-delimiter-upon-effect #t)
-
-; This is one single global mutable cell
-(define holes '())
-(define (hole-push! hole)
-  (set! holes (cons hole holes)))
-(define (hole-pop!)
-  (let ([hole (car holes)])
-    (set! holes (cdr holes))
-    hole))
-
-(define (cell-new v mark)
-  (cons v mark))
-(define (cell-ref c)
-  (car c))
-(define (cell-marked? c)
-  (cdr c))
-
-; Essentially this is the ``return from the function''
-(define (abort-top! v)
-  ((cell-ref (hole-pop!)) v))
-(define (unwind-till-marked!)
-  (when (null? holes)
-    (error! "No prompt set"))
-  (let ([hole (hole-pop!)])
-    (if (cell-marked? hole) ; if marked, it's prompt's hole
-        (begin
-          (hole-push! ; put it back
-           (if keep-delimiter-upon-effect
-               hole
-               (cell-new (cell-ref hole) #f))) ; make the hole non-delimiting
-          '())
-        (cons hole (unwind-till-marked!)))))
-
-(define (prompt* thunk)
-  (call-with-current-continuation (lambda (outer-k)
-                                    (hole-push! (cell-new outer-k #t)) ; it's prompt's hole
-                                    (abort-top! (thunk)))))
-
-(define (control* f)
-  (call-with-current-continuation
-   (lambda (k-control)
-     (let* ([holes-prefix (reverse (unwind-till-marked!))]
-            [invoke-subcont (lambda (v)
-                              (call-with-current-continuation (lambda (k-return)
-                                                                (hole-push! (cell-new k-return
-                                                                                      is-shift))
-                                                                (for-each hole-push! holes-prefix)
-                                                                (k-control v))))])
-       (abort-top! (f invoke-subcont))))))
-
-(define (abort v)
-  (control* (lambda (k) v)))
-
-; Some syntactic sugar
-(define-syntax prompt
-  (syntax-rules ()
-    [(prompt e) (prompt* (lambda () e))]))
-
-(define-syntax control
-  (syntax-rules ()
-    [(control f e) (control* (lambda (f) e))]))
-
-;------------------------------------------------------------------------
-;			Shift tests
-(display "shift tests")
-(newline)
-
-(set! is-shift #t)
-(set! keep-delimiter-upon-effect #t)
-
-; introduce convenient synonyms
-
-(define-syntax reset
-  (syntax-rules ()
-    [(reset e) (prompt e)]))
-
-(define-syntax shift
-  (syntax-rules ()
-    [(shift f e) (control f e)]))
-
-(display (+ 10 (reset (+ 2 (shift k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (* 10 (reset (* 2 (shift g (reset (* 5 (shift f (+ (f 1) 1)))))))))
-(newline)
-; --> 60
-
-(display (let ([f (lambda (x) (shift k (k (k x))))]) (+ 1 (reset (+ 10 (f 100))))))
-(newline)
-; --> 121
-
-(display (reset (let ([x (shift f (cons 'a (f '())))]) (shift g x))))
-(newline)
-; ==> '(a)
-
-(define (p x)
-  (if (eq? x p) '(p p) `(p ,x)))
-(define (shift* p)
-  (shift f (p f)))
-(reset (display (let ([x 'abcde]) (eq? x ((shift* shift*) x)))))
-(newline)
-
-; (define traverse
-;   (lambda (xs)
-;     (letrec ((visit
-; 	       (lambda (xs)
-; 		 (if (null? xs)
-; 		   '()
-; 		   (visit (control*
-; 			    (lambda (k)
-; 			      (cons (car xs) (k (cdr xs))))))))))
-;       (prompt*
-; 	(lambda ()
-; 	  (visit xs))))))
-
-; (display "Ex by Olivier Danvy") (newline)
-; (display (traverse '(1 2 3 4 5)))
-; (newline)
-
-;------------------------------------------------------------------------
-;			Control tests
-; Example from Sitaram, Felleisen
-
-(newline)
-(display "control tests")
-(newline)
-
-(set! is-shift #f)
-(set! keep-delimiter-upon-effect #t)
-
-(display "Ex 1")
-(newline)
-(assert! (equal? 42 (let ([g (prompt (* 2 (control k k)))]) (* 3 (prompt (* 5 (abort (g 7))))))))
-(newline)
-
-; Olivier Danvy's puzzle
-
-; (define traverse
-;   (lambda (xs)
-;     (letrec ((visit
-; 	       (lambda (xs)
-; 		 (if (null? xs)
-; 		   '()
-; 		   (visit (control*
-; 			    (lambda (k)
-; 			      (cons (car xs) (k (cdr xs))))))))))
-;       (prompt*
-; 	(lambda ()
-; 	  (visit xs))))))
-
-; (display "Ex by Olivier Danvy") (newline)
-; (display (traverse '(1 2 3 4 5)))
-; (newline)
-
-(displayln (+ 10 (prompt (+ 2 (control k (+ 100 (k (k 3))))))))
-; --> 117
-
-; (assert! (equal?
-
-(displayln (prompt (let ([x (control f (cons 'a (f '())))]) (control g x))))
-; ==> '()
-
-(display (prompt ((lambda (x) (control l 2)) (control l (+ 1 (l 0))))))
-(newline)
-;  ==> 2
-(display (prompt (control f (cons 'a (f '())))))
-(newline)
-; ==> '(a)
-(display (prompt (let ([x (control f (cons 'a (f '())))]) (control g (g x)))))
-(newline)
-; ==> '(a)
-
-(prompt (display (let ([x 'abcde]) (eq? x ((control* control*) x)))))
-(newline)
-
-;------------------------------------------------------------------------
-;			shift0/control0 tests
-
-(define-syntax prompt0
-  (syntax-rules ()
-    [(prompt0 e) (prompt e)]))
-
-(display "control0 tests")
-(newline)
-(set! is-shift #f)
-(set! keep-delimiter-upon-effect #f)
-
-(display (+ 10 (prompt0 (+ 2 (control k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (prompt0 (prompt0 (let ([x (control f (cons 'a (f '())))]) (control g x)))))
-(newline)
-; ==> '()
-
-(define-syntax shift0
-  (syntax-rules ()
-    [(shift0 f e) (control f e)]))
-
-(display "shift0 tests")
-(newline)
-(set! is-shift #t)
-(set! keep-delimiter-upon-effect #f)
-
-(display (+ 10 (prompt0 (+ 2 (shift0 k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (prompt0 (cons 'a (prompt0 (shift0 f (shift0 g '()))))))
-(newline)
-; ==> '()
diff --git a/crates/steel-core/src/tests/success/dfs.scm b/crates/steel-core/src/tests/success/dfs.scm
deleted file mode 100644
index 428c3778a..000000000
--- a/crates/steel-core/src/tests/success/dfs.scm
+++ /dev/null
@@ -1,81 +0,0 @@
-;; implementation of a dfs in steel
-
-;; Given a node and a graph
-;; node -> 'a
-;; graph -> '((a b c) (b d) (e f))
-;;
-;; returns the neighbors
-;; ex.
-;; (get-neighbors 'a graph) => '(b c)
-;;
-(define (get-neighbors node graph)
-  (define found-neighbors (assoc node graph))
-  (if found-neighbors (cdr found-neighbors) '()))
-
-(define (longest lst)
-  (foldr (λ (a b) (if (> (length a) (length b)) a b)) '() lst))
-
-(define (first-step curr end graph)
-  (define neighbors (get-neighbors curr graph))
-  (longest (map (lambda (x) (dfs x end '() '() graph)) neighbors)))
-
-(define (member? x los)
-  (cond
-    [(null? los) #f]
-    [(equal? x (car los)) #t]
-    [else (member? x (cdr los))]))
-
-;; iteratively tries each neighbor
-;; quits when the length is worse
-(define (try-all-neighbors neighbors best-path end new-path graph)
-  (if (not (empty? neighbors))
-      (let* ([next-neighbor (car neighbors)]
-             [found-path (dfs next-neighbor end new-path best-path graph)])
-        (if (> (length found-path) (length best-path))
-            (try-all-neighbors (cdr neighbors) found-path end new-path graph)
-            (try-all-neighbors (cdr neighbors) best-path end new-path graph)))
-      best-path))
-
-(define (dfs curr end path best-path graph)
-  (define neighbors (get-neighbors curr graph))
-  (define new-path (cons curr path))
-  (cond
-    [(equal? curr end) (cons curr path)]
-    [(member? curr path) '()]
-    [neighbors (try-all-neighbors neighbors best-path end (cons curr path) graph)]
-    [else '()]))
-
-(define (longest-path start end graph)
-  (define found-path (reverse (first-step start end graph)))
-  (cond
-    [(empty? found-path) (if (equal? start end) (list start) '())]
-    [(and (equal? (car found-path) start) (not (equal? start end))) found-path]
-    [else (cons start found-path)]))
-
-(longest-path 'a 'c '((a b) (b c))) ;; '(a b c)
-(longest-path 'a 'c '((a b) (b a c))) ;; '(a b c)
-(longest-path 'a 'c '((a d e f g b) (b a c))) ;; '(a b c)
-(longest-path 'a 'a '((a b) (b a c))) ;; '(a b a)
-(longest-path 'a 'c '((a b) (b a) (c))) ;; '()
-(longest-path 'a 'f '((a b c) (b f) (c d) (d e) (e f))) ;; '(a c d e f)
-(longest-path 'a 'f '((a b c a) (b c d) (c e a) (d e f) (e d f))) ;; '(a b c e d f)
-(longest-path 'a 'a '((a b c a) (b c d) (c e a) (d e f) (e d f))) ;; '(a b c a)
-(longest-path 'a 'a '((a b) (b c))) ;; '(a)
-(longest-path 'a 'a '((a a b) (b c))) ;; '(a a)
-(longest-path 'a 'a '((a b a) (b c))) ;; '(a a)
-(longest-path 'a 'b '((a b) (b c) (c b))) ;; '(a b)
-(longest-path 'a 'b '((a b c) (b c) (c b))) ;; '(a c b)
-
-(assert! (equal? (longest-path 'a 'c '((a b) (b c))) '(a b c)))
-(assert! (equal? (longest-path 'a 'c '((a b) (b a c))) '(a b c)))
-(assert! (equal? (longest-path 'a 'c '((a d e f g b) (b a c))) '(a b c)))
-(assert! (equal? (longest-path 'a 'a '((a b) (b a c))) '(a b a)))
-(assert! (equal? (longest-path 'a 'c '((a b) (b a) (c))) '()))
-(assert! (equal? (longest-path 'a 'f '((a b c) (b f) (c d) (d e) (e f))) '(a c d e f)))
-(assert! (equal? (longest-path 'a 'f '((a b c a) (b c d) (c e a) (d e f) (e d f))) '(a b c e d f)))
-(assert! (equal? (longest-path 'a 'a '((a b c a) (b c d) (c e a) (d e f) (e d f))) '(a b c a)))
-(assert! (equal? (longest-path 'a 'a '((a b) (b c))) '(a)))
-(assert! (equal? (longest-path 'a 'a '((a a b) (b c))) '(a a)))
-(assert! (equal? (longest-path 'a 'a '((a b a) (b c))) '(a a)))
-(assert! (equal? (longest-path 'a 'b '((a b) (b c) (c b))) '(a b)))
-(assert! (equal? (longest-path 'a 'b '((a b c) (b c) (c b))) '(a c b)))
diff --git a/crates/steel-core/src/tests/success/dll.scm b/crates/steel-core/src/tests/success/dll.scm
deleted file mode 100644
index 858f51b17..000000000
--- a/crates/steel-core/src/tests/success/dll.scm
+++ /dev/null
@@ -1,53 +0,0 @@
-(struct dllist (head tail) #:mutable #:transparent)
-(struct dllink (content prev next) #:mutable #:transparent)
-
-(define (insert-between dlist before after data)
-  ; Insert a fresh link containing DATA after existing link
-  ; BEFORE if not nil and before existing link AFTER if not nil
-  (define new-link (dllink data before after))
-  (if before (set-dllink-next! before new-link) (set-dllist-head! dlist new-link))
-  (if after (set-dllink-prev! after new-link) (set-dllist-tail! dlist new-link))
-  new-link)
-
-(define (insert-before dlist dlink data)
-  ; Insert a fresh link containing DATA before existing link DLINK
-  (insert-between dlist (dllink-prev dlink) dlink data))
-
-(define (insert-after dlist dlink data)
-  ; Insert a fresh link containing DATA after existing link DLINK
-  (insert-between dlist dlink (dllink-next dlink) data))
-
-(define (insert-head dlist data)
-  ; Insert a fresh link containing DATA at the head of DLIST
-  (insert-between dlist #f (dllist-head dlist) data))
-
-(define (insert-tail dlist data)
-  ; Insert a fresh link containing DATA at the tail of DLIST
-  (insert-between dlist (dllist-tail dlist) #f data))
-
-(define (remove-link dlist dlink)
-  ; Remove link DLINK from DLIST and return its content
-  (let ([before (dllink-prev dlink)] [after (dllink-next dlink)])
-    (if before (set-dllink-next! before after) (set-dllist-head! dlist after))
-    (if after (set-dllink-prev! after before) (set-dllist-tail! dlist before))))
-
-(define (dllist-elements dlist)
-  ; Returns the elements of DLIST as a list
-  (define (extract-values dlink acc)
-    (if dlink (extract-values (dllink-next dlink) (cons (dllink-content dlink) acc)) acc))
-  (reverse (extract-values (dllist-head dlist) '())))
-
-;; It is important that this doesn't stack overflow
-(let ([dlist (dllist #f #f)])
-  (insert-head dlist 1)
-  (displayln dlist)
-  (insert-tail dlist 4)
-  (displayln dlist)
-  (insert-after dlist (dllist-head dlist) 2)
-  (displayln dlist)
-  (let* ([next-to-last (insert-before dlist (dllist-tail dlist) 3)]
-         [bad-link (insert-before dlist next-to-last 42)])
-    (remove-link dlist bad-link))
-  (displayln dlist)
-  (displayln (dllist-elements dlist))
-  (displayln dlist))
diff --git a/crates/steel-core/src/tests/success/ellipses.scm b/crates/steel-core/src/tests/success/ellipses.scm
deleted file mode 100644
index 27f3df9b5..000000000
--- a/crates/steel-core/src/tests/success/ellipses.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-(define (foo . x)
-  x)
-
-(define-syntax test/c
-  (syntax-rules (=>)
-    [(test/c (r (x => (y) ...)) ...) (list (foo (list x ...) (list y ...) r) ...)]))
-
-(assert! (equal? (test/c (1 (10 => (500))) (2 (10 => (700)))) '(((10 10) (500) 1) ((10 10) (700) 2))))
-
-(define-syntax test2
-  (syntax-rules (=>)
-    [(test2 (r (z) ...)) (list (list r z) ...)]))
-
-(assert! (equal? (test2 (10 (20) (30) (40))) '((10 20) (10 30) (10 40))))
diff --git a/crates/steel-core/src/tests/success/empty.scm b/crates/steel-core/src/tests/success/empty.scm
deleted file mode 100644
index 42a8ca8f1..000000000
--- a/crates/steel-core/src/tests/success/empty.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-(assert! (empty? '()))
-(assert! (not (empty? (list 10 20 30 40))))
diff --git a/crates/steel-core/src/tests/success/fib.scm b/crates/steel-core/src/tests/success/fib.scm
deleted file mode 100644
index 2634793b6..000000000
--- a/crates/steel-core/src/tests/success/fib.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(define (fib n) 
-    (if (<= n 2) 
-        1
-        (+ (fib (- n 1)) (fib (- n 2)))))
-
-(fib 20)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/generator.scm b/crates/steel-core/src/tests/success/generator.scm
deleted file mode 100644
index 6b145d2ed..000000000
--- a/crates/steel-core/src/tests/success/generator.scm
+++ /dev/null
@@ -1,54 +0,0 @@
-(define (for-each func lst)
-    (if (null? lst) 
-        void
-        (begin
-            (func (car lst))
-            (when (null? lst) (return! void))
-            (for-each func (cdr lst)))))
-
-; (for-each (lambda (x) (displayln x)) '(1 2 3 4 5))
-
-;; [LISTOF X] -> ( -> X u 'you-fell-off-the-end)
-(define (generate-one-element-at-a-time lst)
-    ;; Both internal functions are closures over lst
-
-    ;; Internal variable/Function which passes the current element in a list
-    ;; to its return argument (which is a continuation), or passes an end-of-list marker 
-    ;; if no more elements are left. On each step the function name is 
-    ;; rebound to a continuation which points back into the function body,
-    ;; while return is rebound to whatever continuation the caller specifies.
-    (define (control-state return)
-        (for-each 
-            (lambda (element)
-                    (set! return (call/cc
-                                    (lambda (resume-here)
-                                        ;; Grab the current continuation
-                                        (set! control-state resume-here)
-                                        (displayln element)
-                                        (return element))))) ;; (return element) evaluates to next return
-            lst)
-        (return 'you-fell-off-the-end))
-
-    ;; (-> X u 'you-fell-off-the-end)
-    ;; This is the actual generator, producing one item from a-list at a time.
-    (define (generator)
-        (call/cc control-state))
-
-    ;; Return the generator 
-    generator)
-
-
-    ;; So this seems to get the job done
-    ;; looks like defining the local variable and then returning it makes it get
-    ;; confused for some reason...
-    ; (lambda () (call/cc control-state)))
-
-(define generate-digit
-    (generate-one-element-at-a-time '(0 1 2)))
-
-(assert! (equal? 0 (generate-digit))) ;; 0
-(assert! (equal? 1 (generate-digit))) ;; 1
-(assert! (equal? 2 (generate-digit))) ;; 2
-(assert! (equal? 'you-fell-off-the-end (generate-digit))) ;; you-fell-off-the-end
-
-
diff --git a/crates/steel-core/src/tests/success/generic_execution.scm b/crates/steel-core/src/tests/success/generic_execution.scm
deleted file mode 100644
index 4cf5b420e..000000000
--- a/crates/steel-core/src/tests/success/generic_execution.scm
+++ /dev/null
@@ -1,9 +0,0 @@
-(define x (mapping (fn (x) x))) ;; identity
-(define y (filtering even?)) ;; get only even ones
-(define z (taking 15)) ;; take the first 15 from the range
-(define xf (compose x y z))
-(define result
-    (transduce (range 0 100) xf (into-list)))
-
-(define expected '(0 2 4 6 8 10 12 14 16 18 20 22 24 26 28))
-(assert! (equal? result expected))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/generic_execution_dropping.scm b/crates/steel-core/src/tests/success/generic_execution_dropping.scm
deleted file mode 100644
index e0e8b06e9..000000000
--- a/crates/steel-core/src/tests/success/generic_execution_dropping.scm
+++ /dev/null
@@ -1,9 +0,0 @@
-(define x (mapping (fn (x) x))) ;; identity
-(define y (filtering even?)) ;; get only even ones
-(define z (dropping 15)) ;; drop the first 15 from the range
-(define xf (compose x y z))
-(define result
-    (transduce (range 0 40) xf (into-list)))
-
-(define expected '(30 32 34 36 38))
-(assert! (equal? result expected))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/generic_execution_output_different_type.scm b/crates/steel-core/src/tests/success/generic_execution_output_different_type.scm
deleted file mode 100644
index cab90789d..000000000
--- a/crates/steel-core/src/tests/success/generic_execution_output_different_type.scm
+++ /dev/null
@@ -1,9 +0,0 @@
-(define x (mapping (fn (x) x))) ;; identity
-(define y (filtering even?)) ;; get only even ones
-(define z (taking 15)) ;; take the first 15 from the range
-(define xf (compose x y z))
-(define result
-    (transduce (range 0 100) xf (into-vector)))
-
-(define expected (vector 0 2 4 6 8 10 12 14 16 18 20 22 24 26 28))
-(assert! (equal? result expected))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/generic_transducer.scm b/crates/steel-core/src/tests/success/generic_transducer.scm
deleted file mode 100644
index 704f8cbcd..000000000
--- a/crates/steel-core/src/tests/success/generic_transducer.scm
+++ /dev/null
@@ -1,8 +0,0 @@
-(define x (mapping (fn (x) x))) ;; identity
-(define y (filtering even?)) ;; get only even ones
-(define z (taking 15)) ;; take the first 15 from the range
-(define xf (compose x y z))
-(assert! 
-    (equal? 
-        (transduce (range 0 100) xf (into-reducer + 0)) ;; => 210
-        210))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/generic_transducer_with_different_functions.scm b/crates/steel-core/src/tests/success/generic_transducer_with_different_functions.scm
deleted file mode 100644
index 5624b23ed..000000000
--- a/crates/steel-core/src/tests/success/generic_transducer_with_different_functions.scm
+++ /dev/null
@@ -1,9 +0,0 @@
-(define x (mapping (fn (x) x))) ;; identity
-(define y (filtering even?)) ;; get only even ones
-(define z (taking 15)) ;; take the first 15 from the range
-(define xf (compose x y z))
-(define reduce-func (lambda (accum next) (+ accum next)))
-(assert! 
-    (equal? 
-        (transduce (range 0 100) xf (into-reducer reduce-func 0)) ;; => 210
-        210))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/hailstone.scm b/crates/steel-core/src/tests/success/hailstone.scm
deleted file mode 100644
index be5a37b42..000000000
--- a/crates/steel-core/src/tests/success/hailstone.scm
+++ /dev/null
@@ -1,39 +0,0 @@
-(define (collatz n)
-    (if (= n 1) 
-        '(1)
-        (cons n (collatz (if (even? n) (/ n 2) (+ 1 (* 3 n)))))))
-
-(define (collatz-length n)
-    (define (aux n r)
-        (if (= n 1) 
-                r
-                (aux (if (even? n) (/ n 2) (+ 1 (* 3 n))) (+ r 1))))
-    (aux n 1))
-
-(define (collatz-max a b)
-    (define (aux i j k)
-        (if (> i b) 
-                (list j k)
-                (let ((h (collatz-length i)))
-                    (if (> h k) 
-                        (aux (+ i 1) i h) 
-                        (aux (+ i 1) j k)))))
-    (aux a 0 0))
-
-
-(assert! (equal? (collatz 27)
-    '(27 82 41 124 62 31 94 47 142 71 214 107 322 161 484 242 121 364 182
-    91 274 137 412 206 103 310 155 466 233 700 350 175 526 263 790 395
-    1186 593 1780 890 445 1336 668 334 167 502 251 754 377 1132 566 283
-    850 425 1276 638 319 958 479 1438 719 2158 1079 3238 1619 4858 2429
-    7288 3644 1822 911 2734 1367 4102 2051 6154 3077 9232 4616 2308 1154
-    577 1732 866 433 1300 650 325 976 488 244 122 61 184 92 46 23 70 35
-    106 53 160 80 40 20 10 5 16 8 4 2 1)))
-
-(assert! (equal? (collatz-length 27)
-                 112))
-; 112
-
-(assert! (equal? (collatz-max 1 100000)
-                 '(77031 351)))
-; (77031 351)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/heap_sort.scm b/crates/steel-core/src/tests/success/heap_sort.scm
deleted file mode 100644
index 243e58787..000000000
--- a/crates/steel-core/src/tests/success/heap_sort.scm
+++ /dev/null
@@ -1,66 +0,0 @@
-; #lang racket
-; (define mutable-vector vector)
-
-(define vector-ref mut-vector-ref)
-(define vector-length mut-vec-len)
-
-; swap two elements of a vector
-(define (swap! v i j)
-  (define temp (vector-ref v i))
-  (vector-set! v i (vector-ref v j))
-  (vector-set! v j temp))
-
-; sift element at node start into place
-(define (sift-down! v start end)
-  (let ((child (+ (* start 2) 1)))
-    (cond
-      ((> child end) 'done) ; start has no children
-      (else
-       (begin
-         ; if child has a sibling node whose value is greater ...
-         (and (and (<= (+ child 1) end)
-                   (< (vector-ref v child) (vector-ref v (+ child 1))))
-              ; ... then we'll look at the sibling instead
-              (set! child (+ child 1)))
-        ;  (displayln child)
-         (if (< (vector-ref v start) (vector-ref v child))
-             (begin
-               (swap! v start child)
-               (sift-down! v child end))
-             'done))))))
-
-; transform v into a binary max-heap
-(define (heapify v)
-  (define (iter v start)
-    (if (>= start 0)
-        (begin (sift-down! v start (- (vector-length v) 1))
-               (iter v (- start 1)))
-        'done))
-  ; start sifting with final parent node of v
-  ; (displayln (quotient (- (vector-length v) 2) 2))
-  (iter v (quotient (- (vector-length v) 2) 2)))
-
-(define (heapsort v)
-  ; swap root and end node values,
-  ; sift the first element into place
-  ; and recurse with new root and next-to-end node
-  (define (iter v end)
-    (if (zero? end)
-        'done
-        (begin
-          (swap! v 0 end)
-          (sift-down! v 0 (- end 1))
-          (iter v (- end 1)))))
-  ; (begin
-  (heapify v)
-  ; start swapping with root and final node
-  (iter v (- (vector-length v) 1)))
-    
-; testing
-(define uriah (mutable-vector 3 5 7 9 0 8 1 4 2 6))
-(heapsort uriah)
-
-(define (mutable-vector->list vec)
-  (transduce vec (into-list)))
-
-(assert! (equal? (mutable-vector->list uriah) '(0 1 2 3 4 5 6 7 8 9)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/help.scm b/crates/steel-core/src/tests/success/help.scm
deleted file mode 100644
index 74c22a87b..000000000
--- a/crates/steel-core/src/tests/success/help.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-(help list)
-(help steel/time steel/time)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/html_table.scm b/crates/steel-core/src/tests/success/html_table.scm
deleted file mode 100644
index 1623ec272..000000000
--- a/crates/steel-core/src/tests/success/html_table.scm
+++ /dev/null
@@ -1,26 +0,0 @@
-(define table (vector
-                (vector "" "X" "Y" "Z")
-                (vector 1 1 2 3)
-                (vector 2 4 5 6)
-                (vector 3 7 8 9)))
-
-(display "<table style=\"text-align:center; border: 1px solid\">")
-(transduce 
-    (range 0 (vector-length table))
-    (into-for-each (lambda (r)
-                (display "<tr>")
-                (transduce (range 0 (vector-length (vector-ref table r)))
-                           (into-for-each (lambda (c)
-                                (when (equal? r 0)
-                                        (display "<th>"))
-                                (when (> r 0)
-                                        (display "<td>"))
-                                (display (vector-ref (vector-ref table r) c))
-                                ; (display r)
-                                (when (equal? r 0)
-                                        (display "</th>"))
-                                (when (> r 0)
-                                        (display "</td>")))))
-                                        
-                (displayln "</tr>"))))
-(display "</table>")
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/letrec_mutual_recursion.scm b/crates/steel-core/src/tests/success/letrec_mutual_recursion.scm
deleted file mode 100644
index 091b51bc1..000000000
--- a/crates/steel-core/src/tests/success/letrec_mutual_recursion.scm
+++ /dev/null
@@ -1,8 +0,0 @@
-(define (test)
-    (let ((x 10) (foo void) (bar void))
-            (let ((foo-prime (lambda (x) (if (= x 10000) x (bar (+ x 1)))))
-                (bar-prime (lambda (x) (if (= x 10000) x (foo (+ x 1))))))
-                (set! foo foo-prime)
-                (set! bar bar-prime))
-            (foo 0)))
-(assert! (= (test) 10000))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/letrec_simple_recursion.scm b/crates/steel-core/src/tests/success/letrec_simple_recursion.scm
deleted file mode 100644
index 9ba0ab8f3..000000000
--- a/crates/steel-core/src/tests/success/letrec_simple_recursion.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(define (test)
-  (let ([loop void])
-    (let ([loop-prime (lambda (x) (if (= x 10000) x (loop (+ x 1))))]) (set! loop loop-prime))
-    (loop 0)))
-
-(assert! (= (test) 10000))
diff --git a/crates/steel-core/src/tests/success/list_functions.scm b/crates/steel-core/src/tests/success/list_functions.scm
deleted file mode 100644
index 179c9066a..000000000
--- a/crates/steel-core/src/tests/success/list_functions.scm
+++ /dev/null
@@ -1,21 +0,0 @@
-(assert! (not (try-list-ref (list 10 20 30 40) 100)))
-
-(assert! (equal? (take (range 0 10) 3) (list 0 1 2)))
-
-(assert! (equal? '() (append)))
-
-(assert! (empty? '()))
-(assert! (not (empty? (range 0 10))))
-
-;; Type handling
-(with-handler
- (lambda (err) void)
- (append (vector 10) (vector 20))
- (assert!
-  #t)) ;; TODO have to use non const values here, or don't evaluate constant folding inside of a with-handler?
-(with-handler (lambda (err) void)
-              (first (hash)) ;; TODO have to use non const values here
-              (assert! #t))
-(with-handler (lambda (err) void) (reverse (hash)) (assert! #t))
-(with-handler (lambda (err) void) (length (vector)) (assert! #t))
-(with-handler (lambda (err) void) (empty? 100) (assert! #t))
diff --git a/crates/steel-core/src/tests/success/local_struct.scm b/crates/steel-core/src/tests/success/local_struct.scm
deleted file mode 100644
index 1de7c8d2e..000000000
--- a/crates/steel-core/src/tests/success/local_struct.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define (foo)
-    (struct Applesauce (a b c))
-    (Applesauce 1 2 3))
-
-(foo)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/matcher.scm b/crates/steel-core/src/tests/success/matcher.scm
deleted file mode 100644
index 46d87805f..000000000
--- a/crates/steel-core/src/tests/success/matcher.scm
+++ /dev/null
@@ -1,375 +0,0 @@
-;; Sets of useful ideas for things
-;; #lang racket
-
-;; ------------------- match functions ----------------------
-
-;; Tells me if this is a free variable (for now)
-(define (var? x)
-  (and (symbol? x) (starts-with? (symbol->string x) "?")))
-
-(define (ignore? x)
-  (equal? x '_))
-
-(define (many? x)
-  (and (symbol? x)
-       (let ([str (symbol->string x)]) (and (starts-with? str "?") (ends-with? str "...")))))
-
-(define (equal-or-insert hm key value)
-  (define existing-value (hash-try-get hm key))
-  (if existing-value (if (equal? existing-value value) hm #f) (hash-insert hm key value)))
-
-(define (collect-until-last-p input collected)
-  (if (null? (cdr input))
-      (list (car input) collected)
-      (collect-until-last-p (cdr input) (cons (car input) collected))))
-
-(define (collect-until-last input)
-  (collect-until-last-p input '()))
-
-;; Bindings or #false if there is not a match
-(define (match-p pattern input bindings)
-  (cond
-    [(and (list? pattern) (not (null? pattern)) (many? (car pattern)))
-     (if (null? (cdr pattern))
-         (equal-or-insert bindings (car pattern) input)
-         (let ([collected (collect-until-last input)])
-           (define remainder (car collected))
-           (define collected-list (reverse (car (cdr collected))))
-           (if (null? (cdr (cdr pattern)))
-               (let ([remainder-bound (equal-or-insert bindings (car (cdr pattern)) remainder)])
-                 (equal-or-insert remainder-bound (car pattern) collected-list))
-               #f)))]
-    [(var? pattern) (equal-or-insert bindings pattern input)]
-    [(ignore? pattern) bindings]
-    [(atom? pattern) (if (equal? pattern input) bindings #f)]
-    [(null? pattern) (if (null? input) bindings #f)]
-    [(null? input) #f]
-    [(and (list? pattern) (not (list? input))) #f]
-    [else
-     (define remaining (match-p (cdr pattern) (cdr input) bindings))
-     (if remaining (match-p (car pattern) (car input) remaining) #f)]))
-
-(define (match pattern
-          input)
-  (match-p pattern input (hash)))
-
-;; ---------------- tests --------------------
-
-;; Pretty print for testing purposes
-;; Throw in the assert as well for testing
-(define (test name input expected)
-  (assert! (equal? input expected))
-  (if (equal? input expected)
-      (begin
-        (display "> ")
-        (display name)
-        (display " ... ")
-        (display "OK")
-        (newline))
-      (begin
-        (display "> ")
-        (display name)
-        (display " ... ")
-        (display "FAILED")
-        (newline)
-        (display "    Expected: ")
-        (display expected)
-        (display ", Found ")
-        (displayln input))))
-
-(displayln "--------------------- match tests ----------------------")
-
-;; Matches a pattern explicitly
-(test "Simple match"
-      (match '?x
-        '(1 2 3 4))
-      (hash '?x '(1 2 3 4)))
-
-;; If the pattern match fails, return false
-(test "Pattern match fails returns false"
-      (match '(10 2 ?z 5)
-        '(1 2 3 4))
-      #f)
-
-;; If the pattern fails because we didn't match exactly, bail
-(test "Pattern fails because constants don't match exactly"
-      (match '(1 2 3 4 5)
-        '(1 2 3 4))
-      #f)
-
-;; Should fail
-(test "Lengths unequal fails"
-      (match '(?x ?y ?z 4 5)
-        '(1 2 3 4))
-      #f)
-
-;; Should succeed with x y z bound to 1 2 3
-(test "Successful pattern match on simple list"
-      (match '(?x ?y ?z 4 5)
-        '(1 2 3 4 5))
-      (hash '?x 1 '?y 2 '?z 3))
-
-;; Should succed with x y z bound to 1 2 3
-(test "Nested patterns match"
-      (match '(?x (?y ?z))
-        '(1 (2 3)))
-      (hash '?x 1 '?y 2 '?z 3))
-
-;; Also should work
-(test "Deep nested pattern"
-      (match '(?x (?y (?z (?applesauce ?bananas))))
-        '(1 (2 (3 (4 5)))))
-      (hash '?x 1 '?y 2 '?z 3 '?applesauce 4 '?bananas 5))
-
-;; Also should work
-(test "Deep nested pattern with list matching"
-      (match '(?x (?y (?z (?applesauce ?bananas))))
-        '(1 (2 (3 (4 (1 2 3 4 5))))))
-      (hash '?x 1 '?y 2 '?z 3 '?applesauce 4 '?bananas '(1 2 3 4 5)))
-
-;; Match the bindings
-(test "Pattern variables once bound retain their value"
-      (match '(?x ?y ?x)
-        '(1 2 1))
-      (hash '?x 1 '?y 2))
-
-;; Should fail since x doesn't match what was there at first
-(test "Matching fails when variable has two different values"
-      (match '(?x ?y ?x)
-        '(1 2 3))
-      #f)
-
-;; Shouldn't fail, should ignore whatever is in the second position
-(test "Wildcard ignores the matching at that position"
-      (match '(?x _ 3)
-        '(1 (1 2 3) 3))
-      (hash '?x 1))
-
-;; a => 1
-;; x => '(2 3 4 5)
-(test "Basic ellipses matching works"
-      (match '(?a ?x...)
-        '(1 2 3 4 5))
-      (hash '?a 1 '?x... '(2 3 4 5)))
-
-(test "Ellipses matches to empty list"
-      (match '(?first ?rest...)
-        '(1))
-      (hash '?first 1 '?rest... '()))
-
-(test "Ellipses matches until next value"
-      (match '(?first ?rest... ?last)
-        '(1 2 3 4 5))
-      (hash '?first 1 '?rest... '(2 3 4) '?last 5))
-
-; TODO this should error out as illegal pattern
-(test "Ellipses does not match multiple characters at the end"
-      (match '(?first ?rest... ?second-last ?last)
-        '(1 2 3 4 5 6))
-      #f
-      ; (hash '?first 1 '?rest... '(2 3 4) '?last 5 '?last 6)
-      )
-
-(test "Ellipses with nested pattern"
-      (match '(?x (?y ?z (?foo ?bar...)))
-        '(1 (2 3 (4 5 6 7 8 9 10))))
-      (hash '?x 1 '?y 2 '?z 3 '?foo 4 '?bar... '(5 6 7 8 9 10)))
-
-(test "Empty pattern matches empty list"
-      (match '()
-        '())
-      (hash))
-
-(test "Empty pattern fails on non empty list"
-      (match '()
-        '(1 2 3))
-      #f)
-
-(test "Single variable with empty list"
-      (match '?x
-        '())
-      (hash '?x '()))
-
-(test "Constant matches constant"
-      (match (list 1 2 3)
-        [list
-         1
-         2
-         3])
-      (hash))
-
-(test "List pattern does not match constant"
-      (match (list 1 2 3 4 5)
-        10)
-      #f)
-
-(test "Constant pattern does not match list"
-      (match 10
-        [list
-         1
-         2
-         3
-         4
-         5])
-      #f)
-
-(test "Wildcard passes"
-      (match '_
-        [list
-         1
-         2
-         3
-         4
-         5])
-      (hash))
-
-;; ----------------- match! syntax --------------------
-
-(define-syntax syntax->pattern
-  (syntax-rules ()
-    [(syntax->pattern (var1)) '(var1)]
-    [(syntax->pattern (var1 var2 ...)) (cons 'var1 (syntax->pattern (var2 ...)))]
-    [(syntax->pattern var) 'var]))
-
-(define-syntax syntax-pattern->lets
-  (syntax-rules ()
-    [(syntax-pattern->lets ((var1)) bindings body) (syntax-pattern->lets (var1) bindings body)]
-    [(syntax-pattern->lets ((var1 ...) rest ...) bindings body)
-     (syntax-pattern->lets (var1 ...) bindings (syntax-pattern->lets (rest ...) bindings body))]
-    [(syntax-pattern->lets (var1) bindings body)
-     ;; TODO
-     (syntax-const-if var1 body (let ([var1 (hash-try-get bindings 'var1)]) body))]
-    [(syntax-pattern->lets (var1 var2 ...) bindings body)
-     (syntax-const-if var1
-                      (syntax-pattern->lets (var2 ...) bindings body)
-                      (let ([var1 (hash-try-get bindings 'var1)])
-                        (syntax-pattern->lets (var2 ...) bindings body)))]
-    [(syntax-pattern->lets () bindings body) body]
-    [(syntax-pattern->lets var bindings body)
-     (syntax-const-if var body (let ([var (hash-try-get bindings 'var)]) body))]))
-
-;; TODO add case for the remaining - when there is no else case given
-;; and it should just error out
-(define-syntax match-dispatch
-  (syntax-rules (else)
-    ;; Explicitly giving an else case
-    [(match-dispatch expr [else e0 e1 ...])
-     (begin
-       e0
-       e1 ...)]
-    ;; Generic recursive case
-    [(match-dispatch expr [p1 e2 ...] c0 c1 ...)
-     (let ([match? (match (syntax->pattern p1)
-                     expr)])
-       (if match?
-           (syntax-pattern->lets p1
-                                 match?
-                                 (begin
-                                   e2 ...))
-           (match-dispatch expr c0 c1 ...)))]
-    ;; When there isn't an else case given, the last case
-    ;; Should include a failure mode
-    [(match-dispatch expr (p1 e2 ...))
-     (let ([match? (match (syntax->pattern p1)
-                     expr)])
-       (if match?
-           (syntax-pattern->lets p1
-                                 match?
-                                 (begin
-                                   e2 ...))
-           (error! "Unable to match expression: " expr " to any of the given patterns")))]))
-
-(define-syntax match!
-  (syntax-rules ()
-    [(match expr
-       pat)
-     (let ([evald-expr expr]) (match-dispatch evald-expr pat))]
-    [(match expr
-       pat
-       pats ...)
-     (let ([evald-expr expr]) (match-dispatch evald-expr pat pats ...))]))
-
-;; --------------------- match! tests ------------------------
-
-(displayln "--------------------- match! tests ----------------------")
-
-(test "Matches constant patterns" (match! (list 1 2 3 4 5) ((1 2 3 4 5) 'case1)) 'case1)
-
-(test "Matches patterns with constants mixed in"
-      (match! (list 1 2 3 4 5) ((?x 2 ?y 4 ?z) (+ ?x ?y ?z)))
-      (+ 1 3 5))
-
-(test "Dispatches on first of multiple matching patterns"
-      (match! (list 1 2 3 4 5) (?x 'case1) ((?a ?b ?c ? d ?e) 'case2))
-      'case1)
-
-(test "Constants match" (match! 10 (10 'case1)) 'case1)
-
-(test "Successfully takes the else case on no match"
-      (match! (list 1 (list 2 (list 3))) ((?x ?y ?z) 'case1) (24 'case2) (else 'case3))
-      'case3)
-
-(test "Custom map implementation succeeds"
-      ((lambda ()
-         (define (budget-map func lst)
-           (define (loop lst accum)
-             (match! lst (() accum) ((?x ?xs...) (loop ?xs... (cons (func ?x) accum)))))
-           (reverse (loop lst '())))
-         (budget-map (fn (x) (+ x 1)) (list 1 2 3 4 5))))
-      '(2 3 4 5 6))
-
-(test "Empty list matches empty list"
-      (match! '() (() 'found-empty-list!) ((?x ?xs...) 'found-list!))
-      'found-empty-list!)
-
-(test "Nested patterns match with bindings"
-      (match! (list (list 1 2) 3 (list 4 (list 5 6))) (((?a 2) ?b (?c (5 6))) (+ ?a ?b ?c)))
-      (+ 1 3 4))
-
-;; ;; Ambiguous matches will take the first one that matches
-;; (match! (list (list 1 2) 3 (list 4 5))
-;;         (() (displayln "Empty pattern!"))
-;;         ((?x) (displayln ?x))
-;;         ((?x ?y) (displayln (+ ?x ?y)))
-;;         (((?x ?y) ?z (?foo ?bar)) (displayln (list ?x ?y ?z ?foo ?bar)))
-;;         ((?x ?y ?z...) (displayln ?z...))
-;;         (else (displayln "didn't match!")))
-
-;; (define (budget-map func lst)
-;;   (define (loop lst accum)
-;;     (match! lst
-;;             (() accum)
-;;             ((?x ?xs...)
-;;              (loop ?xs...
-;;                    (cons (func ?x) accum)))))
-;;   (reverse (loop lst '())))
-
-;; (displayln
-;;  (budget-map (fn (x) (+ x 1))
-;;             (list 1 2 3 4 5))) ;; => '(2 3 4 5 6)
-
-;; (match! (list 1 2 3 4)
-;;         ((?x ?y) (displayln "Shouldn't get here!"))
-;;         ((?x 2 ?y 4)
-;;          (displayln ?x)
-;;          (displayln ?y)))
-
-;; TODO fix bug where using (quote <expr>) instead of '<expr>
-;; leads to a parsing error
-;; (define-syntax deck
-;;   (syntax-rules ()
-;;     [(deck (var1))
-;;         (begin
-;;         (display "Found a one element list ")
-;;         (displayln '(var1)))]
-;;     [(deck (var1 var2 ...))
-;;         (begin
-;;         (display "Popping off value: ")
-;;         (displayln 'var1)
-;;         (deck (var2 ...)))]
-;;     [(deck var)
-;;      (begin
-;;        (display "Found a single expr ")
-;;        (displayln 'var))]))
-
-;; (deck (?x ?y ?z))
diff --git a/crates/steel-core/src/tests/success/maxsubseq.scm b/crates/steel-core/src/tests/success/maxsubseq.scm
deleted file mode 100644
index d3204362c..000000000
--- a/crates/steel-core/src/tests/success/maxsubseq.scm
+++ /dev/null
@@ -1,15 +0,0 @@
-(define (max-subseq in)
-  (define (loop _sum _seq maxsum maxseq l)
-    (if (null? l)
-        (cons maxsum (reverse maxseq))
-        (let* ((x (car l)) (sum (+ _sum x)) (seq (cons x _seq)))
-            (if (> sum 0)
-                (if (> sum maxsum)
-                    (loop sum seq    sum    seq (cdr l))
-                    (loop sum seq maxsum maxseq (cdr l)))
-                (loop 0 (list) maxsum maxseq (cdr l))))))
-  (loop 0 (list) 0 (list) in))
-
-(assert! (equal? 
-            (max-subseq '(-1 -2 3 5 6 -2 -1 4 -4 2 -1))
-            '(15 3 5 6 -2 -1 4)))
diff --git a/crates/steel-core/src/tests/success/merge_sort.scm b/crates/steel-core/src/tests/success/merge_sort.scm
deleted file mode 100644
index db3ca7210..000000000
--- a/crates/steel-core/src/tests/success/merge_sort.scm
+++ /dev/null
@@ -1,50 +0,0 @@
-;;; -----------------------------------------------------------------
-;;; Merge two lists of numbers which are already in increasing order
-
-(define merge-lists
-    (lambda (l1 l2)
-        (if (null? l1)
-            l2
-            (if (null? l2)
-                l1
-                (if (< (car l1) (car l2))
-                    (cons (car l1) (merge-lists (cdr l1) l2))
-                    (cons (car l2) (merge-lists (cdr l2) l1)))))))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in even positions
-
-(define even-numbers
-    (lambda (l)
-        (if (null? l)
-            '()
-            (if (null? (cdr l))
-                '()
-                (cons (car (cdr l)) (even-numbers (cdr (cdr l))))))))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in odd positions
-
-(define odd-numbers
-    (lambda (l)
-        (if (null? l)
-            '()
-            (if (null? (cdr l))
-                (list (car l))
-                (cons (car l) (odd-numbers (cdr (cdr l))))))))
-
-;;; ---------------------------------------------------------------------
-;;; Use the procedures above to create a simple and efficient merge-sort
-
-(define merge-sort
-    (lambda (l)
-        (if (null? l)
-            l
-            (if (null? (cdr l))
-                l
-                (merge-lists
-                (merge-sort (odd-numbers l))
-                (merge-sort (even-numbers l)))))))
-
-(define result (merge-sort '(5 1 4 2 3)))
-(assert! (equal? result '(1 2 3 4 5)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/ncsubseq.scm b/crates/steel-core/src/tests/success/ncsubseq.scm
deleted file mode 100644
index 7d01a9b9e..000000000
--- a/crates/steel-core/src/tests/success/ncsubseq.scm
+++ /dev/null
@@ -1,27 +0,0 @@
-(define (ncsubseq lst)
-  (let recurse ([s 0] [lst lst])
-    (if (null? lst)
-        (if (>= s 3) '(()) '())
-        (let ([x (car lst)] [xs (cdr lst)])
-          (if (even? s)
-              (append (map (lambda (ys) (cons x ys)) (recurse (+ s 1) xs)) (recurse s xs))
-              (append (map (lambda (ys) (cons x ys)) (recurse s xs)) (recurse (+ s 1) xs)))))))
-
-(assert! (equal? (ncsubseq '(1 2 3)) '((1 3))))
-(assert! (equal? (ncsubseq '(1 2 3 4)) '((1 2 4) (1 3 4) (1 3) (1 4) (2 4))))
-(assert! (equal? (ncsubseq '(1 2 3 4 5))
-                 '((1 2 3 5) (1 2 4 5)
-                             (1 2 4)
-                             (1 2 5)
-                             (1 3 4 5)
-                             (1 3 4)
-                             (1 3 5)
-                             (1 3)
-                             (1 4 5)
-                             (1 4)
-                             (1 5)
-                             (2 3 5)
-                             (2 4 5)
-                             (2 4)
-                             (2 5)
-                             (3 5))))
diff --git a/crates/steel-core/src/tests/success/numbers.scm b/crates/steel-core/src/tests/success/numbers.scm
deleted file mode 100644
index 45c951ec4..000000000
--- a/crates/steel-core/src/tests/success/numbers.scm
+++ /dev/null
@@ -1,54 +0,0 @@
-; #lang racket
-
-(define (flatten lst)
-;   (displayln "inside flatten")
-  (cond ((null? lst) '())
-        ((list? lst)
-         (append (flatten (car lst)) (flatten (cdr lst))))
-        (else (list lst))))
-
-
-(define (_list-for-each func lsts)
-    ; (displayln "calling list for each")
-    ; (displayln func)
-    ; (displayln lsts)
-    ; (displayln lsts)
-    (if (null? (flatten lsts))
-        void
-        (begin
-            (apply func (map car lsts))
-            (if (null? lsts)
-                void
-                (_list-for-each func (map cdr lsts))))))
-
-(define (for-each func . lsts)
-    ; (displayln "calling normal for each")
-    ; (display "func: ") (displayln func)
-    ; (display "args: ") (displayln lsts)
-    (_list-for-each func lsts))
-
-(define x  2.0)
-(define xi 0.5)
-(define y  4.0)
-(define yi 0.25)
-(define z  (+ x y))
-(define zi (/ 1 (+ x y)))
-
-(define number (list x y z))
-(define inverse (list xi yi zi))
-
-(define (multiplier n1 n2) (lambda (m) (* n1 n2 m)))
-
-(define m 0.5)
-(define (go n1 n2)
-  (for-each (lambda (n1 n2)
-              (displayln ((multiplier n1 n2) m)))
-            n1 n2))
-
-
-; (define (go n1 n2)
-;   (for-each (lambda (x y)
-;               (displayln (list x y)))
-;             n1 n2))
-
-; (go number inverse)
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/pascals.scm b/crates/steel-core/src/tests/success/pascals.scm
deleted file mode 100644
index 67b7f9e12..000000000
--- a/crates/steel-core/src/tests/success/pascals.scm
+++ /dev/null
@@ -1,9 +0,0 @@
-(define (next-row row)
-  (map + (cons 0 row) (append row '(0))))
-
-(define (triangle row rows)
-  (if (= rows 0) '() (cons row (triangle (next-row row) (- rows 1)))))
-
-; (triangle (list 1) 5)
-
-; (assert! (equal? (triangle (list 1) 5) '((1) (1 1) (1 2 1) (1 3 3 1) (1 4 6 4 1))))
diff --git a/crates/steel-core/src/tests/success/permutations.scm b/crates/steel-core/src/tests/success/permutations.scm
deleted file mode 100644
index 8c262c758..000000000
--- a/crates/steel-core/src/tests/success/permutations.scm
+++ /dev/null
@@ -1,41 +0,0 @@
-(define (insert l n e)
-  (if (= 0 n) (cons e l) (cons (car l) (insert (cdr l) (- n 1) e))))
-
-(define (seq start end)
-  (if (= start end) (list end) (cons start (seq (+ start 1) end))))
-
-(define (permute l)
-  (if (null? l)
-      '(())
-      (apply append
-             (map (lambda (p) (map (lambda (n) (insert p n (car l))) (seq 0 (length p))))
-                  (permute (cdr l))))))
-
-(assert! (equal? (permute (range 0 2)) '((0 1) (1 0))))
-
-(assert! (equal? (permute (range 0 3)) '((0 1 2) (1 0 2) (1 2 0) (0 2 1) (2 0 1) (2 1 0))))
-
-(assert! (equal? (permute (range 0 4))
-                 '((0 1 2 3) (1 0 2 3)
-                             (1 2 0 3)
-                             (1 2 3 0)
-                             (0 2 1 3)
-                             (2 0 1 3)
-                             (2 1 0 3)
-                             (2 1 3 0)
-                             (0 2 3 1)
-                             (2 0 3 1)
-                             (2 3 0 1)
-                             (2 3 1 0)
-                             (0 1 3 2)
-                             (1 0 3 2)
-                             (1 3 0 2)
-                             (1 3 2 0)
-                             (0 3 1 2)
-                             (3 0 1 2)
-                             (3 1 0 2)
-                             (3 1 2 0)
-                             (0 3 2 1)
-                             (3 0 2 1)
-                             (3 2 0 1)
-                             (3 2 1 0))))
diff --git a/crates/steel-core/src/tests/success/quicksort.scm b/crates/steel-core/src/tests/success/quicksort.scm
deleted file mode 100644
index 9a57eac48..000000000
--- a/crates/steel-core/src/tests/success/quicksort.scm
+++ /dev/null
@@ -1,16 +0,0 @@
-;; Current append only accepts 2 arguments, need to make it accept 3
-(define (append-three one two three)
-    (-> one
-        (append two)
-        (append three)))
-
-(define (quicksort l gt?)
-  (if (null? l)
-      '()
-      (append-three (quicksort (filter (lambda (x) (gt? (car l) x)) (cdr l)) gt?)
-              (list (car l))
-              (quicksort (filter (lambda (x) (not (gt? (car l) x))) (cdr l)) gt?))))
-
-(define output (quicksort '(1 3 5 7 9 8 6 4 2) >))
-
-(assert! (equal? output '(1 2 3 4 5 6 7 8 9)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/read.scm b/crates/steel-core/src/tests/success/read.scm
deleted file mode 100644
index 611f66668..000000000
--- a/crates/steel-core/src/tests/success/read.scm
+++ /dev/null
@@ -1,2 +0,0 @@
-(define read-value (read! "1 2 3 4 5"))
-(assert! (equal? '(1 2 3 4 5) read-value))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/require_alias.scm b/crates/steel-core/src/tests/success/require_alias.scm
deleted file mode 100644
index 7088a0c6f..000000000
--- a/crates/steel-core/src/tests/success/require_alias.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(require (only-in "steel/result" map-ok (Ok Foo) (Err Bar)))
-
-(define my-result (Foo 10))
-
-(assert! (equal? (map-ok my-result (lambda (x) (+ x 10))) (Foo 20)))
-(assert! (equal? (map-ok (Bar 10) (lambda (x) (+ x 10))) (Bar 10)))
diff --git a/crates/steel-core/src/tests/success/require_only_in.scm b/crates/steel-core/src/tests/success/require_only_in.scm
deleted file mode 100644
index f9bd6aee1..000000000
--- a/crates/steel-core/src/tests/success/require_only_in.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(require (only-in "steel/result" map-ok Ok Err))
-
-(define my-result (Ok 10))
-
-(assert! (equal? (map-ok my-result (lambda (x) (+ x 10))) (Ok 20)))
-(assert! (equal? (map-ok (Err 10) (lambda (x) (+ x 10))) (Err 10)))
diff --git a/crates/steel-core/src/tests/success/require_prefix.scm b/crates/steel-core/src/tests/success/require_prefix.scm
deleted file mode 100644
index 5639614b9..000000000
--- a/crates/steel-core/src/tests/success/require_prefix.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(require (prefix-in result/ "steel/result"))
-
-(define my-result (Ok 10))
-
-(assert! (equal? (result/map-ok my-result (lambda (x) (+ x 10))) (result/Ok 20)))
-(assert! (equal? (result/map-ok (result/Err 10) (lambda (x) (+ x 10))) (result/Err 10)))
diff --git a/crates/steel-core/src/tests/success/result.scm b/crates/steel-core/src/tests/success/result.scm
deleted file mode 100644
index a207f6a40..000000000
--- a/crates/steel-core/src/tests/success/result.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(require "steel/result")
-
-(define my-result (Ok 10))
-
-(assert! (equal? (map-ok my-result (lambda (x) (+ x 10))) (Ok 20)))
-(assert! (equal? (map-ok (Err 10) (lambda (x) (+ x 10))) (Err 10)))
diff --git a/crates/steel-core/src/tests/success/search.scm b/crates/steel-core/src/tests/success/search.scm
deleted file mode 100644
index c6b76973f..000000000
--- a/crates/steel-core/src/tests/success/search.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-(define haystack '("Zig" "Zag" "Wally" "Ronald" "Bush" "Krusty" "Charlie" "Bush" "Bozo"))
-
-(define index-of
-  (lambda (needle hackstack)
-    (let ([tail (member needle haystack)])
-      (if tail (- (length haystack) (length tail)) (error 'needle-missing)))))
-
-(define last-index-of
-  (lambda (needle hackstack)
-    (let ([tail (member needle (reverse haystack))])
-      (if tail (- (length tail) 1) (error 'needle-missing)))))
-
-(assert! (equal? (index-of "Bush" haystack) 4))
-(assert! (equal? (last-index-of "Bush" haystack) 7))
diff --git a/crates/steel-core/src/tests/success/set_local.scm b/crates/steel-core/src/tests/success/set_local.scm
deleted file mode 100644
index c25489439..000000000
--- a/crates/steel-core/src/tests/success/set_local.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define (foo a)
-    (set! a 100)
-    a)
-
-(assert! (equal? (foo 50) 100))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/set_tail_call.scm b/crates/steel-core/src/tests/success/set_tail_call.scm
deleted file mode 100644
index b6d2dfdcc..000000000
--- a/crates/steel-core/src/tests/success/set_tail_call.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-(define (test x) 
-    (set! test (lambda (x) 100)) 
-    (if (= x 10)
-        x
-        (test (+ x 1))))
-
-(assert! (equal? (test 0) 100))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/shift_reset.scm b/crates/steel-core/src/tests/success/shift_reset.scm
deleted file mode 100644
index 995afad2b..000000000
--- a/crates/steel-core/src/tests/success/shift_reset.scm
+++ /dev/null
@@ -1,77 +0,0 @@
-(define-syntax reset 
-    (syntax-rules ()
-        ((reset ?e) (*reset (lambda () ?e)))))
-
-(define-syntax shift 
-    (syntax-rules ()
-        ((shift ?k ?e) (*shift (lambda (?k) ?e)))))
-
-(define (*meta-continuation* v)
-    (error "You forgot the top-level reset..."))
-
-(define (*abort thunk) 
-    (let ((v (thunk)))
-        (*meta-continuation* v)))
-
-(define (*reset thunk)
-    (let ((mc *meta-continuation*))
-        (call/cc (lambda (k)
-            (begin
-                (set! *meta-continuation*
-                        (lambda (v)
-                            (set! *meta-continuation* mc) 
-                            (k v)))
-                (*abort thunk))))))
-
-(define (*shift f)
-    (call/cc
-        (lambda (k)
-            (*abort (lambda ()
-                        (f (lambda (v)
-                                (reset (k v)))))))))
-
-(define (void) void)
-
-(assert! (equal? 
-            (* 2 (reset (+ 1 (shift k (k 5)))))
-            12))
-
-(assert! (equal?
-            (* 2 (reset (+ 1 (shift k 5))))
-            10))
-
-(assert! (equal?
-            (+ 1 (reset (* 2 (shift k (k (k 4))))))
-            17))
-
-(assert! (equal? 
-             (reset
-                (begin
-                    (shift k (cons 1 (k (void)))) ;; (1)
-                    '()))
-             '(1)))
-
-(assert! (equal?
-            (reset
-                (begin
-                    (shift k (cons 1 (k (void))))
-                    (shift k (cons 2 (k (void))))
-                    '()))
-            '(1 2)))
-
-(assert! (equal?
-            (reset
-                (begin
-                    (shift k (cons 1 (k (void))))
-                    (list 2)))
-            '(1 2)))
-
-(define (yield x) (shift k (cons x (k (void)))))
-
-(assert! (equal?
-             (reset (begin
-                (yield 1)
-                (yield 2)
-                (yield 3)
-                '()))    ;; (list 1 2 3)))
-            '(1 2 3)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/sicp_example.scm b/crates/steel-core/src/tests/success/sicp_example.scm
deleted file mode 100644
index 9f7643707..000000000
--- a/crates/steel-core/src/tests/success/sicp_example.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(define (a-plus-abs-b a b)
-  ((if (> b 0) + -) a b))
-
-;; 3
-(assert! (equal? 3 (a-plus-abs-b 1 2)))
-(assert! (equal? 3 (a-plus-abs-b 1 -2)))
diff --git a/crates/steel-core/src/tests/success/sieve.scm b/crates/steel-core/src/tests/success/sieve.scm
deleted file mode 100644
index 3747bf221..000000000
--- a/crates/steel-core/src/tests/success/sieve.scm
+++ /dev/null
@@ -1,24 +0,0 @@
-(define (sieve n)
-    (define (aux u v)
-        (let ((p (car v)))
-        (if (> (* p p) n)
-            (rev-append u v)
-            (aux (cons p u)
-            (wheel '() (cdr v) (* p p) p)))))
-    (aux '(2)
-        (range-s '() (if (odd? n) n (- n 1)))))
-
-
-(define (wheel u v a p)
-    (cond ((null? v) (reverse u))
-                    ((= (car v) a) (wheel u (cdr v) (+ a p) p))
-                    ((> (car v) a) (wheel u v (+ a p) p))
-                    (else (wheel (cons (car v) u) (cdr v) a p))))
-
-(define (rev-append u v)
-    (if (null? u) v (rev-append (cdr u) (cons (car u) v))))
-
-(define (range-s v k)
-    (if (< k 3) v (range-s (cons k v) (- k 2))))
-
-(assert! (equal? 168 (length (sieve 1000))))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/simple_stream.scm b/crates/steel-core/src/tests/success/simple_stream.scm
deleted file mode 100644
index 39adba59e..000000000
--- a/crates/steel-core/src/tests/success/simple_stream.scm
+++ /dev/null
@@ -1,13 +0,0 @@
-(define (stream-cdr stream)
-  ((#%stream-cdr stream)))
-
-(define (integers n)
-  (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(define (stream-section n stream)
-  (displayln stream)
-  (cond
-    [(= n 0) '()]
-    [else (cons (stream-car stream) (stream-section (- n 1) (stream-cdr stream)))]))
-
-(assert! (equal? (list 0 1 2 3 4) (stream-section 5 (integers 0))))
diff --git a/crates/steel-core/src/tests/success/simple_stream_with_map.scm b/crates/steel-core/src/tests/success/simple_stream_with_map.scm
deleted file mode 100644
index c95518b18..000000000
--- a/crates/steel-core/src/tests/success/simple_stream_with_map.scm
+++ /dev/null
@@ -1,17 +0,0 @@
-(define (stream-cdr stream)
-  ((#%stream-cdr stream)))
-
-(define (integers n)
-  (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(define (stream-section n stream)
-  (cond
-    [(= n 0) '()]
-    [else (cons (stream-car stream) (stream-section (- n 1) (stream-cdr stream)))]))
-
-(define (map-stream func s)
-  (cond
-    [(stream-empty? s) s]
-    [else (stream-cons (func (stream-car s)) (lambda () (map-stream func (stream-cdr s))))]))
-
-(assert! (equal? (list 10 10 10 10 10) (stream-section 5 (map-stream (lambda (x) 10) (integers 0)))))
diff --git a/crates/steel-core/src/tests/success/simple_stream_with_mapping.scm b/crates/steel-core/src/tests/success/simple_stream_with_mapping.scm
deleted file mode 100644
index caa5dcdd9..000000000
--- a/crates/steel-core/src/tests/success/simple_stream_with_mapping.scm
+++ /dev/null
@@ -1,9 +0,0 @@
-(define (stream-cdr stream)
-  ((#%stream-cdr stream)))
-
-(define (integers n)
-  (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(assert!
- (equal? (list 1 2 3 4 5)
-         (transduce (integers 0) (compose (mapping (lambda (x) (+ x 1))) (taking 5)) (into-list))))
diff --git a/crates/steel-core/src/tests/success/simple_stream_with_transduce_operation.scm b/crates/steel-core/src/tests/success/simple_stream_with_transduce_operation.scm
deleted file mode 100644
index af285db48..000000000
--- a/crates/steel-core/src/tests/success/simple_stream_with_transduce_operation.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-(define (stream-cdr stream)
-  ((#%stream-cdr stream)))
-
-(define (integers n)
-  (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(assert! (equal? 10 (transduce (integers 0) (taking 5) (into-reducer + 0))))
diff --git a/crates/steel-core/src/tests/success/simple_stream_with_transducer.scm b/crates/steel-core/src/tests/success/simple_stream_with_transducer.scm
deleted file mode 100644
index 7115c30ac..000000000
--- a/crates/steel-core/src/tests/success/simple_stream_with_transducer.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-(define (stream-cdr stream)
-  ((#%stream-cdr stream)))
-
-(define (integers n)
-  (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(assert! (equal? (list 0 1 2 3 4) (transduce (integers 0) (taking 5) (into-list))))
diff --git a/crates/steel-core/src/tests/success/stack_state.scm b/crates/steel-core/src/tests/success/stack_state.scm
deleted file mode 100644
index 9069f4e12..000000000
--- a/crates/steel-core/src/tests/success/stack_state.scm
+++ /dev/null
@@ -1,56 +0,0 @@
-(define (push element)
-    (lambda (stack)
-        (list '() (cons element stack))))
-
-(define (pop)
-    (lambda (stack)
-        (let ((element (car stack))
-            (new-stack (cdr stack)))
-        (list element new-stack))))
-
-(define stack-of cadr)
-(define value-of car)
-
-(define (>>= stack-action continuation)
-    (lambda (stack)
-        (let ((result (stack-action stack)))
-        ((continuation (value-of result)) (stack-of result)))))
-
-(define (return value)
-    (lambda (stack)
-        (list value stack)))
-
-(define (run-stack computation stack)
-    (computation stack))
-
-(define (eval-stack computation stack)
-    (value-of (computation stack)))
-
-(define (exec-stack computation stack)
-    (stack-of (computation stack)))
-
-(define computation-1 (>>= (push 4) (lambda (_)
-                    (>>= (push 5) (lambda (_)
-                    (>>= (pop)    (lambda (a)
-                    (>>= (pop)    (lambda (b)
-                    (return (list a b)))))))))))
-
-(define computation-2 (>>= (push 2) (lambda (_)
-                    (>>= (push 3) (lambda (_)
-                    (>>= (pop)    (lambda (a)
-                    (>>= (pop)    (lambda (b)
-                    (return (list a b)))))))))))
-
-(define (main)
-    (let ((initial-stack '())
-            (composed (>>= computation-1 (lambda (a)
-                    (>>= computation-2 (lambda (b)
-                    (return (list a b))))))))
-        (begin
-            (display "Result: ")
-            (define result (eval-stack composed initial-stack))
-            (display result)
-            (newline)
-            result)))
-
-; (assert! (equal? '((5 4) (3 2)) (main)))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/stack_struct.scm b/crates/steel-core/src/tests/success/stack_struct.scm
deleted file mode 100644
index 3be6ccc38..000000000
--- a/crates/steel-core/src/tests/success/stack_struct.scm
+++ /dev/null
@@ -1,75 +0,0 @@
-;; destruct works like so:
-;; (destruct (a b c) value)
-;;  ...
-;; (define a (car value)
-;; (define b (car (cdr value)))
-;; (define c (car (cdr (cdr value))))
-(define-syntax destruct
-  (syntax-rules ()
-    [(destruct (var) ret-value)
-     (define (datum->syntax var)
-       (car ret-value))]
-    [(destruct (var1 var2 ...) ret-value)
-     (begin
-       (define (datum->syntax var1)
-         (car ret-value))
-       (destruct (var2 ...) (cdr ret-value)))]))
-
-(define-syntax def-method
-  (syntax-rules ()
-    [(def-method struct-name (define/method (a this b ...) body ...))
-     (define ((datum->syntax struct-name . a) this b ...)
-       (unless ((datum->syntax struct-name ?) this)
-         (error! (datum->syntax struct-name . a) "method takes a value of" struct-name "given" this))
-       body ...)]))
-
-;; impl block asserts that each function contains the struct type given as the first argument
-;; This is why later down we use the thread first vs. the thread last given above
-;;
-;; However, take note that a recursive call will not work properly in this, best to be used as an interface
-;; since it does not transform the name of the recursive call
-(define-syntax impl
-  (syntax-rules ()
-    [(impl struct-name (define/method (a this b ...) body ...) c cs ...)
-     (begin
-       (def-method struct-name (define/method (a this b ...) body ...))
-       (impl struct-name c cs ...))]
-    [(impl struct-name (define/method (a this b ...) body ...))
-     (def-method struct-name (define/method (a this b ...) body ...))]))
-
-(struct Stack (lst) #:transparent)
-(impl
- Stack
- ;; Change this to be something like (define/method)
- ;; as to disambiguate it from the base define
- (define/method (pop stack)
-                (define contents (Stack-lst stack))
-                (if (null? contents) '(#f '()) (list (car contents) (cdr contents))))
- (define/method (push stack value) (define contents (Stack-lst stack)) (Stack (cons value contents))))
-
-(-> (Stack '()) (Stack.push 1) (Stack.push 2) (Stack.push 3) (Stack.push 4) (Stack.pop))
-
-; (Stack.pop
-;     (%plain-let
-;         ((x (%plain-let
-;                 ((x (%plain-let
-;                         ((x (%plain-let ((x (Stack (quote ()))))
-;                                 (Stack.push x 1))))
-;                             (Stack.push x 2))))
-;                             (Stack.push x 3))))
-;                             (Stack.push x 4)))
-
-; (define test-stack (Stack '()))
-
-; (destruct (pop-val-test new-stack-test)
-;         (-> test-stack
-;             (Stack.push 1)
-;             (Stack.push 2)
-;             (Stack.push 3)
-;             (Stack.push 4)
-;             (Stack.pop)))
-
-; pop-val-test ;; => 4
-; new-stack-test ;; => '(3 2 1)
-; (assert! (equal? 4 pop-val-test))
-; (assert! (equal? '(3 2 1) new-stack-test))
diff --git a/crates/steel-core/src/tests/success/stack_test_with_contract.scm b/crates/steel-core/src/tests/success/stack_test_with_contract.scm
deleted file mode 100644
index b69dacec0..000000000
--- a/crates/steel-core/src/tests/success/stack_test_with_contract.scm
+++ /dev/null
@@ -1,48 +0,0 @@
-;; destruct works like so:
-;; (destruct (a b c) value)
-;;  ...
-;; (define a (car value))
-;; (define b (car (cdr value)))
-;; (define c (car (cdr (cdr value))))
-(define-syntax destruct
-(syntax-rules ()
-    [(destruct (var) ret-value)
-    (define (datum->syntax var) (car ret-value))]
-    [(destruct (var1 var2 ...) ret-value)
-    (begin (define (datum->syntax var1) (car ret-value))
-            (destruct (var2 ...) (cdr ret-value)))]))
-
-
-(define (any? v) #t)
-(define stack? list?)
-(define (pair? s)
-(and (list? s) (= (length s) 2)))
-
-
-(define (make-stack) '())
-
-(define/contract (pop stack)
-    (->/c stack? pair?)
-    (if (null? stack)
-        '(#f '())
-        (list (car stack) (cdr stack))))
-
-;; value -> stack -> stack
-(define push cons)
-
-;; instantiate an empty stack
-(define my-stack (make-stack))
-
-;; Bind the last few values from the stack
-;; Push the values 1, 2, 3, 4, then pop and return the value and the stack
-(destruct (pop-val new-stack)
-        (->> my-stack
-            (push 1)
-            (push 2)
-            (push 3)
-            (push 4)
-            (pop)))
-
-pop-val ;; => 4
-new-stack ;; => '(3 2 1)
-(assert! (equal? pop-val 4))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/string_append.scm b/crates/steel-core/src/tests/success/string_append.scm
deleted file mode 100644
index 36a3922ea..000000000
--- a/crates/steel-core/src/tests/success/string_append.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-(assert! (equal? (string-append) ""))
-(assert! (equal? (string-append "foo") "foo"))
-(assert! (equal? (string-append "foo" "bar") "foobar"))
diff --git a/crates/steel-core/src/tests/success/structs.scm b/crates/steel-core/src/tests/success/structs.scm
deleted file mode 100644
index bf2691921..000000000
--- a/crates/steel-core/src/tests/success/structs.scm
+++ /dev/null
@@ -1,32 +0,0 @@
-(struct Foo (a b c))
-
-(assert! (equal? (Foo 10 20 30) (Foo 10 20 30)))
-
-(assert! (Foo? (Foo 10 20 30)))
-(assert! (not (Foo? 10)))
-
-(define my-foo (Foo 10 20 30))
-
-(assert! (equal? (Foo-a my-foo) 10))
-(assert! (equal? (Foo-b my-foo) 20))
-(assert! (equal? (Foo-c my-foo) 30))
-
-(struct Bar (a b c) #:transparent)
-
-(assert! (equal? (trim (to-string (Bar 10 20 30))) "(Bar 10 20 30)"))
-
-(struct Baz (a) #:transparent #:mutable)
-
-(define my-baz (Baz 10))
-
-(assert! (equal? (Baz-a my-baz) 10))
-
-(set-Baz-a! my-baz 50)
-
-(assert! (equal? (Baz-a my-baz)))
-
-(struct Callable (func) #:transparent #:prop:procedure 0)
-
-(define callable (Callable (lambda (x) (+ x 10))))
-
-(assert! (equal? (callable 100) 110))
diff --git a/crates/steel-core/src/tests/success/threads.scm b/crates/steel-core/src/tests/success/threads.scm
deleted file mode 100644
index 2493692ec..000000000
--- a/crates/steel-core/src/tests/success/threads.scm
+++ /dev/null
@@ -1,13 +0,0 @@
-(define (foo x)
-  (vector 10 20 30 40 x))
-
-;; TODO: This actually won't work now - displayln references (current-output-port)
-;; which is a parameter, which allocates a mutable variable. So for this to work:
-;; 1. Certain kinds of ports need to be transferrable across threads
-;; 2. Mutable variables need to be transferrable across threads, by being allocated
-;;    in the target threads heap
-;; 3. Parameters somehow need to be "reinitialized" to have a default value. This should
-;;    be doable by having some kind of thread initialization function (like how thread locals work)
-
-;; Closure should get serialized and sent across the thread
-(thread-join! (spawn-thread! (lambda () (stdout-simple-displayln (vector-ref (foo 100) 4)))))
diff --git a/crates/steel-core/src/tests/success/transducer_over_streams.scm b/crates/steel-core/src/tests/success/transducer_over_streams.scm
deleted file mode 100644
index 3e16781ea..000000000
--- a/crates/steel-core/src/tests/success/transducer_over_streams.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(define (integers n)
-        (stream-cons n (lambda () (integers (+ 1 n)))))
-(define result (transduce (integers 0) (taking 15) (into-list)))
-(define expected '(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14))
-(assert! (equal? result expected))
\ No newline at end of file
diff --git a/crates/steel-core/src/tests/success/tree_traversal.scm b/crates/steel-core/src/tests/success/tree_traversal.scm
deleted file mode 100644
index ea85178ed..000000000
--- a/crates/steel-core/src/tests/success/tree_traversal.scm
+++ /dev/null
@@ -1,54 +0,0 @@
-(define (preorder tree)
-  (if (null? tree) '() (append (list (car tree)) (preorder (cadr tree)) (preorder (caddr tree)))))
-
-(define (inorder tree)
-  (if (null? tree) '() (append (inorder (cadr tree)) (list (car tree)) (inorder (caddr tree)))))
-
-(define (postorder tree)
-  (if (null? tree) '() (append (postorder (cadr tree)) (postorder (caddr tree)) (list (car tree)))))
-
-(define (level-order tree)
-  (define lst '())
-  (define (traverse nodes)
-    (when (pair? nodes)
-      (let ([next-nodes '()])
-        (let loop ([p nodes])
-          (when (not (null? p))
-
-            (set! lst (cons (caar p) lst))
-            (let* ([n '()]
-                   [n (if (null? (cadar p)) n (cons (cadar p) n))]
-                   [n (if (null? (caddar p)) n (cons (caddar p) n))])
-              (set! next-nodes (append n next-nodes)))
-
-            (loop (cdr p))))
-
-        (traverse (reverse next-nodes)))))
-  (if (null? tree)
-      '()
-      (begin
-        (traverse (list tree))
-        (reverse lst))))
-
-(define (demonstration tree)
-  (define (display-values lst)
-    (let loop ([p lst])
-      (when (not (null? p))
-        (display (car p))
-        (when (pair? (cdr p))
-          (display " "))
-
-        (loop (cdr p))))
-    (newline))
-  (display "preorder:    ")
-  (display-values (preorder tree))
-  (display "inorder:     ")
-  (display-values (inorder tree))
-  (display "postorder:   ")
-  (display-values (postorder tree))
-  (display "level-order: ")
-  (display-values (level-order tree)))
-
-(define the-task-tree '(1 (2 (4 (7 () ()) ()) (5 () ())) (3 (6 (8 () ()) (9 () ())) ())))
-
-(demonstration the-task-tree)
diff --git a/crates/steel-core/src/tests/success/trie_sort.scm b/crates/steel-core/src/tests/success/trie_sort.scm
deleted file mode 100644
index b4a96f39d..000000000
--- a/crates/steel-core/src/tests/success/trie_sort.scm
+++ /dev/null
@@ -1,122 +0,0 @@
-(struct trie (char children end-word? word-up-to))
-
-;; Rename functions for the sake of compatibility
-(define empty (list))
-(define empty-trie (trie void empty #f empty))
-
-;; Throw in a mediocre flatten definition
-(define (flatten lst)
-  (cond
-    [(null? lst) empty]
-    [(list? lst) (append (flatten (car lst)) (flatten (cdr lst)))]
-    [else (list lst)]))
-
-;; contract: (listof char?) (listof tries?) integer? -> (listof trie?)
-(define (create-children char-list lst prefix-chars)
-  (cond
-    [(= (length char-list) 1) (handle-last-letter char-list lst prefix-chars)]
-    ;; you are in the middle of the word
-    [else (handle-intern-letter char-list lst prefix-chars)]))
-
-;; contract: (listof char?) (listof trie?) integer? -> (listof trie?)
-(define (handle-last-letter char-list lst prefix-chars)
-  (define char (first char-list))
-  ; (define next-prefix (append prefix-chars (list char)))
-  (define next-prefix (push-back prefix-chars char))
-  (cond
-    ;; children are empty, return list of empty children
-    [(empty? lst) (list (trie char empty #t next-prefix))]
-    ;; less than, put it to the left
-    [(< char (trie-char (first lst))) (cons (trie char empty #t next-prefix) lst)]
-    [(= char (trie-char (first lst))) ;; equal, step down a level
-     (cons (trie char (trie-children (first lst)) #t next-prefix) (rest lst))]
-    ;; move to the right
-    [else (cons (first lst) (create-children char-list (rest lst) prefix-chars))]))
-
-;; contract: (listof char?) (listof trie?) integer? -> (listof trie?)
-(define (handle-intern-letter char-list lst prefix-chars)
-  (define char (first char-list))
-  ; (define next-prefix (append prefix-chars (list char)))
-  (define next-prefix (push-back prefix-chars char))
-  (cond
-    [(empty? lst) ;; no children, pop off front and step down
-     (list (trie char (create-children (rest char-list) empty next-prefix) #f next-prefix))]
-    [(< char (trie-char (first lst))) ;; place where it is, pop off front and go
-     (cons (trie char (create-children (rest char-list) empty next-prefix) #f next-prefix) lst)]
-    [(equal? char (trie-char (first lst))) ;; equal, step down
-     (cons (trie char
-                 (create-children (rest char-list) (trie-children (first lst)) next-prefix)
-                 (trie-end-word? (first lst))
-                 (trie-word-up-to (first lst)))
-           (rest lst))]
-    ; move to the right
-    [else (cons (first lst) (create-children char-list (rest lst) prefix-chars))]))
-
-;; contract: trie? string? integer? -> trie?
-(define (insert root-trie word)
-  (define char-list (string->list word))
-  (trie (trie-char root-trie)
-        (create-children char-list (trie-children root-trie) empty)
-        (trie-end-word? root-trie)
-        (trie-word-up-to root-trie)))
-
-; contract: trie? trie? -> boolean?
-(define (trie<? trie-node1 trie-node2)
-  (< (trie-char trie-node1) (trie-char trie-node2)))
-
-;; contract: trie? (listof string?) -> trie?
-(define (build-trie-from-list-of-words trie list-of-words)
-  (cond
-    [(= (length list-of-words) 1) (insert trie (first list-of-words))]
-    [else (build-trie-from-list-of-words (insert trie (first list-of-words)) (rest list-of-words))]))
-
-;; ------------------ SORTING ---------------------- ;;
-
-(define (trie-sort list-of-words)
-  (define new-trie (build-trie-from-list-of-words empty-trie list-of-words))
-  (pre-order new-trie))
-
-; THIS ONE WORKS (using con and flatten)
-;; contract: trie? -> (listof string?)
-(define (pre-order trie-node)
-  (if (trie-end-word? trie-node)
-      (cons (list->string (trie-word-up-to trie-node))
-            (flatten (map pre-order (trie-children trie-node))))
-      (flatten (map pre-order (trie-children trie-node)))))
-
-(define test-list
-  (list "suppose"
-        "believe"
-        "changeable"
-        "absent"
-        "busy"
-        "float"
-        "debonair"
-        "throat"
-        "grey"
-        "use"
-        "measure"
-        "van"
-        "thirsty"
-        "notify"
-        "star"))
-
-(define expected-list
-  (list "absent"
-        "believe"
-        "busy"
-        "changeable"
-        "debonair"
-        "float"
-        "grey"
-        "measure"
-        "notify"
-        "star"
-        "suppose"
-        "thirsty"
-        "throat"
-        "use"
-        "van"))
-
-(define trie1 (build-trie-from-list-of-words empty-trie test-list))
-(assert! (equal? expected-list (trie-sort test-list)))
diff --git a/crates/steel-core/src/tests/success/y_combinator.scm b/crates/steel-core/src/tests/success/y_combinator.scm
deleted file mode 100644
index 01873e0fa..000000000
--- a/crates/steel-core/src/tests/success/y_combinator.scm
+++ /dev/null
@@ -1,25 +0,0 @@
-(define Y 
-    (lambda (f)
-        ((lambda (x) (x x))
-        (lambda (x) (f (lambda (y) ((x x) y)))))))
-
-;; head-recursive factorial
-(define fac                ; fac = (Y f) = (f      (lambda a (apply (Y f) a))) 
-    (Y (lambda (r)           ;     = (lambda (x) ... (r     (- x 1)) ... )
-            (lambda (x)         ;        where   r    = (lambda a (apply (Y f) a))
-            (if (< x 2)       ;               (r ... ) == ((Y f) ... )
-                1             ;     == (lambda (x) ... (fac  (- x 1)) ... )
-                (* x (r (- x 1))))))))
-
-
-; double-recursive Fibonacci
-(define fib
-    (Y (lambda (f)
-            (lambda (x)
-            (if (< x 2)
-                x
-                (+ (f (- x 1)) (f (- x 2))))))))
-
-
-(assert! (equal? 720 (fac 6)))
-(assert! (equal? 233 (fib 13)))
\ No newline at end of file
diff --git a/crates/steel-core/src/values/closed.rs b/crates/steel-core/src/values/closed.rs
deleted file mode 100644
index 816d6b018..000000000
--- a/crates/steel-core/src/values/closed.rs
+++ /dev/null
@@ -1,807 +0,0 @@
-use std::{
-    cell::RefCell,
-    rc::{Rc, Weak},
-};
-
-use crate::{
-    rvals::{OpaqueIterator, SteelVector},
-    steel_vm::vm::{Continuation, ContinuationMark},
-    values::lists::List,
-};
-use num::BigInt;
-
-use crate::{
-    gc::{unsafe_erased_pointers::OpaqueReference, Gc},
-    rvals::{
-        cycles::BreadthFirstSearchSteelValVisitor, BoxedAsyncFunctionSignature, CustomType,
-        FunctionSignature, FutureResult, MutFunctionSignature, SteelHashMap, SteelHashSet,
-        SteelString, Syntax,
-    },
-    steel_vm::vm::BuiltInSignature,
-    values::functions::ByteCodeLambda,
-    SteelVal,
-};
-
-use super::{
-    functions::BoxedDynFunction,
-    lazy_stream::LazyStream,
-    port::SteelPort,
-    structs::UserDefinedStruct,
-    transducers::{Reducer, Transducer},
-};
-
-const GC_THRESHOLD: usize = 256 * 1000;
-const GC_GROW_FACTOR: usize = 2;
-const RESET_LIMIT: usize = 5;
-
-thread_local! {
-    static ROOTS: RefCell<Roots> = RefCell::new(Roots::default());
-}
-
-#[derive(Default)]
-pub struct Roots {
-    generation: usize,
-    offset: usize,
-    roots: fxhash::FxHashMap<(usize, usize), SteelVal>,
-}
-
-#[derive(Debug, PartialEq, Eq, Hash)]
-pub struct RootToken {
-    generation: usize,
-    offset: usize,
-}
-
-impl Drop for RootToken {
-    fn drop(&mut self) {
-        ROOTS.with(|x| x.borrow_mut().free(self))
-    }
-}
-
-#[derive(Debug)]
-pub struct RootedSteelVal {
-    value: SteelVal,
-    token: RootToken,
-}
-
-impl RootedSteelVal {
-    pub fn value(&self) -> &SteelVal {
-        &self.value
-    }
-}
-
-impl Roots {
-    fn root(&mut self, value: SteelVal) -> RootToken {
-        let generation = self.generation;
-        let offset = self.offset;
-
-        self.offset += 1;
-
-        self.roots.insert((generation, offset), value);
-
-        RootToken { generation, offset }
-    }
-
-    fn free(&mut self, token: &RootToken) {
-        self.roots.remove(&(token.generation, token.offset));
-    }
-
-    fn increment_generation(&mut self) {
-        self.generation += 1;
-    }
-}
-
-impl SteelVal {
-    pub fn mark_rooted(&self) -> RootToken {
-        ROOTS.with(|x| x.borrow_mut().root(self.clone()))
-    }
-
-    // If we're storing in an external struct that could escape
-    // the runtime, we probably want to be marked as rooted
-    pub fn as_rooted(&self) -> RootedSteelVal {
-        let token = self.mark_rooted();
-
-        RootedSteelVal {
-            token,
-            value: self.clone(),
-        }
-    }
-}
-
-type HeapValue = Rc<RefCell<HeapAllocated<SteelVal>>>;
-type HeapVector = Rc<RefCell<HeapAllocated<Vec<SteelVal>>>>;
-
-// Maybe uninitialized
-
-struct FreeList {
-    elements: Vec<Option<HeapValue>>,
-    cursor: usize,
-    alloc_count: usize,
-}
-
-impl FreeList {
-    const EXTEND_CHUNK: usize = 128;
-
-    fn is_heap_full(&self) -> bool {
-        self.alloc_count == self.elements.len()
-    }
-
-    fn extend_heap(&mut self) {
-        self.cursor = self.elements.len();
-
-        self.elements.reserve(Self::EXTEND_CHUNK);
-        self.elements
-            .extend(std::iter::repeat(None).take(Self::EXTEND_CHUNK));
-    }
-
-    fn allocate(&mut self, value: SteelVal) -> HeapRef<SteelVal> {
-        // Drain, moving values around...
-        // is that expensive?
-
-        let pointer = Rc::new(RefCell::new(HeapAllocated::new(value)));
-        let weak_ptr = Rc::downgrade(&pointer);
-
-        self.elements[self.cursor] = Some(pointer);
-        self.alloc_count += 1;
-
-        // Find where to assign the next slot optimistically
-        let next_slot = self.elements[self.cursor..]
-            .iter()
-            .position(Option::is_none);
-
-        if let Some(next_slot) = next_slot {
-            self.cursor += next_slot;
-        } else {
-            //
-            if self.is_heap_full() {
-                // Extend the heap, move the cursor to the end
-                self.extend_heap();
-            } else {
-                self.cursor = self.elements.iter().position(Option::is_none).unwrap()
-            }
-        }
-
-        HeapRef { inner: weak_ptr }
-    }
-
-    fn collect_on_condition(&mut self, func: fn(&HeapValue) -> bool) -> usize {
-        let mut amount_dropped = 0;
-
-        self.elements.iter_mut().for_each(|x| {
-            if x.as_ref().map(func).unwrap_or_default() {
-                *x = None;
-                amount_dropped += 1;
-            }
-        });
-
-        self.alloc_count -= amount_dropped;
-
-        amount_dropped
-    }
-
-    fn weak_collection(&mut self) -> usize {
-        self.collect_on_condition(|inner| Rc::weak_count(inner) == 0)
-    }
-
-    fn strong_collection(&mut self) -> usize {
-        self.collect_on_condition(|inner| !inner.borrow().is_reachable())
-    }
-}
-
-// TODO: If this proves to be faster, make these From(Vec<HeapValue>)
-#[derive(Copy, Clone)]
-enum CurrentSpace {
-    From,
-    To,
-}
-
-/// The heap for steel currently uses an allocation scheme based on weak references to reference counted pointers.
-/// Allocation is just a `Vec<Rc<RefCell<T>>>`, where allocating simply pushes and allocates a value at the end.
-/// When we do a collection, we attempt to do a small collection by just dropping any values with no weak counts
-/// pointing to it.
-#[derive(Clone)]
-pub struct Heap {
-    memory: Vec<HeapValue>,
-
-    // from_space: Vec<HeapValue>,
-    // to_space: Vec<HeapValue>,
-    // current: CurrentSpace,
-    vectors: Vec<HeapVector>,
-    count: usize,
-    threshold: usize,
-    // mark_and_sweep_queue: VecDeque<SteelVal>,
-    mark_and_sweep_queue: Vec<SteelVal>,
-    maybe_memory_size: usize,
-}
-
-impl Heap {
-    pub fn new() -> Self {
-        Heap {
-            memory: Vec::with_capacity(256),
-
-            // from_space: Vec::with_capacity(256),
-            // to_space: Vec::with_capacity(256),
-            // current: CurrentSpace::From,
-            vectors: Vec::with_capacity(256),
-            count: 0,
-            threshold: GC_THRESHOLD,
-            // mark_and_sweep_queue: VecDeque::with_capacity(256),
-            mark_and_sweep_queue: Vec::with_capacity(256),
-            maybe_memory_size: 0,
-        }
-    }
-
-    pub fn new_empty() -> Self {
-        Heap {
-            memory: Vec::new(),
-            vectors: Vec::new(),
-            count: 0,
-            threshold: GC_THRESHOLD,
-            mark_and_sweep_queue: Vec::new(),
-            maybe_memory_size: 0,
-        }
-    }
-
-    // #[inline(always)]
-    // pub fn memory(&mut self) -> &mut Vec<HeapValue> {
-    //     match self.current {
-    //         CurrentSpace::From => &mut self.from_space,
-    //         CurrentSpace::To => &mut self.to_space,
-    //     }
-    // }
-
-    // Allocate this variable on the heap
-    // It explicitly should no longer be on the stack, and variables that
-    // reference it should be pointing here now
-    pub fn allocate<'a>(
-        &mut self,
-        value: SteelVal,
-        roots: impl Iterator<Item = &'a SteelVal>,
-        live_functions: impl Iterator<Item = &'a ByteCodeLambda>,
-        globals: impl Iterator<Item = &'a SteelVal>,
-    ) -> HeapRef<SteelVal> {
-        self.collect(Some(value.clone()), None, roots, live_functions, globals);
-
-        let pointer = Rc::new(RefCell::new(HeapAllocated::new(value)));
-        let weak_ptr = Rc::downgrade(&pointer);
-
-        self.memory.push(pointer);
-
-        HeapRef { inner: weak_ptr }
-    }
-
-    pub fn allocate_without_collection<'a>(&mut self, value: SteelVal) -> HeapRef<SteelVal> {
-        let pointer = Rc::new(RefCell::new(HeapAllocated::new(value)));
-        let weak_ptr = Rc::downgrade(&pointer);
-
-        self.memory.push(pointer);
-
-        HeapRef { inner: weak_ptr }
-    }
-
-    // Allocate a vector explicitly onto the heap
-    pub fn allocate_vector<'a>(
-        &mut self,
-        values: Vec<SteelVal>,
-        roots: impl Iterator<Item = &'a SteelVal>,
-        live_functions: impl Iterator<Item = &'a ByteCodeLambda>,
-        globals: impl Iterator<Item = &'a SteelVal>,
-    ) -> HeapRef<Vec<SteelVal>> {
-        self.collect(None, Some(&values), roots, live_functions, globals);
-
-        let pointer = Rc::new(RefCell::new(HeapAllocated::new(values)));
-        let weak_ptr = Rc::downgrade(&pointer);
-
-        self.vectors.push(pointer);
-
-        HeapRef { inner: weak_ptr }
-    }
-
-    fn vector_cells_allocated(&self) -> usize {
-        // self.vectors.iter().map(|x| x.borrow().value.len()).sum()
-        self.vectors.len()
-    }
-
-    pub fn weak_collection(&mut self) {
-        self.memory.retain(|x| Rc::weak_count(x) > 0);
-        self.vectors.retain(|x| Rc::weak_count(x) > 0);
-    }
-
-    // TODO: Call this in more areas in the VM to attempt to free memory more carefully
-    // Also - come up with generational scheme if possible
-    pub fn collect<'a>(
-        &mut self,
-        root_value: Option<SteelVal>,
-        root_vector: Option<&Vec<SteelVal>>,
-        roots: impl Iterator<Item = &'a SteelVal>,
-        live_functions: impl Iterator<Item = &'a ByteCodeLambda>,
-        globals: impl Iterator<Item = &'a SteelVal>,
-    ) {
-        let memory_size = self.memory.len() + self.vector_cells_allocated();
-
-        if memory_size > self.threshold {
-            log::debug!(target: "gc", "Freeing memory");
-
-            let original_length = memory_size;
-
-            // Do at least one small collection, where we immediately drop
-            // anything that has weak counts of 0, meaning there are no alive
-            // references and we can avoid doing a full collection
-            //
-            // In the event that the collection does not yield a substantial
-            // change in the heap size, we should also enqueue a larger mark and
-            // sweep collection.
-            let mut changed = true;
-            let mut i = 0;
-            while changed && i < 3 {
-                let now = std::time::Instant::now();
-
-                log::debug!(target: "gc", "Small collection");
-                let prior_len = self.memory.len() + self.vector_cells_allocated();
-                log::debug!(target: "gc", "Previous length: {:?}", prior_len);
-                self.memory.retain(|x| Rc::weak_count(x) > 0);
-                self.vectors.retain(|x| Rc::weak_count(x) > 0);
-                let after = self.memory.len() + self.vector_cells_allocated();
-                log::debug!(target: "gc", "Objects freed: {:?}", prior_len - after);
-                log::debug!(target: "gc", "Small collection time: {:?}", now.elapsed());
-
-                changed = prior_len != after;
-                i += 1;
-            }
-
-            let post_small_collection_size = self.memory.len() + self.vector_cells_allocated();
-
-            // Mark + Sweep!
-            if post_small_collection_size as f64 > (0.25 * original_length as f64) {
-                log::debug!(target: "gc", "---- Post small collection, running mark and sweep - heap size filled: {:?} ----", post_small_collection_size as f64 / original_length as f64);
-
-                // TODO fix the garbage collector
-                self.mark_and_sweep(root_value, root_vector, roots, live_functions, globals);
-            } else {
-                log::debug!(target: "gc", "---- Skipping mark and sweep - heap size filled: {:?} ----", post_small_collection_size as f64 / original_length as f64);
-            }
-
-            // self.mark_and_sweep(roots, live_functions, globals);
-
-            self.threshold = (self.threshold + self.memory.len() + self.vector_cells_allocated())
-                * GC_GROW_FACTOR;
-
-            self.count += 1;
-
-            // Drive it down!
-            if self.count > RESET_LIMIT {
-                log::debug!(target: "gc", "Shrinking the heap");
-
-                self.threshold = GC_THRESHOLD;
-                self.count = 0;
-
-                self.memory.shrink_to(GC_THRESHOLD * GC_GROW_FACTOR);
-                self.vectors.shrink_to(GC_THRESHOLD * GC_GROW_FACTOR);
-            }
-        }
-    }
-
-    fn mark_and_sweep<'a>(
-        &mut self,
-        root_value: Option<SteelVal>,
-        root_vector: Option<&Vec<SteelVal>>,
-        roots: impl Iterator<Item = &'a SteelVal>,
-        function_stack: impl Iterator<Item = &'a ByteCodeLambda>,
-        globals: impl Iterator<Item = &'a SteelVal>,
-    ) {
-        log::debug!(target: "gc", "Marking the heap");
-
-        let now = std::time::Instant::now();
-
-        let mut context = MarkAndSweepContext {
-            queue: &mut self.mark_and_sweep_queue,
-        };
-
-        if let Some(root_value) = root_value {
-            context.push_back(root_value);
-        }
-
-        if let Some(root_vector) = root_vector {
-            for value in root_vector {
-                context.push_back(value.clone());
-            }
-        }
-
-        for root in roots {
-            context.push_back(root.clone());
-        }
-
-        context.visit();
-
-        for root in globals {
-            context.push_back(root.clone());
-        }
-
-        context.visit();
-
-        for function in function_stack {
-            for heap_ref in function.heap_allocated.borrow().iter() {
-                context.mark_heap_reference(&heap_ref.strong_ptr())
-            }
-
-            for value in function.captures() {
-                context.push_back(value.clone());
-            }
-        }
-
-        context.visit();
-
-        ROOTS.with(|x| {
-            x.borrow()
-                .roots
-                .values()
-                .for_each(|value| context.push_back(value.clone()))
-        });
-
-        context.visit();
-
-        log::debug!(target: "gc", "Mark: Time taken: {:?}", now.elapsed());
-
-        let now = std::time::Instant::now();
-
-        log::debug!(target: "gc", "--- Sweeping ---");
-        let prior_len = self.memory.len() + self.vector_cells_allocated();
-
-        // sweep
-        self.memory.retain(|x| x.borrow().is_reachable());
-        self.vectors.retain(|x| x.borrow().is_reachable());
-
-        let after_len = self.memory.len();
-
-        let amount_freed = prior_len - after_len;
-
-        log::debug!(target: "gc", "Freed objects: {:?}", amount_freed);
-        log::debug!(target: "gc", "Objects alive: {:?}", after_len);
-
-        // put them back as unreachable
-        self.memory.iter().for_each(|x| x.borrow_mut().reset());
-        self.vectors.iter().for_each(|x| x.borrow_mut().reset());
-
-        ROOTS.with(|x| x.borrow_mut().increment_generation());
-
-        log::debug!(target: "gc", "Sweep: Time taken: {:?}", now.elapsed());
-    }
-}
-
-pub trait HeapAble: Clone + std::fmt::Debug + PartialEq + Eq {}
-impl HeapAble for SteelVal {}
-impl HeapAble for Vec<SteelVal> {}
-
-#[derive(Clone, Debug)]
-pub struct HeapRef<T: HeapAble> {
-    inner: Weak<RefCell<HeapAllocated<T>>>,
-}
-
-impl<T: HeapAble> HeapRef<T> {
-    pub fn get(&self) -> T {
-        self.inner.upgrade().unwrap().borrow().value.clone()
-    }
-
-    pub fn as_ptr_usize(&self) -> usize {
-        self.inner.as_ptr() as usize
-    }
-
-    pub fn set(&mut self, value: T) -> T {
-        let inner = self.inner.upgrade().unwrap();
-
-        let ret = { inner.borrow().value.clone() };
-
-        inner.borrow_mut().value = value;
-        ret
-    }
-
-    pub fn set_and_return(&self, value: T) -> T {
-        let inner = self.inner.upgrade().unwrap();
-
-        let mut guard = inner.borrow_mut();
-        std::mem::replace(&mut guard.value, value)
-    }
-
-    pub(crate) fn set_interior_mut(&self, value: T) -> T {
-        let inner = self.inner.upgrade().unwrap();
-
-        let ret = { inner.borrow().value.clone() };
-
-        inner.borrow_mut().value = value;
-        ret
-    }
-
-    pub(crate) fn strong_ptr(&self) -> Rc<RefCell<HeapAllocated<T>>> {
-        self.inner.upgrade().unwrap()
-    }
-
-    pub(crate) fn ptr_eq(&self, other: &Self) -> bool {
-        Weak::ptr_eq(&self.inner, &other.inner)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub struct HeapAllocated<T: Clone + std::fmt::Debug + PartialEq + Eq> {
-    pub(crate) reachable: bool,
-    pub(crate) value: T,
-}
-
-// Adding generation information should be doable here
-// struct Test {
-//     pub(crate) reachable: bool,
-//     pub(crate) generation: u32,
-//     pub(crate) value: SteelVal,
-// }
-
-#[test]
-fn check_size_of_heap_allocated_value() {
-    println!("{:?}", std::mem::size_of::<HeapAllocated<SteelVal>>());
-    // println!("{:?}", std::mem::size_of::<Test>());
-}
-
-impl<T: Clone + std::fmt::Debug + PartialEq + Eq> HeapAllocated<T> {
-    pub fn new(value: T) -> Self {
-        Self {
-            reachable: false,
-            value,
-        }
-    }
-
-    pub fn is_reachable(&self) -> bool {
-        self.reachable
-    }
-
-    pub(crate) fn mark_reachable(&mut self) {
-        self.reachable = true;
-    }
-
-    pub(crate) fn reset(&mut self) {
-        self.reachable = false;
-    }
-}
-
-pub struct MarkAndSweepContext<'a> {
-    // queue: &'a mut VecDeque<SteelVal>,
-    queue: &'a mut Vec<SteelVal>,
-}
-
-impl<'a> MarkAndSweepContext<'a> {
-    fn mark_heap_reference(&mut self, heap_ref: &Rc<RefCell<HeapAllocated<SteelVal>>>) {
-        if heap_ref.borrow().is_reachable() {
-            return;
-        }
-
-        {
-            heap_ref.borrow_mut().mark_reachable();
-        }
-
-        self.push_back(heap_ref.borrow().value.clone());
-    }
-
-    // Visit the heap vector, mark it as visited!
-    fn mark_heap_vector(&mut self, heap_vector: &Rc<RefCell<HeapAllocated<Vec<SteelVal>>>>) {
-        if heap_vector.borrow().is_reachable() {
-            return;
-        }
-
-        {
-            heap_vector.borrow_mut().mark_reachable();
-        }
-
-        for value in heap_vector.borrow().value.iter() {
-            self.push_back(value.clone());
-        }
-    }
-}
-
-impl<'a> BreadthFirstSearchSteelValVisitor for MarkAndSweepContext<'a> {
-    type Output = ();
-
-    fn default_output(&mut self) -> Self::Output {}
-
-    fn pop_front(&mut self) -> Option<SteelVal> {
-        // self.queue.pop_front()
-        self.queue.pop()
-    }
-
-    fn push_back(&mut self, value: SteelVal) {
-        match &value {
-            SteelVal::BoolV(_)
-            | SteelVal::NumV(_)
-            | SteelVal::IntV(_)
-            | SteelVal::CharV(_)
-            | SteelVal::Void
-            | SteelVal::StringV(_)
-            | SteelVal::FuncV(_)
-            | SteelVal::SymbolV(_)
-            | SteelVal::FutureFunc(_)
-            | SteelVal::FutureV(_)
-            | SteelVal::BoxedFunction(_)
-            | SteelVal::MutFunc(_)
-            | SteelVal::BuiltIn(_)
-            | SteelVal::BigNum(_) => return,
-            _ => {
-                // self.queue.push_back(value);
-                self.queue.push(value);
-            }
-        }
-    }
-
-    fn visit_bignum(&mut self, _bignum: Gc<BigInt>) -> Self::Output {}
-
-    fn visit_bool(&mut self, _boolean: bool) -> Self::Output {}
-    fn visit_boxed_function(&mut self, _function: Rc<BoxedDynFunction>) -> Self::Output {}
-    // TODO: Revisit this when the boxed iterator is cleaned up
-    fn visit_boxed_iterator(&mut self, iterator: Gc<RefCell<OpaqueIterator>>) -> Self::Output {
-        self.push_back(iterator.borrow().root.clone());
-    }
-    fn visit_boxed_value(&mut self, boxed_value: Gc<RefCell<SteelVal>>) -> Self::Output {
-        self.push_back(boxed_value.borrow().clone());
-    }
-
-    fn visit_builtin_function(&mut self, _function: BuiltInSignature) -> Self::Output {}
-
-    fn visit_char(&mut self, _c: char) -> Self::Output {}
-    fn visit_closure(&mut self, closure: Gc<ByteCodeLambda>) -> Self::Output {
-        for heap_ref in closure.heap_allocated.borrow().iter() {
-            self.mark_heap_reference(&heap_ref.strong_ptr())
-        }
-
-        for capture in closure.captures() {
-            self.push_back(capture.clone());
-        }
-
-        if let Some(contract) = closure.get_contract_information().as_ref() {
-            self.push_back(contract.clone());
-        }
-    }
-    fn visit_continuation(&mut self, continuation: Continuation) -> Self::Output {
-        let continuation = (*continuation.inner.borrow()).clone();
-
-        match continuation {
-            ContinuationMark::Closed(continuation) => {
-                for value in &continuation.stack {
-                    self.push_back(value.clone());
-                }
-
-                for value in &continuation.current_frame.function.captures {
-                    self.push_back(value.clone());
-                }
-
-                for frame in &continuation.stack_frames {
-                    for value in &frame.function.captures {
-                        self.push_back(value.clone());
-                    }
-
-                    if let Some(handler) = &frame.handler {
-                        self.push_back((*handler.as_ref()).clone());
-                    }
-                }
-            }
-
-            ContinuationMark::Open(continuation) => {
-                for value in &continuation.current_stack_values {
-                    self.push_back(value.clone());
-                }
-
-                for value in &continuation.current_frame.function.captures {
-                    self.push_back(value.clone());
-                }
-            }
-        }
-    }
-    // TODO: Come back to this
-    fn visit_custom_type(&mut self, custom_type: Gc<RefCell<Box<dyn CustomType>>>) -> Self::Output {
-        custom_type.borrow().visit_children(self);
-    }
-
-    fn visit_float(&mut self, _float: f64) -> Self::Output {}
-
-    fn visit_function_pointer(&mut self, _ptr: FunctionSignature) -> Self::Output {}
-
-    fn visit_future(&mut self, _future: Gc<FutureResult>) -> Self::Output {}
-
-    fn visit_future_function(&mut self, _function: BoxedAsyncFunctionSignature) -> Self::Output {}
-
-    fn visit_hash_map(&mut self, hashmap: SteelHashMap) -> Self::Output {
-        for (key, value) in hashmap.iter() {
-            self.push_back(key.clone());
-            self.push_back(value.clone());
-        }
-    }
-
-    fn visit_hash_set(&mut self, hashset: SteelHashSet) -> Self::Output {
-        for value in hashset.iter() {
-            self.push_back(value.clone());
-        }
-    }
-
-    fn visit_heap_allocated(&mut self, heap_ref: HeapRef<SteelVal>) -> Self::Output {
-        self.mark_heap_reference(&heap_ref.strong_ptr());
-    }
-
-    fn visit_immutable_vector(&mut self, vector: SteelVector) -> Self::Output {
-        for value in vector.iter() {
-            self.push_back(value.clone());
-        }
-    }
-    fn visit_int(&mut self, _int: isize) -> Self::Output {}
-
-    fn visit_list(&mut self, list: List<SteelVal>) -> Self::Output {
-        for value in list {
-            self.push_back(value);
-        }
-    }
-
-    fn visit_mutable_function(&mut self, _function: MutFunctionSignature) -> Self::Output {}
-
-    fn visit_mutable_vector(&mut self, vector: HeapRef<Vec<SteelVal>>) -> Self::Output {
-        self.mark_heap_vector(&vector.strong_ptr())
-    }
-
-    fn visit_port(&mut self, _port: SteelPort) -> Self::Output {}
-
-    fn visit_reducer(&mut self, reducer: Gc<Reducer>) -> Self::Output {
-        match reducer.as_ref().clone() {
-            Reducer::ForEach(f) => self.push_back(f),
-            Reducer::Generic(rf) => {
-                self.push_back(rf.initial_value);
-                self.push_back(rf.function);
-            }
-            _ => {}
-        }
-    }
-
-    // TODO: Revisit this
-    fn visit_reference_value(&mut self, _reference: Rc<OpaqueReference<'static>>) -> Self::Output {}
-
-    fn visit_steel_struct(&mut self, steel_struct: Gc<UserDefinedStruct>) -> Self::Output {
-        for field in steel_struct.fields.iter() {
-            self.push_back(field.clone());
-        }
-    }
-
-    fn visit_stream(&mut self, stream: Gc<LazyStream>) -> Self::Output {
-        self.push_back(stream.initial_value.clone());
-        self.push_back(stream.stream_thunk.clone());
-    }
-
-    fn visit_string(&mut self, _string: SteelString) -> Self::Output {}
-
-    fn visit_symbol(&mut self, _symbol: SteelString) -> Self::Output {}
-
-    fn visit_syntax_object(&mut self, syntax_object: Gc<Syntax>) -> Self::Output {
-        if let Some(raw) = syntax_object.raw.clone() {
-            self.push_back(raw);
-        }
-
-        self.push_back(syntax_object.syntax.clone());
-    }
-
-    fn visit_transducer(&mut self, transducer: Gc<Transducer>) -> Self::Output {
-        for transducer in transducer.ops.iter() {
-            match transducer.clone() {
-                crate::values::transducers::Transducers::Map(m) => self.push_back(m),
-                crate::values::transducers::Transducers::Filter(v) => self.push_back(v),
-                crate::values::transducers::Transducers::Take(t) => self.push_back(t),
-                crate::values::transducers::Transducers::Drop(d) => self.push_back(d),
-                crate::values::transducers::Transducers::FlatMap(fm) => self.push_back(fm),
-                crate::values::transducers::Transducers::Flatten => {}
-                crate::values::transducers::Transducers::Window(w) => self.push_back(w),
-                crate::values::transducers::Transducers::TakeWhile(tw) => self.push_back(tw),
-                crate::values::transducers::Transducers::DropWhile(dw) => self.push_back(dw),
-                crate::values::transducers::Transducers::Extend(e) => self.push_back(e),
-                crate::values::transducers::Transducers::Cycle => {}
-                crate::values::transducers::Transducers::Enumerating => {}
-                crate::values::transducers::Transducers::Zipping(z) => self.push_back(z),
-                crate::values::transducers::Transducers::Interleaving(i) => self.push_back(i),
-            }
-        }
-    }
-
-    fn visit_void(&mut self) -> Self::Output {}
-
-    fn visit_pair(&mut self, pair: Gc<super::lists::Pair>) -> Self::Output {
-        self.push_back(pair.car());
-        self.push_back(pair.cdr());
-    }
-}
diff --git a/crates/steel-core/src/values/contracts.rs b/crates/steel-core/src/values/contracts.rs
deleted file mode 100644
index 9131d935d..000000000
--- a/crates/steel-core/src/values/contracts.rs
+++ /dev/null
@@ -1,477 +0,0 @@
-// use crate::gc::Gc;
-// use crate::rvals::{Result, SteelVal};
-// use std::collections::HashMap;
-// use std::fmt;
-
-// use crate::parser::ast::IteratorExtensions;
-
-// use super::functions::ByteCodeLambda;
-
-// /// Flat contracts are simply predicates to apply to a value. These can be immediately applied
-// /// at attachment to a value.
-// #[derive(Clone, PartialEq)]
-// pub struct FlatContract {
-//     /// Steel Function of any kind
-//     pub(crate) predicate: SteelVal,
-//     /// Name of the function for blaming purposes
-//     pub(crate) name: String,
-// }
-
-// impl fmt::Display for FlatContract {
-//     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//         write!(f, "{}", self.name)
-//     }
-// }
-
-// impl FlatContract {
-//     #[inline(always)]
-//     pub fn new_from_steelval(predicate: SteelVal, name: String) -> Result<SteelVal> {
-//         if predicate.is_contract() {
-//             Ok(predicate)
-//         } else if predicate.is_function() {
-//             Ok(FlatContract::new(predicate, name).into())
-//         } else {
-//             stop!(TypeMismatch => format!("flat contracts require a function argument, found {predicate}"));
-//         }
-//     }
-
-//     pub fn new(predicate: SteelVal, name: String) -> Self {
-//         FlatContract { predicate, name }
-//     }
-
-//     pub fn predicate(&self) -> &SteelVal {
-//         &self.predicate
-//     }
-// }
-
-// impl From<FlatContract> for SteelVal {
-//     fn from(val: FlatContract) -> SteelVal {
-//         SteelVal::Contract(Gc::new(ContractType::Flat(val)))
-//     }
-// }
-
-// // (x) (>= x) -- contains a vector of the arguments and then the contract
-// #[derive(Clone, PartialEq)]
-// pub(crate) struct DependentPair {
-//     pub(crate) argument_name: String,
-//     pub(crate) arguments: Vec<String>,
-//     pub(crate) thunk: Gc<ByteCodeLambda>,
-//     pub(crate) thunk_name: String,
-// }
-
-// impl DependentPair {
-//     fn new(
-//         argument_name: String,
-//         arguments: Vec<String>,
-//         thunk: Gc<ByteCodeLambda>,
-//         thunk_name: String,
-//     ) -> Self {
-//         DependentPair {
-//             argument_name,
-//             arguments,
-//             thunk,
-//             thunk_name,
-//         }
-//     }
-// }
-
-// impl fmt::Display for DependentPair {
-//     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//         write!(
-//             f,
-//             "[{} ({}) {}]",
-//             self.argument_name,
-//             self.arguments.iter().join(" "),
-//             self.thunk_name
-//         )
-//     }
-// }
-
-// // The arg positions -> which argument maps to which index in the input
-// // the pre-conditions - array of dependent pairs
-// // post-condition - dependent pair
-// // the rest is the same
-// #[derive(Clone, PartialEq)]
-// pub struct DependentContract {
-//     pub(crate) arg_positions: HashMap<String, usize>,
-//     pub(crate) pre_conditions: Box<[DependentPair]>,
-//     pub(crate) post_condition: DependentPair,
-//     pub(crate) contract_attachment_location: Option<String>,
-//     parent: Option<Gc<FunctionKind>>,
-// }
-
-// fn parse_list(lst: SteelVal) -> Result<(String, Vec<String>, Gc<ByteCodeLambda>, String)> {
-//     if let SteelVal::ListV(l) = lst {
-//         let mut iter = l.into_iter();
-
-//         let ident = iter
-//             .next()
-//             .ok_or_else(throw!(ArityMismatch => "make-dependent-function/c expected a symbol in the first position"))?
-//             .symbol_or_else(throw!(TypeMismatch => "make-dependent-function/c expected a symbol in the first position"))?
-//             .to_string();
-
-//         let raw_arguments = iter.next().ok_or_else(throw!(ArityMismatch => "make-dependent-function/c expected a list in the second position"))?;
-
-//         let arguments = match &raw_arguments {
-//             SteelVal::ListV(l) => {
-//                 l.iter()
-//                 .map(|x| x.clone_symbol_or_else(throw!(TypeMismatch => "make-dependent-function/c expected a symbol in the list of arguments")))
-//                 .collect::<Result<Vec<_>>>()
-//             }
-//             _ => stop!(TypeMismatch => format!("make-dependent-function/c expected a list of symbols, found: {raw_arguments}")),
-//         }?;
-
-//         let contract = iter
-//             .next()
-//             .ok_or_else(throw!(ArityMismatch => "make-dependent-function/c expected a contract in the third position"))?
-//             .closure_or_else(throw!(TypeMismatch => "make-dependent-function/c expected a contract in the third position"))?;
-
-//         let thunk_name = iter
-//             .next()
-//             .ok_or_else(throw!(ArityMismatch => "make-dependent-function/c expected a name in the fourth position"))?
-//             .to_string();
-
-//         if iter.next().is_some() {
-//             stop!(ArityMismatch => "make-dependent-function/c condition expects 4 arguments, found (at least) 5");
-//         }
-
-//         Ok((ident, arguments, contract, thunk_name))
-//     } else {
-//         stop!(TypeMismatch => "make-dependent-function/c expects a list");
-//     }
-// }
-
-// impl DependentContract {
-//     pub(crate) fn new_from_steelvals(
-//         pre_condition_lists: &[SteelVal],
-//         post_condition_list: SteelVal,
-//     ) -> Result<SteelVal> {
-//         let mut arg_positions = HashMap::new();
-//         let mut pre_conditions = Vec::new();
-
-//         for (index, pre_condition) in pre_condition_lists.iter().enumerate() {
-//             let (ident, arguments, contract, thunk_name) = parse_list(pre_condition.clone())?;
-
-//             // Insert the index of the name in order
-//             arg_positions.insert(ident.clone(), index);
-
-//             if index == 0 && !arguments.is_empty() {
-//                 stop!(ArityMismatch => "dependent contract depends on values not present!");
-//             }
-
-//             if index != 0 {
-//                 for argument in &arguments {
-//                     if !arg_positions.contains_key(argument) {
-//                         stop!(Generic => "dependent contract must depend on variable in scope!");
-//                     }
-//                 }
-//             }
-
-//             let pre_condition = DependentPair::new(ident, arguments, contract, thunk_name);
-//             pre_conditions.push(pre_condition);
-//         }
-
-//         let post_condition = {
-//             let (ident, arguments, contract, thunk_name) = parse_list(post_condition_list)?;
-
-//             for argument in &arguments {
-//                 if !arg_positions.contains_key(argument) {
-//                     stop!(Generic => "dependent contract result (range) condition must depend on one of arguments (domain)");
-//                 }
-//             }
-
-//             DependentPair::new(ident, arguments, contract, thunk_name)
-//         };
-
-//         let pre_conditions = pre_conditions.into_boxed_slice();
-//         let dep_contract = DependentContract {
-//             arg_positions,
-//             pre_conditions,
-//             post_condition,
-//             contract_attachment_location: None,
-//             parent: None,
-//         };
-
-//         Ok(SteelVal::Contract(Gc::new(ContractType::Function(
-//             FunctionKind::Dependent(dep_contract),
-//         ))))
-//     }
-// }
-
-// impl Contract for DependentContract {
-//     fn arity(&self) -> usize {
-//         self.pre_conditions.len()
-//     }
-
-//     fn set_parent(&mut self, p: Gc<FunctionKind>) {
-//         self.parent = Some(p);
-//     }
-
-//     fn parent(&self) -> Option<Gc<FunctionKind>> {
-//         self.parent.as_ref().map(Gc::clone)
-//     }
-
-//     fn set_attachment_location(&mut self, loc: Option<String>) {
-//         self.contract_attachment_location = loc
-//     }
-// }
-
-// pub trait Contract {
-//     fn set_parent(&mut self, p: Gc<FunctionKind>);
-//     fn parent(&self) -> Option<Gc<FunctionKind>>;
-//     fn set_attachment_location(&mut self, loc: Option<String>);
-//     fn arity(&self) -> usize;
-// }
-
-// impl fmt::Display for DependentContract {
-//     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//         write!(
-//             f,
-//             "(->i ({}) {})",
-//             self.pre_conditions.iter().map(|x| x.to_string()).join(" "),
-//             self.post_condition
-//         )
-//     }
-// }
-
-// /// Struct for function contracts. Contains all of the necessary information
-// /// for contract evaluation and blaming, including the pre and post conditions, the contract
-// /// attachment location, and the parent contract from which this contract was derived (if any)
-// #[derive(Clone, PartialEq)]
-// pub struct FunctionContract {
-//     /// List of pre conditions, required to be list of ContractType
-//     pre_conditions: Box<[Gc<ContractType>]>,
-//     /// Post condition, required to be a contract type
-//     post_condition: Gc<ContractType>,
-//     /// Location/Name of contract attachment
-//     pub(crate) contract_attachment_location: Option<String>,
-//     /// Stack of function contracts to also abide by, checked at application
-//     parent: Option<Gc<FunctionKind>>,
-// }
-
-// impl Contract for FunctionContract {
-//     fn arity(&self) -> usize {
-//         self.pre_conditions.len()
-//     }
-
-//     fn set_parent(&mut self, p: Gc<FunctionKind>) {
-//         self.parent = Some(p);
-//     }
-
-//     fn parent(&self) -> Option<Gc<FunctionKind>> {
-//         self.parent.as_ref().map(Gc::clone)
-//     }
-
-//     fn set_attachment_location(&mut self, loc: Option<String>) {
-//         self.contract_attachment_location = loc
-//     }
-// }
-
-// impl fmt::Display for FunctionContract {
-//     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//         write!(
-//             f,
-//             "(-> {} {})",
-//             self.pre_conditions.iter().map(|x| x.to_string()).join(" "),
-//             *self.post_condition
-//         )
-//     }
-// }
-
-// impl FunctionContract {
-//     #[inline(always)]
-//     pub fn new_from_steelval(
-//         pre_conditions: &[SteelVal],
-//         post_condition: SteelVal,
-//     ) -> Result<SteelVal> {
-//         let pre_conditions = pre_conditions
-//             .iter()
-//             .map(|x| {
-//                 if let SteelVal::Contract(c) = x {
-//                     Ok(c.clone()) // TODO find out how to remove this clone
-//                 } else {
-//                     stop!(TypeMismatch => "Function contract domain requires a list of contracts")
-//                 }
-//             })
-//             .collect::<Result<Box<_>>>()?;
-
-//         let post_condition = if let SteelVal::Contract(c) = post_condition {
-//             c
-//         } else {
-//             stop!(TypeMismatch => "function contract range expected a contract, found: {}", post_condition)
-//         };
-
-//         Ok(FunctionContract::new(pre_conditions, post_condition, None, None).into())
-//     }
-
-//     pub fn pre_conditions(&self) -> &[Gc<ContractType>] {
-//         &self.pre_conditions
-//     }
-
-//     pub fn post_condition(&self) -> &Gc<ContractType> {
-//         &self.post_condition
-//     }
-
-//     pub fn new(
-//         pre_conditions: Box<[Gc<ContractType>]>,
-//         post_condition: Gc<ContractType>,
-//         contract_attachment_location: Option<String>,
-//         parent: Option<Gc<FunctionKind>>,
-//     ) -> Self {
-//         FunctionContract {
-//             pre_conditions,
-//             post_condition,
-//             contract_attachment_location,
-//             parent,
-//         }
-//     }
-// }
-
-// impl From<FunctionContract> for SteelVal {
-//     fn from(val: FunctionContract) -> SteelVal {
-//         SteelVal::Contract(Gc::new(ContractType::Function(FunctionKind::Basic(val))))
-//     }
-// }
-
-// /// The contract type. `Flat` contracts apply to reified values (non functions)
-// /// `Function` contracts apply to exactly that - functions.
-// #[derive(Clone, PartialEq)]
-// pub enum ContractType {
-//     Flat(FlatContract),
-//     Function(FunctionKind),
-// }
-
-// #[derive(Clone, PartialEq)]
-// pub enum FunctionKind {
-//     Basic(FunctionContract),
-//     Dependent(DependentContract),
-// }
-
-// impl Contract for FunctionKind {
-//     fn arity(&self) -> usize {
-//         match self {
-//             Self::Basic(fc) => fc.arity(),
-//             Self::Dependent(dc) => dc.arity(),
-//         }
-//     }
-
-//     fn set_parent(&mut self, p: Gc<FunctionKind>) {
-//         match self {
-//             Self::Basic(fc) => fc.set_parent(p),
-//             Self::Dependent(dc) => dc.set_parent(p),
-//         }
-//     }
-
-//     fn parent(&self) -> Option<Gc<FunctionKind>> {
-//         match self {
-//             Self::Basic(fc) => fc.parent(),
-//             Self::Dependent(dc) => dc.parent(),
-//         }
-//     }
-
-//     fn set_attachment_location(&mut self, loc: Option<String>) {
-//         match self {
-//             Self::Basic(fc) => fc.set_attachment_location(loc),
-//             Self::Dependent(dc) => dc.set_attachment_location(loc),
-//         }
-//     }
-// }
-
-// impl fmt::Display for FunctionKind {
-//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-//         match self {
-//             Self::Basic(fc) => write!(f, "{fc}"),
-//             Self::Dependent(dc) => write!(f, "{dc}"),
-//         }
-//     }
-// }
-
-// impl fmt::Display for ContractType {
-//     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//         match self {
-//             Self::Flat(flat) => write!(f, "{flat}"),
-//             Self::Function(fc) => write!(f, "{fc}"),
-//         }
-//     }
-// }
-
-// /// Represents a Steel function wrapped with a contract
-// /// Contains the contract, the function, and the name of the contract (for blaming)
-// #[derive(Clone)]
-// pub struct ContractedFunction {
-//     pub contract: FunctionKind,
-//     pub function: SteelVal,
-//     pub name: Option<String>,
-// }
-
-// impl PartialEq for ContractedFunction {
-//     fn eq(&self, other: &Self) -> bool {
-//         self.contract == other.contract
-//     }
-// }
-
-// impl ContractedFunction {
-//     pub fn new(contract: FunctionKind, function: SteelVal, name: Option<String>) -> Self {
-//         ContractedFunction {
-//             contract,
-//             function,
-//             name,
-//         }
-//     }
-
-//     pub fn arity(&self) -> Option<usize> {
-//         if let SteelVal::Closure(func) = &self.function {
-//             Some(func.arity())
-//         } else {
-//             None
-//         }
-//     }
-
-//     #[inline(always)]
-//     pub fn new_from_steelvals(
-//         contract: SteelVal,
-//         function: SteelVal,
-//         name: Option<SteelVal>,
-//     ) -> Result<SteelVal> {
-//         let name = match name {
-//             Some(SteelVal::SymbolV(s)) => Some(s.to_string()),
-//             Some(_) => stop!(TypeMismatch => "bind/c expected a symbol in the first position"),
-//             None => None,
-//         };
-
-//         let contract = if let SteelVal::Contract(fc) = contract {
-//             if let ContractType::Function(fc) = fc.as_ref() {
-//                 fc.clone()
-//             } else {
-//                 stop!(TypeMismatch => "bind/c requires a function contract")
-//             }
-//         } else {
-//             stop!(TypeMismatch => "bind/c requires a function contract")
-//         };
-
-//         if !function.is_function() {
-//             stop!(TypeMismatch => "bind/c requires a function");
-//         }
-
-//         // let function = if let SteelVal::Closure(b) = function {
-//         //     b.clone()
-//         // } else {
-//         //     stop!(TypeMismatch => "bind/c requires a bytecode function, not a primitive")
-//         // };
-
-//         // Check the arity only if we have it
-//         if let SteelVal::Closure(function) = &function {
-//             if contract.arity() != function.arity() {
-//                 stop!(TypeMismatch => format!("contract did not match function arity: function has arity: {}, contract has arity: {}", function.arity(), contract.arity()));
-//             }
-//         }
-
-//         Ok(ContractedFunction::new(contract, function, name).into())
-//     }
-// }
-
-// impl From<ContractedFunction> for SteelVal {
-//     fn from(val: ContractedFunction) -> Self {
-//         SteelVal::ContractedFunction(Gc::new(val))
-//     }
-// }
diff --git a/crates/steel-core/src/values/functions.rs b/crates/steel-core/src/values/functions.rs
deleted file mode 100644
index ae5483a56..000000000
--- a/crates/steel-core/src/values/functions.rs
+++ /dev/null
@@ -1,476 +0,0 @@
-#![allow(unused)]
-
-use std::{
-    cell::{Cell, RefCell},
-    collections::HashMap,
-    convert::TryFrom,
-    hash::Hasher,
-    rc::Rc,
-    sync::Arc,
-};
-
-use fxhash::FxHashSet;
-
-use crate::{
-    core::{instructions::DenseInstruction, opcode::OpCode},
-    gc::Gc,
-    parser::{parser::SyntaxObjectId, span::Span},
-    rvals::{
-        from_serializable_value, into_serializable_value, AsRefSteelVal, BoxedFunctionSignature,
-        Custom, FunctionSignature, HeapSerializer, IntoSteelVal, MutFunctionSignature,
-        SerializableSteelVal, SteelString,
-    },
-    steel_vm::{
-        register_fn::SendSyncStatic,
-        vm::{BlockMetadata, BlockPattern, BuiltInSignature},
-    },
-    // values::contracts::ContractedFunction,
-    SteelErr,
-    SteelVal,
-};
-
-use super::{
-    closed::{Heap, HeapRef},
-    structs::UserDefinedStruct,
-};
-
-// pub(crate) enum Function {
-//     BoxedFunction(BoxedFunctionSignature),
-//     Closure(Gc<ByteCodeLambda>),
-//     FuncV(FunctionSignature),
-//     ContractedFunction(Gc<ContractedFunction>),
-//     MutFuncV(MutFunctionSignature),
-//     Builtin(BuiltInSignature),
-// }
-
-// TODO: replace body exp below with this
-// struct Blagh {
-//     body: Rc<RefCell<[DenseInstruction]>>,
-// }
-
-// Keep track of this metadata table for getting the docs associated
-// with a given function?
-pub struct LambdaMetadataTable {
-    fn_ptr_table: HashMap<usize, SteelString>,
-}
-
-impl Custom for LambdaMetadataTable {}
-
-impl LambdaMetadataTable {
-    pub fn new() -> Self {
-        Self {
-            fn_ptr_table: HashMap::new(),
-        }
-    }
-
-    pub fn add(&mut self, function: SteelVal, doc: SteelString) {
-        match function {
-            SteelVal::Closure(b) => {
-                self.fn_ptr_table.insert(b.id, doc);
-            }
-            SteelVal::BoxedFunction(b) => {
-                self.fn_ptr_table.insert(Rc::as_ptr(&b) as usize, doc);
-            }
-            _ => {}
-        }
-    }
-
-    pub fn get(&self, function: SteelVal) -> Option<SteelString> {
-        match function {
-            SteelVal::Closure(b) => self.fn_ptr_table.get(&b.id).cloned(),
-            SteelVal::BoxedFunction(b) => {
-                self.fn_ptr_table.get(&(Rc::as_ptr(&b) as usize)).cloned()
-            }
-            _ => None,
-        }
-    }
-
-    // TODO: This will need to get called in other places
-    pub fn collect_garbage(&mut self, keep_set: impl Iterator<Item = usize>) {
-        let set = keep_set.collect::<std::collections::HashSet<_>>();
-
-        self.fn_ptr_table.retain(|k, _| set.contains(k));
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct ByteCodeLambda {
-    pub(crate) id: usize,
-    /// body of the function with identifiers yet to be bound
-    #[cfg(feature = "dynamic")]
-    pub(crate) body_exp: RefCell<Rc<[DenseInstruction]>>,
-
-    #[cfg(not(feature = "dynamic"))]
-    pub(crate) body_exp: Rc<[DenseInstruction]>,
-
-    // #[cfg(not(feature = "dynamic"))]
-    // pub(crate) body_exp: Rc<[DenseInstruction]>,
-    pub(crate) arity: usize,
-
-    #[cfg(feature = "dynamic")]
-    call_count: Cell<usize>,
-
-    pub(crate) is_multi_arity: bool,
-    pub(crate) captures: Vec<SteelVal>,
-    pub(crate) heap_allocated: RefCell<Vec<HeapRef<SteelVal>>>,
-    // pub(crate) spans: Rc<[Span]>,
-    #[cfg(feature = "dynamic")]
-    pub(crate) blocks: RefCell<Vec<(BlockPattern, BlockMetadata)>>,
-
-    // This is a little suspicious, but it should give us the necessary information to attach a struct of metadata
-    contract: RefCell<Option<Gc<UserDefinedStruct>>>,
-}
-
-impl PartialEq for ByteCodeLambda {
-    fn eq(&self, other: &Self) -> bool {
-        // self.body_exp == other.body_exp &&
-        self.arity == other.arity && self.id == other.id
-    }
-}
-
-impl Eq for ByteCodeLambda {}
-
-impl std::hash::Hash for ByteCodeLambda {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.id.hash(state);
-        // self.body_exp.as_ptr().hash(state);
-        self.arity.hash(state);
-
-        // self.sub_expression_env.as_ptr().hash(state);
-    }
-}
-
-// Can this be moved across threads? What does it cost to execute a closure in another thread?
-// Engine instances be deep cloned?
-pub struct SerializedLambda {
-    pub id: usize,
-    pub body_exp: Vec<DenseInstruction>,
-    pub arity: usize,
-    pub is_multi_arity: bool,
-    // TODO: Go ahead and create a ThreadSafeSteelVal where we will just deep clone everything, move
-    // it across the thread, and reconstruct on the other side.
-    pub captures: Vec<SerializableSteelVal>,
-}
-
-#[derive(Clone)]
-pub struct SerializedLambdaPrototype {
-    pub id: usize,
-    pub body_exp: Vec<DenseInstruction>,
-    pub arity: usize,
-    pub is_multi_arity: bool,
-    // TODO: Go ahead and create a ThreadSafeSteelVal where we will just deep clone everything, move
-    // it across the thread, and reconstruct on the other side.
-    // pub captures: Vec<SerializableSteelVal>,
-}
-
-// TODO
-// is_let can probably be localized to a specific kind of function
-// is_multi_arity can also be localized to a specific kind of function
-impl ByteCodeLambda {
-    pub fn new(
-        id: usize,
-        body_exp: Rc<[DenseInstruction]>,
-        arity: usize,
-        is_multi_arity: bool,
-        captures: Vec<SteelVal>,
-        heap_allocated: Vec<HeapRef<SteelVal>>,
-    ) -> ByteCodeLambda {
-        // debug_assert_eq!(body_exp.len(), spans.len());
-
-        ByteCodeLambda {
-            id,
-
-            #[cfg(feature = "dynamic")]
-            body_exp: RefCell::new(body_exp),
-            #[cfg(not(feature = "dynamic"))]
-            body_exp,
-
-            arity,
-
-            #[cfg(feature = "dynamic")]
-            call_count: Cell::new(0),
-
-            is_multi_arity,
-            captures,
-            // TODO: Allocated the necessary size right away <- we're going to index into it
-            heap_allocated: RefCell::new(heap_allocated),
-            // spans,
-
-            // span_id,
-            contract: RefCell::new(None),
-
-            #[cfg(feature = "dynamic")]
-            blocks: RefCell::new(Vec::new()),
-        }
-    }
-
-    pub(crate) fn from_serialized(heap: &mut HeapSerializer, value: SerializedLambda) -> Self {
-        ByteCodeLambda::new(
-            value.id,
-            value.body_exp.into(),
-            value.arity,
-            value.is_multi_arity,
-            value
-                .captures
-                .into_iter()
-                .map(|x| from_serializable_value(heap, x))
-                .collect(),
-            Vec::new(),
-        )
-    }
-
-    pub fn main(instructions: Vec<DenseInstruction>) -> ByteCodeLambda {
-        Self::new(
-            SyntaxObjectId::fresh().into(),
-            instructions.into(),
-            0,
-            false,
-            Vec::default(),
-            Vec::default(),
-            // Rc::from([]),
-        )
-    }
-
-    // pub fn id(&self) -> usize {
-    //     self.id
-    // }
-
-    pub fn set_captures(&mut self, captures: Vec<SteelVal>) {
-        self.captures = captures;
-    }
-
-    pub fn set_heap_allocated(&mut self, heap_allocated: Vec<HeapRef<SteelVal>>) {
-        self.heap_allocated = RefCell::new(heap_allocated);
-    }
-
-    pub fn body_exp(&self) -> Rc<[DenseInstruction]> {
-        #[cfg(feature = "dynamic")]
-        return Rc::clone(&self.body_exp.borrow());
-
-        #[cfg(not(feature = "dynamic"))]
-        Rc::clone(&self.body_exp)
-    }
-
-    pub fn body_mut_exp(&mut self) -> Rc<[DenseInstruction]> {
-        #[cfg(feature = "dynamic")]
-        return Rc::clone(self.body_exp.get_mut());
-
-        #[cfg(not(feature = "dynamic"))]
-        Rc::clone(&self.body_exp)
-    }
-
-    // pub fn spans(&self) -> Rc<[Span]> {
-    //     Rc::clone(&self.spans)
-    // }
-
-    // Get the starting index in the instruction set, and the new ID to associate with this
-    // super instruction set.
-    // Deep copy the old instruction set, update the new spot to have a dynamic super instruction
-    // associated with it.
-    #[cfg(feature = "dynamic")]
-    pub fn update_to_super_instruction(
-        &self,
-        start: usize,
-        super_instruction_id: usize,
-    ) -> (DenseInstruction, Rc<[DenseInstruction]>) {
-        let mut guard = self.body_exp.borrow_mut();
-        let mut old: Box<[_]> = guard.iter().copied().collect();
-
-        // set up the head instruction to get returned, we'll need it in the block first
-        let head_instruction = old[start];
-
-        // Point to the new super instruction
-        old[start].op_code = OpCode::DynSuperInstruction;
-        old[start].payload_size = super_instruction_id as _;
-        *guard = old.into();
-        (head_instruction, Rc::clone(&guard))
-    }
-
-    #[inline(always)]
-    pub fn arity(&self) -> usize {
-        self.arity
-    }
-
-    pub fn heap_allocated(&self) -> &RefCell<Vec<HeapRef<SteelVal>>> {
-        &self.heap_allocated
-    }
-
-    pub fn captures(&self) -> &[SteelVal] {
-        &self.captures
-    }
-
-    #[cfg(feature = "dynamic")]
-    #[inline(always)]
-    pub fn increment_call_count(&self) {
-        // self.call_count += 1;
-        self.call_count.set(self.call_count.get() + 1);
-    }
-
-    #[cfg(feature = "dynamic")]
-    pub fn call_count(&self) -> usize {
-        self.call_count.get()
-    }
-
-    // pub fn set_cannot_be_compiled(&self) {
-    //     self.cant_be_compiled.set(true)
-    // }
-
-    // pub fn has_attempted_to_be_compiled(&self) -> bool {
-    //     self.cant_be_compiled.get()
-    // }
-
-    pub fn attach_contract_information(&self, steel_struct: Gc<UserDefinedStruct>) {
-        let mut guard = self.contract.borrow_mut();
-
-        *guard = Some(steel_struct);
-    }
-
-    pub fn get_contract_information(&self) -> Option<SteelVal> {
-        self.contract
-            .borrow()
-            .as_ref()
-            .map(|x| SteelVal::CustomStruct(x.clone()))
-    }
-
-    // pub fn mark_hot(&self) {
-    //     self.is_hot.set(true)
-    // }
-
-    // pub(crate) fn mark_block_tail(&self, pattern: BlockPattern) {
-    //     self.blocks.borrow_mut();
-    // }
-
-    // pub(crate) fn check_tail(&self, pattern: &BlockPattern) -> bool {
-    //     self.blocks.borrow().contains(pattern)
-    // }
-
-    // pub(crate) fn block_tail(&self, block_pattern
-}
-
-pub fn attach_contract_struct(args: &[SteelVal]) -> crate::rvals::Result<SteelVal> {
-    if let SteelVal::Closure(closure) = &args[0] {
-        if let SteelVal::CustomStruct(s) = &args[1] {
-            closure.attach_contract_information(s.clone());
-
-            Ok(SteelVal::Void)
-        } else {
-            stop!(TypeMismatch => "attach-contract-struct! expects a struct in the second position")
-        }
-    } else {
-        stop!(TypeMismatch => "attach-contract-struct! expects a function in the first position")
-    }
-}
-
-pub fn get_contract(args: &[SteelVal]) -> crate::rvals::Result<SteelVal> {
-    if let SteelVal::Closure(closure) = &args[0] {
-        closure.get_contract_information().into_steelval()
-    } else {
-        Ok(SteelVal::BoolV(false))
-
-        // stop!(TypeMismatch => "get-contract-struct! expects a function in the first position, found: {}", &args[0])
-    }
-}
-
-#[derive(Clone)]
-#[repr(C)]
-pub enum StaticOrRcStr {
-    Static(&'static str),
-    Owned(Arc<String>),
-}
-
-/// This allows cloning the underlying closure, so we can send it across threads.
-/// It does _not_ solve serializing closures fully, but it does mean we can move function
-/// pointers across threads, which should be very helpful with spawning native threads.
-// TODO: @Matt - Replace usage of BoxedDynFunction (and subsequent call sites) with this instead
-// trait DynamicFunction: Send + Sync {
-//     #[inline]
-//     fn call(&self, args: &[SteelVal]) -> crate::rvals::Result<SteelVal>;
-//     fn clone_box(&self) -> Box<dyn DynamicFunction>;
-// }
-
-// // Allow only the capturing of send + sync variables?
-// impl<F: Fn(&[SteelVal]) -> crate::rvals::Result<SteelVal> + Clone + Send + Sync + 'static>
-//     DynamicFunction for F
-// {
-//     fn call(&self, args: &[SteelVal]) -> crate::rvals::Result<SteelVal> {
-//         (self)(args)
-//     }
-
-//     fn clone_box(&self) -> Box<dyn DynamicFunction> {
-//         Box::new(self.clone())
-//     }
-// }
-
-// impl Clone for Box<dyn DynamicFunction> {
-//     fn clone(&self) -> Self {
-//         self.clone_box()
-//     }
-// }
-
-// pub enum MaybeSendSyncFunction {}
-
-#[derive(Clone)]
-#[repr(C)]
-pub struct BoxedDynFunction {
-    pub function:
-        Arc<dyn Fn(&[SteelVal]) -> crate::rvals::Result<SteelVal> + Send + Sync + 'static>,
-    pub name: Option<StaticOrRcStr>,
-    pub arity: Option<usize>,
-}
-
-impl BoxedDynFunction {
-    // pub fn spawn_on_thread(self) {
-    //     std::thread::spawn(move || self.function);
-    // }
-
-    pub(crate) fn new(
-        function: Arc<
-            dyn Fn(&[SteelVal]) -> crate::rvals::Result<SteelVal> + Send + Sync + 'static,
-        >,
-        name: Option<&str>,
-        arity: Option<usize>,
-    ) -> Self {
-        BoxedDynFunction {
-            function,
-            name: name
-                .map(|x| Arc::new(x.to_string()))
-                .map(StaticOrRcStr::Owned),
-            arity,
-        }
-    }
-
-    pub(crate) fn new_owned(
-        function: Arc<
-            dyn Fn(&[SteelVal]) -> crate::rvals::Result<SteelVal> + Send + Sync + 'static,
-        >,
-        name: Option<Arc<String>>,
-        arity: Option<usize>,
-    ) -> Self {
-        BoxedDynFunction {
-            function,
-            name: name.map(StaticOrRcStr::Owned),
-            arity,
-        }
-    }
-
-    #[inline(always)]
-    pub fn func(
-        &self,
-    ) -> &(dyn Fn(&[SteelVal]) -> crate::rvals::Result<SteelVal> + Send + Sync + 'static) {
-        self.function.as_ref()
-    }
-
-    #[inline(always)]
-    pub fn get_arity(&self) -> Option<usize> {
-        self.arity
-    }
-
-    #[inline(always)]
-    pub fn name(&self) -> Option<&str> {
-        match &self.name {
-            Some(StaticOrRcStr::Owned(o)) => None, // TODO: Come back here @Matt
-            Some(StaticOrRcStr::Static(s)) => Some(s),
-            None => None,
-        }
-    }
-}
diff --git a/crates/steel-core/src/values/json_vals.rs b/crates/steel-core/src/values/json_vals.rs
deleted file mode 100644
index b3ea128e7..000000000
--- a/crates/steel-core/src/values/json_vals.rs
+++ /dev/null
@@ -1,213 +0,0 @@
-use crate::values::lists::List;
-use crate::{
-    gc::Gc,
-    rerrs::SteelErr,
-    rvals::{FromSteelVal, IntoSteelVal, Result, SteelVal},
-    throw,
-};
-use im_rc::HashMap;
-use serde_json::{Map, Number, Value};
-use std::convert::{TryFrom, TryInto};
-
-pub fn string_to_jsexpr() -> SteelVal {
-    SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-        if args.len() != 1 {
-            stop!(ArityMismatch => "string->jsexpr takes 1 argument");
-        } else {
-            let arg =
-                &args[0].string_or_else(throw!(TypeMismatch => "string->jsexpr takes a string"))?;
-            // let unescaped = unescape(arg);
-            // let res: std::result::Result<Value, _> = serde_json::from_str(unescaped.as_str());
-            let res: std::result::Result<Value, _> = serde_json::from_str(arg);
-            match res {
-                Ok(res) => res.try_into(),
-                Err(e) => stop!(Generic => format!("string->jsexpr failed: {e}")),
-            }
-        }
-    })
-}
-
-pub fn serialize_val_to_string() -> SteelVal {
-    SteelVal::FuncV(|args: &[SteelVal]| -> Result<SteelVal> {
-        if args.len() != 1 {
-            stop!(ArityMismatch => "serialize value takes one argument");
-        } else {
-            let arg = args[0].clone();
-            let serde_value: Value = arg.try_into()?;
-            let serialized_value = serde_value.to_string();
-            Ok(SteelVal::StringV(serialized_value.into()))
-        }
-    })
-}
-
-// required to parse each string
-#[allow(unused)]
-fn unescape(s: &str) -> String {
-    let mut result = String::with_capacity(s.len());
-    let mut chars = s.chars();
-    while let Some(ch) = chars.next() {
-        result.push(if ch != '\\' {
-            ch
-        } else {
-            match chars.next() {
-                // Some('u') => {
-                //     let value = chars
-                //         .by_ref()
-                //         .take(4)
-                //         .fold(0, |acc, c| acc * 16 + c.to_digit(16).unwrap());
-                //     char::from_u32(value).unwrap()
-                // }
-                Some('b') => '\x08',
-                Some('f') => '\x0c',
-                Some('n') => '\n',
-                Some('r') => '\r',
-                Some('t') => '\t',
-                Some(ch) => ch,
-                _ => panic!("Malformed escape"),
-            }
-        })
-    }
-    result
-}
-
-impl TryFrom<Map<String, Value>> for SteelVal {
-    type Error = SteelErr;
-    fn try_from(map: Map<String, Value>) -> std::result::Result<Self, Self::Error> {
-        let mut hm = HashMap::new();
-        for (key, value) in map {
-            hm.insert(SteelVal::SymbolV(key.into()), value.try_into()?);
-        }
-        Ok(SteelVal::HashMapV(Gc::new(hm).into()))
-    }
-}
-
-impl TryFrom<Value> for SteelVal {
-    type Error = SteelErr;
-    fn try_from(val: Value) -> std::result::Result<Self, Self::Error> {
-        match val {
-            Value::Null => Ok(SteelVal::Void),
-            Value::Bool(t) => Ok(SteelVal::BoolV(t)),
-            Value::Number(n) => <SteelVal>::try_from(n),
-            Value::String(s) => Ok(SteelVal::StringV(s.into())),
-            Value::Array(v) => Ok(SteelVal::ListV(
-                v.into_iter()
-                    .map(<SteelVal>::try_from)
-                    .collect::<Result<List<SteelVal>>>()?,
-            )),
-            Value::Object(m) => m.try_into(),
-        }
-    }
-}
-
-// TODO
-impl TryFrom<Number> for SteelVal {
-    type Error = SteelErr;
-    fn try_from(n: Number) -> std::result::Result<Self, Self::Error> {
-        let result = n.as_f64().unwrap();
-        Ok(SteelVal::NumV(result))
-    }
-}
-
-impl IntoSteelVal for Value {
-    fn into_steelval(self) -> Result<SteelVal> {
-        self.try_into()
-    }
-}
-
-impl FromSteelVal for Value {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        val.clone().try_into()
-    }
-}
-
-// Attempt to serialize to json?
-// It would be better to straight implement the deserialize method
-// Honestly... this is not great
-impl TryFrom<SteelVal> for Value {
-    type Error = SteelErr;
-    fn try_from(val: SteelVal) -> std::result::Result<Self, Self::Error> {
-        match val {
-            SteelVal::BoolV(b) => Ok(Value::Bool(b)),
-            SteelVal::NumV(n) => Ok(Value::Number(Number::from_f64(n).unwrap())),
-            SteelVal::IntV(n) => Ok(Value::Number(Number::from(n))),
-            SteelVal::CharV(c) => Ok(Value::String(c.to_string())),
-            // SteelVal::Pair(_) => Ok(Value::Array(
-            //     SteelVal::iter(val)
-            //         .map(|x| x.try_into())
-            //         .collect::<Result<Vec<_>>>()?,
-            // )),
-            SteelVal::ListV(l) => Ok(Value::Array(
-                l.into_iter()
-                    .map(|x| x.try_into())
-                    .collect::<Result<Vec<_>>>()?,
-            )),
-            SteelVal::VectorV(v) => Ok(Value::Array(
-                v.iter()
-                    .map(|x| x.clone().try_into())
-                    .collect::<Result<Vec<_>>>()?,
-            )),
-            SteelVal::Void => stop!(Generic => "void not serializable"),
-            SteelVal::StringV(s) => Ok(Value::String(s.to_string())),
-            SteelVal::FuncV(_) => stop!(Generic => "function not serializable"),
-            // SteelVal::LambdaV(_) => stop!(Generic => "function not serializable"),
-            // SteelVal::MacroV(_) => stop!(Generic => "macro not serializable"),
-            SteelVal::SymbolV(s) => Ok(Value::String(s.to_string())),
-            SteelVal::Custom(_) => stop!(Generic => "generic struct not serializable"),
-            SteelVal::HashMapV(hm) => {
-                let mut map: Map<String, Value> = Map::new();
-                for (key, value) in hm.iter() {
-                    map.insert(key.clone().try_into()?, value.clone().try_into()?);
-                }
-                Ok(Value::Object(map))
-            }
-            SteelVal::HashSetV(hs) => Ok(Value::Array(
-                hs.iter()
-                    .map(|x| x.clone().try_into())
-                    .collect::<Result<Vec<_>>>()?,
-            )),
-            // SteelVal::StructV(_) => stop!(Generic => "built in struct not serializable yet"),
-            _ => stop!(Generic => "type not serializable"),
-            // SteelVal::StructClosureV(_, _) => {}
-            // SteelVal::PortV(_) => {}
-            // SteelVal::Closure(_) => {}
-            // SteelVal::IterV(_) => {}
-            // SteelVal::FutureFunc(_) => {}
-            // SteelVal::FutureV(_) => {}
-            // SteelVal::StreamV(_) => {}
-        }
-
-        // unimplemented!()
-    }
-}
-
-#[cfg(test)]
-mod json_tests {
-    use super::*;
-
-    use crate::rvals::SteelVal::*;
-    use im_rc::hashmap;
-
-    fn apply_function(func: SteelVal, args: Vec<SteelVal>) -> Result<SteelVal> {
-        func.func_or_else(throw!(BadSyntax => "hash tests"))
-            .unwrap()(&args)
-    }
-
-    #[test]
-    fn test_string_to_jsexpr() {
-        let json_expr = r#"{"a":"applesauce","b":"bananas"}"#;
-        let steelval = SteelVal::StringV(json_expr.into());
-        let args = vec![steelval];
-
-        let result = apply_function(string_to_jsexpr(), args);
-
-        let expected = SteelVal::HashMapV(
-            Gc::new(hashmap! {
-                SymbolV("a".into()) => StringV("applesauce".into()),
-                SymbolV("b".into()) => StringV("bananas".into())
-            })
-            .into(),
-        );
-
-        assert_eq!(result.unwrap(), expected);
-    }
-}
diff --git a/crates/steel-core/src/values/lazy_stream.rs b/crates/steel-core/src/values/lazy_stream.rs
deleted file mode 100644
index 4c1eea332..000000000
--- a/crates/steel-core/src/values/lazy_stream.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use crate::rvals::SteelVal;
-
-#[derive(Clone)]
-pub struct LazyStream {
-    pub initial_value: SteelVal, // argument to stream
-    pub stream_thunk: SteelVal,  // function to get the next value
-    pub empty_stream: bool,
-}
-
-impl LazyStream {
-    // Perhaps do some error checking here in order to determine
-    // if the arguments passed are actually valid
-    pub fn new(initial_value: SteelVal, stream_thunk: SteelVal) -> Self {
-        LazyStream {
-            initial_value,
-            stream_thunk,
-            empty_stream: false,
-        }
-    }
-
-    pub fn new_empty_stream() -> Self {
-        LazyStream {
-            initial_value: SteelVal::Void,
-            stream_thunk: SteelVal::Void,
-            empty_stream: true,
-        }
-    }
-
-    // Should return the value in the `initial_value` field
-    // is equivalent to calling (stream-first stream)
-    pub fn stream_first(&self) -> SteelVal {
-        self.initial_value.clone()
-    }
-
-    // `stream_thunk` should be a thunk that return the next `LazyStream`
-    //  this should just return a new `LazyStream`
-    pub fn stream_thunk(&self) -> SteelVal {
-        self.stream_thunk.clone()
-    }
-
-    pub fn empty_stream(&self) -> SteelVal {
-        SteelVal::BoolV(self.empty_stream)
-    }
-}
diff --git a/crates/steel-core/src/values/lists.rs b/crates/steel-core/src/values/lists.rs
deleted file mode 100644
index f93f07e2e..000000000
--- a/crates/steel-core/src/values/lists.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-use std::cell::Cell;
-
-use im_lists::handler::DropHandler;
-
-use crate::SteelVal;
-
-// TODO:
-// Builtin immutable pairs
-#[derive(Clone)]
-pub struct Pair {
-    pub(crate) car: SteelVal,
-    pub(crate) cdr: SteelVal,
-}
-
-impl Pair {
-    pub fn cons(car: SteelVal, cdr: SteelVal) -> Self {
-        Pair { car, cdr }
-    }
-
-    pub fn car(&self) -> SteelVal {
-        self.car.clone()
-    }
-
-    pub fn cdr(&self) -> SteelVal {
-        self.cdr.clone()
-    }
-}
-
-impl std::fmt::Debug for Pair {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "({} . {})", &self.car, &self.cdr)
-    }
-}
-
-#[cfg(feature = "without-drop-protection")]
-type DropHandlerChoice = im_lists::handler::DefaultDropHandler;
-#[cfg(not(feature = "without-drop-protection"))]
-type DropHandlerChoice = list_drop_handler::ListDropHandler;
-
-thread_local! {
-    pub static DEPTH: Cell<usize> = Cell::new(0);
-}
-
-#[cfg(not(feature = "without-drop-protection"))]
-mod list_drop_handler {
-
-    use std::collections::VecDeque;
-
-    use super::*;
-
-    pub struct ListDropHandler;
-
-    use crate::rvals::cycles::{drop_impls::DROP_BUFFER, IterativeDropHandler};
-
-    impl
-        DropHandler<
-            im_lists::list::GenericList<SteelVal, im_lists::shared::RcPointer, 256, 1, Self>,
-        > for ListDropHandler
-    {
-        fn drop_handler(
-            obj: &mut im_lists::list::GenericList<
-                SteelVal,
-                im_lists::shared::RcPointer,
-                256,
-                1,
-                Self,
-            >,
-        ) {
-            // println!("CALLING DROP HANDLER: {}", obj.strong_count());
-            // DEPTH.with(|x| x.set(x.get() + 1));
-            // println!("Current depth: {}", DEPTH.with(|x| x.get()));
-
-            if obj.strong_count() == 1 {
-                if obj.len() == 0 {
-                    // println!("Early returning");
-                    // DEPTH.with(|x| x.set(x.get() - 1));
-                    return;
-                }
-
-                // println!("Doing stuff...");
-
-                if DROP_BUFFER
-                    .try_with(|drop_buffer| {
-                        if let Ok(mut drop_buffer) = drop_buffer.try_borrow_mut() {
-                            for value in std::mem::take(obj).draining_iterator() {
-                                drop_buffer.push_back(value);
-                            }
-
-                            IterativeDropHandler::bfs(&mut drop_buffer);
-                        } else {
-                            let mut drop_buffer = VecDeque::new();
-
-                            for value in std::mem::take(obj) {
-                                drop_buffer.push_back(value);
-                            }
-
-                            IterativeDropHandler::bfs(&mut drop_buffer);
-                        }
-                    })
-                    .is_err()
-                {
-                    let mut drop_buffer = VecDeque::new();
-                    for value in std::mem::take(obj).draining_iterator() {
-                        drop_buffer.push_back(value);
-                    }
-
-                    IterativeDropHandler::bfs(&mut drop_buffer);
-                }
-            }
-
-            // DEPTH.with(|x| x.set(x.get() - 1));
-        }
-    }
-}
-
-// TODO: Change this to just be something like `SteelList`
-pub type List<T> =
-    im_lists::list::GenericList<T, im_lists::shared::RcPointer, 256, 1, DropHandlerChoice>;
-
-pub type ConsumingIterator<T> =
-    im_lists::list::ConsumingIter<T, im_lists::shared::RcPointer, 256, 1, DropHandlerChoice>;
diff --git a/crates/steel-core/src/values/mod.rs b/crates/steel-core/src/values/mod.rs
deleted file mode 100644
index 5d7cea4c7..000000000
--- a/crates/steel-core/src/values/mod.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#[allow(dead_code)]
-pub(crate) mod closed;
-pub(crate) mod contracts;
-pub(crate) mod functions;
-pub(crate) mod json_vals;
-pub(crate) mod lazy_stream;
-pub(crate) mod lists;
-pub(crate) mod port;
-pub(crate) mod structs;
-pub(crate) mod transducers;
-
-pub use closed::RootToken;
-pub use closed::RootedSteelVal;
-
-// pub(crate) mod upvalue;
diff --git a/crates/steel-core/src/values/port.rs b/crates/steel-core/src/values/port.rs
deleted file mode 100644
index dd2f555d8..000000000
--- a/crates/steel-core/src/values/port.rs
+++ /dev/null
@@ -1,456 +0,0 @@
-use std::fs::File;
-use std::fs::OpenOptions;
-use std::io;
-use std::io::prelude::*;
-use std::io::Cursor;
-use std::io::{BufReader, BufWriter, Stdin, Stdout};
-use std::process::ChildStdin;
-use std::process::ChildStdout;
-use std::sync::Arc;
-use std::sync::Mutex;
-
-// use serr::{SErr, SResult};
-// use utils::chars::Chars;
-// use utils::{new_rc_ref_cell, RcRefCell};
-
-use crate::rerrs;
-use crate::rvals::Result;
-use crate::SteelErr;
-
-// use crate::rvals::{new_rc_ref_cell, RcRefSteelVal};
-
-use std::cell::RefCell;
-use std::rc::Rc;
-
-// pub<T> type RcRefCell: Rc<RcRefCell<T>>;
-
-pub type RcRefCell<T> = Rc<RefCell<T>>;
-pub fn new_rc_ref_cell<T>(x: T) -> RcRefCell<T> {
-    Rc::new(RefCell::new(x))
-}
-
-thread_local! {
-    // TODO: This needs to be per engine, not global, and functions should accept the port they use
-    // Probably by boxing up the port that gets used
-    pub static DEFAULT_OUTPUT_PORT: RcRefCell<SteelPort> = new_rc_ref_cell(SteelPort { port: new_rc_ref_cell(SteelPortRepr::StdOutput(io::stdout())) } );
-    pub static CAPTURED_OUTPUT_PORT: RcRefCell<BufWriter<Vec<u8>>> = new_rc_ref_cell(BufWriter::new(Vec::new()));
-
-    // pub static STANDARD_OUT: SteelPort = SteelPort::StringOutput(Rc::new(RefCell::new(BufWriter::new(Vec::new()))));
-}
-
-#[derive(Debug, Clone)]
-pub struct SteelPort {
-    pub(crate) port: RcRefCell<SteelPortRepr>,
-}
-
-// #[derive(Debug)]
-pub enum SteelPortRepr {
-    FileInput(String, BufReader<File>),
-    FileOutput(String, BufWriter<File>),
-    StdInput(Stdin),
-    StdOutput(Stdout),
-    ChildStdOutput(BufReader<ChildStdout>),
-    ChildStdInput(BufWriter<ChildStdin>),
-    StringInput(BufReader<Cursor<Vec<u8>>>),
-    StringOutput(BufWriter<Vec<u8>>),
-    DynWriter(Arc<Mutex<dyn Write + Send + Sync>>),
-    // DynReader(Box<dyn Read>),
-    Closed,
-}
-
-impl std::fmt::Debug for SteelPortRepr {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            SteelPortRepr::FileInput(name, w) => {
-                f.debug_tuple("FileInput").field(name).field(w).finish()
-            }
-            SteelPortRepr::FileOutput(name, w) => {
-                f.debug_tuple("FileOutput").field(name).field(w).finish()
-            }
-            SteelPortRepr::StdInput(s) => f.debug_tuple("StdInput").field(s).finish(),
-            SteelPortRepr::StdOutput(s) => f.debug_tuple("StdOutput").field(s).finish(),
-            SteelPortRepr::ChildStdOutput(s) => f.debug_tuple("ChildStdOutput").field(s).finish(),
-            SteelPortRepr::ChildStdInput(s) => f.debug_tuple("ChildStdInput").field(s).finish(),
-            SteelPortRepr::StringInput(s) => f.debug_tuple("StringInput").field(s).finish(),
-            SteelPortRepr::StringOutput(s) => f.debug_tuple("StringOutput").field(s).finish(),
-            SteelPortRepr::DynWriter(_) => f.debug_tuple("DynWriter").field(&"#<opaque>").finish(),
-            SteelPortRepr::Closed => f.debug_tuple("Closed").finish(),
-        }
-    }
-}
-
-pub enum SendablePort {
-    StdInput(Stdin),
-    StdOutput(Stdout),
-    BoxDynWriter(Arc<Mutex<dyn Write + Send + Sync>>),
-    Closed,
-}
-
-impl SendablePort {
-    fn from_port_repr(value: &SteelPortRepr) -> Result<SendablePort> {
-        match value {
-            SteelPortRepr::StdInput(_) => Ok(SendablePort::StdInput(io::stdin())),
-            SteelPortRepr::StdOutput(_) => Ok(SendablePort::StdOutput(io::stdout())),
-            SteelPortRepr::Closed => Ok(SendablePort::Closed),
-            _ => {
-                stop!(Generic => "Unable to send port across threads: {:?}", value)
-            }
-        }
-    }
-
-    pub fn from_port(value: SteelPort) -> Result<SendablePort> {
-        Self::from_port_repr(&value.port.borrow())
-    }
-}
-
-impl SteelPort {
-    pub fn from_sendable_port(value: SendablePort) -> Self {
-        match value {
-            SendablePort::StdInput(s) => SteelPort {
-                port: new_rc_ref_cell(SteelPortRepr::StdInput(s)),
-            },
-            SendablePort::StdOutput(s) => SteelPort {
-                port: new_rc_ref_cell(SteelPortRepr::StdOutput(s)),
-            },
-            SendablePort::Closed => SteelPort {
-                port: new_rc_ref_cell(SteelPortRepr::Closed),
-            },
-            SendablePort::BoxDynWriter(w) => SteelPort {
-                port: new_rc_ref_cell(SteelPortRepr::DynWriter(w)),
-            },
-        }
-    }
-}
-
-// TODO: Probably replace this with dynamic dispatch over writers?
-// #[derive(Debug, Clone)]
-// pub enum SteelPort {
-//     FileInput(String, RcRefCell<BufReader<File>>),
-//     FileOutput(String, RcRefCell<BufWriter<File>>),
-//     StdInput(RcRefCell<Stdin>),
-//     StdOutput(RcRefCell<Stdout>),
-//     ChildStdOutput(RcRefCell<BufReader<ChildStdout>>),
-//     ChildStdInput(RcRefCell<BufWriter<ChildStdin>>),
-//     // StringInput(RcRefCell<BufReader<&[u8]>>),
-//     StringOutput(RcRefCell<BufWriter<Vec<u8>>>),
-//     // DynWriter(Rc<RefCell<Box<dyn Write>>>),
-//     // DynReader(Rc<RefCell<Box<dyn Read>>>),
-//     Closed,
-// }
-
-#[macro_export]
-macro_rules! port_read_str_fn(
-    ($br: ident, $fn: ident) => {{
-        let mut result = String::new();
-        let size = $br.$fn(&mut result)?;
-        Ok((size, result))
-    }};
-);
-
-impl SteelPortRepr {
-    pub fn read_line(&mut self) -> Result<(usize, String)> {
-        match self {
-            SteelPortRepr::FileInput(_, br) => port_read_str_fn!(br, read_line),
-            SteelPortRepr::StdInput(br) => port_read_str_fn!(br, read_line),
-
-            SteelPortRepr::ChildStdOutput(br) => {
-                // let buf_reader = BufReader::new(br.borrow_mut().as_mut());
-
-                port_read_str_fn!(br, read_line)
-
-                // todo!()
-
-                // buf_reader
-            }
-
-            // SteelPort::ChildStdOutput(br) => port_read_str_fn!(br, read_line),
-            // FIXME: fix this and the functions below
-            _x => stop!(Generic => "read-line"),
-        }
-    }
-
-    pub fn flush(&mut self) -> Result<()> {
-        match self {
-            SteelPortRepr::FileOutput(_, s) => Ok(s.flush()?),
-            SteelPortRepr::StdOutput(s) => Ok(s.flush()?),
-            SteelPortRepr::ChildStdInput(s) => Ok(s.flush()?),
-            SteelPortRepr::StringOutput(s) => Ok(s.flush()?),
-            SteelPortRepr::DynWriter(s) => Ok(s.lock().unwrap().flush()?),
-            SteelPortRepr::Closed => Ok(()),
-            _ => stop!(TypeMismatch => "expected an output port, found: {:?}", self),
-        }
-    }
-
-    pub fn read_all_str(&mut self) -> Result<(usize, String)> {
-        match self {
-            SteelPortRepr::FileInput(_, br) => port_read_str_fn!(br, read_to_string),
-            SteelPortRepr::StdInput(br) => port_read_str_fn!(br, read_to_string),
-            _x => stop!(Generic => "read-all-str"),
-        }
-    }
-
-    pub fn read_char(&mut self) -> Result<(usize, char)> {
-        // FIXME: this only reads 1 u8 and casts it to char
-        macro_rules! port_read_chr(
-            ($br: ident) => {{
-                let mut chr = [0; 1];
-                $br.read_exact(&mut chr)?;
-                Ok((1, chr[0] as char))
-            }};
-        );
-
-        match self {
-            SteelPortRepr::FileInput(_, br) => port_read_chr!(br),
-            SteelPortRepr::StdInput(br) => port_read_chr!(br),
-            _x => stop!(Generic => "read-char"),
-        }
-    }
-
-    pub fn write_char(&mut self, c: char) -> Result<()> {
-        macro_rules! write_string(
-            ($br: ident) => {{
-                write!($br, "{}", c)?;
-                $br.flush()?;
-            }};
-        );
-
-        match self {
-            SteelPortRepr::FileOutput(_, br) => write_string!(br),
-            SteelPortRepr::StringOutput(br) => write_string!(br),
-            SteelPortRepr::StdOutput(out) => {
-                let mut br = out.lock();
-                write!(br, "{}", c)?;
-                br.flush()?;
-            }
-            SteelPortRepr::DynWriter(o) => {
-                let mut br = o.lock().unwrap();
-                write!(br, "{}", c)?;
-                br.flush()?;
-            }
-            _x => stop!(Generic => "write-car"),
-        };
-
-        Ok(())
-    }
-
-    pub fn write_string(&mut self, string: &str) -> Result<()> {
-        macro_rules! write_string(
-            ($br: ident) => {{
-                write!($br, "{}", string)?;
-                $br.flush()?;
-            }};
-        );
-
-        match self {
-            SteelPortRepr::FileOutput(_, br) => write_string!(br),
-            SteelPortRepr::StdOutput(out) => {
-                let mut br = out.lock();
-                write!(br, "{}", string)?;
-                br.flush()?;
-            }
-            SteelPortRepr::DynWriter(o) => {
-                let mut br = o.lock().unwrap();
-                write!(br, "{}", string)?;
-                br.flush()?;
-            }
-            SteelPortRepr::StringOutput(br) => write_string!(br),
-            _x => stop!(Generic => "write-string"),
-        };
-
-        Ok(())
-    }
-
-    pub fn write_string_line(&mut self, string: &str) -> Result<()> {
-        macro_rules! write_string(
-            ($br: ident) => {{
-                write!($br, "{}\n", string)?;
-                $br.flush()?;
-            }};
-        );
-
-        match self {
-            SteelPortRepr::FileOutput(_, br) => write_string!(br),
-            SteelPortRepr::StdOutput(br) => write_string!(br),
-            SteelPortRepr::ChildStdInput(br) => write_string!(br),
-            SteelPortRepr::StringOutput(br) => write_string!(br),
-            SteelPortRepr::DynWriter(br) => {
-                let mut br = br.lock().unwrap();
-                write_string!(br)
-            }
-            _x => stop!(Generic => "write-string"),
-        };
-
-        Ok(())
-    }
-
-    pub fn is_input(&self) -> bool {
-        matches!(
-            self,
-            SteelPortRepr::FileInput(_, _) | SteelPortRepr::StdInput(_)
-        )
-    }
-
-    pub fn is_output(&self) -> bool {
-        matches!(
-            self,
-            SteelPortRepr::FileOutput(_, _)
-                | SteelPortRepr::StdOutput(_)
-                | SteelPortRepr::DynWriter(_)
-        )
-    }
-
-    pub fn is_textual(&self) -> bool {
-        matches!(
-            self,
-            SteelPortRepr::FileInput(_, _)
-                | SteelPortRepr::FileOutput(_, _)
-                | SteelPortRepr::StdOutput(_)
-                | SteelPortRepr::StdInput(_)
-        )
-    }
-
-    pub fn get_output_string(&mut self) -> Result<String> {
-        if let SteelPortRepr::StringOutput(s) = self {
-            // Ensure that this is flushed
-            s.flush()?;
-
-            String::from_utf8(s.get_ref().to_vec())
-                .map_err(|err| SteelErr::new(rerrs::ErrorKind::Generic, err.to_string()))
-        } else {
-            stop!(TypeMismatch => "get-output-string expects an output port, found: {:?}", self);
-        }
-    }
-
-    pub fn close_output_port(&mut self) -> Result<()> {
-        match self {
-            SteelPortRepr::FileOutput(_, _) | SteelPortRepr::StdOutput(_) => {
-                *self = SteelPortRepr::Closed;
-                Ok(())
-            }
-            _ => {
-                stop!(TypeMismatch => "close-output-port expects an output port, found: {:?}", self)
-            }
-        }
-    }
-}
-
-impl SteelPort {
-    pub fn new_textual_file_input(path: &str) -> Result<SteelPort> {
-        let file = OpenOptions::new().read(true).open(path)?;
-
-        Ok(SteelPort {
-            port: new_rc_ref_cell(SteelPortRepr::FileInput(
-                path.to_string(),
-                BufReader::new(file),
-            )),
-        })
-    }
-
-    pub fn new_textual_file_output(path: &str) -> Result<SteelPort> {
-        let file = OpenOptions::new()
-            .truncate(true)
-            .write(true)
-            .create(true)
-            .open(path)?;
-
-        Ok(SteelPort {
-            port: new_rc_ref_cell(SteelPortRepr::FileOutput(
-                path.to_string(),
-                BufWriter::new(file),
-            )),
-        })
-    }
-
-    pub fn new_input_port_string(string: String) -> SteelPort {
-        SteelPort {
-            port: new_rc_ref_cell(SteelPortRepr::StringInput(BufReader::new(Cursor::new(
-                string.into_bytes(),
-            )))),
-        }
-    }
-
-    pub fn new_output_port() -> SteelPort {
-        SteelPort {
-            port: new_rc_ref_cell(SteelPortRepr::StringOutput(BufWriter::new(Vec::new()))),
-        }
-    }
-
-    //
-    // Read functions
-    //
-    pub fn read_line(&self) -> Result<(usize, String)> {
-        self.port.borrow_mut().read_line()
-    }
-
-    // TODO: Implement the rest of the flush methods
-    pub fn flush(&self) -> Result<()> {
-        self.port.borrow_mut().flush()
-    }
-
-    pub fn read_all_str(&self) -> Result<(usize, String)> {
-        self.port.borrow_mut().read_all_str()
-    }
-
-    pub fn read_char(&self) -> Result<(usize, char)> {
-        self.port.borrow_mut().read_char()
-    }
-
-    pub fn write_char(&self, c: char) -> Result<()> {
-        self.port.borrow_mut().write_char(c)
-    }
-
-    //
-    // Write functions
-    //
-    pub fn write_string(&self, string: &str) -> Result<()> {
-        self.port.borrow_mut().write_string(string)
-    }
-
-    pub fn write_string_line(&self, string: &str) -> Result<()> {
-        self.port.borrow_mut().write_string_line(string)
-    }
-
-    //
-    // Checks
-    //
-    pub fn is_input(&self) -> bool {
-        self.port.borrow().is_input()
-    }
-
-    pub fn is_output(&self) -> bool {
-        self.port.borrow().is_output()
-    }
-
-    pub fn is_textual(&self) -> bool {
-        self.port.borrow().is_textual()
-    }
-
-    pub fn default_current_input_port() -> Self {
-        SteelPort {
-            port: new_rc_ref_cell(SteelPortRepr::StdInput(io::stdin())),
-        }
-    }
-
-    pub fn default_current_output_port() -> Self {
-        if cfg!(test) {
-            // Write out to thread safe port
-            SteelPort {
-                port: new_rc_ref_cell(SteelPortRepr::DynWriter(Arc::new(Mutex::new(
-                    BufWriter::new(Vec::new()),
-                )))),
-            }
-        } else {
-            SteelPort {
-                port: new_rc_ref_cell(SteelPortRepr::StdOutput(io::stdout())),
-            }
-        }
-    }
-
-    pub fn get_output_string(&self) -> Result<String> {
-        self.port.borrow_mut().get_output_string()
-    }
-
-    pub fn close_output_port(&self) -> Result<()> {
-        self.port.borrow_mut().close_output_port()
-    }
-}
diff --git a/crates/steel-core/src/values/structs.rs b/crates/steel-core/src/values/structs.rs
deleted file mode 100644
index aea2af618..000000000
--- a/crates/steel-core/src/values/structs.rs
+++ /dev/null
@@ -1,1106 +0,0 @@
-#![allow(unused)]
-#![allow(clippy::type_complexity)]
-
-use im_rc::HashMap;
-use once_cell::sync::Lazy;
-
-use crate::compiler::map::SymbolMap;
-use crate::parser::interner::InternedString;
-use crate::rerrs::ErrorKind;
-use crate::rvals::{
-    from_serializable_value, into_serializable_value, Custom, HeapSerializer, SerializableSteelVal,
-    SerializedHeapRef, SteelHashMap,
-};
-use crate::steel_vm::register_fn::RegisterFn;
-use crate::throw;
-use crate::{
-    core::utils::Boxed,
-    rvals::{FromSteelVal, IntoSteelVal},
-};
-use crate::{
-    gc::Gc,
-    rvals::{AsRefSteelVal, SRef, SteelString},
-};
-use crate::{
-    rvals::{Result, SteelVal},
-    SteelErr,
-};
-use crate::{steel_vm::builtin::BuiltInModule, stop};
-use std::collections::VecDeque;
-use std::sync::Arc;
-use std::{
-    cell::{Ref, RefCell},
-    rc::Rc,
-};
-
-use super::closed::Heap;
-use super::functions::BoxedDynFunction;
-
-enum StringOrMagicNumber {
-    String(Rc<String>),
-    Magic(usize),
-}
-
-// #[derive(Debug)]
-pub struct VTableEntry {
-    pub(crate) name: InternedString,
-    pub(crate) properties: Gc<im_rc::HashMap<SteelVal, SteelVal>>,
-    pub(crate) proc: Option<usize>,
-    pub(crate) transparent: bool,
-    pub(crate) mutable: bool,
-}
-
-pub(crate) struct SendableVTableEntry {
-    pub(crate) name: InternedString,
-    pub(crate) properties: Vec<(SerializableSteelVal, SerializableSteelVal)>,
-    pub(crate) proc: Option<usize>,
-    pub(crate) transparent: bool,
-    pub(crate) mutable: bool,
-}
-
-impl VTableEntry {
-    pub fn new(name: InternedString, proc: Option<usize>) -> Self {
-        Self {
-            name,
-            proc,
-            properties: DEFAULT_PROPERTIES.with(|x| x.clone()),
-            transparent: false,
-            mutable: false,
-        }
-    }
-}
-
-// If they're built in, we want to package the values alongside the
-#[derive(Debug, Clone, Hash)]
-pub enum Properties {
-    BuiltIn,
-    Local(Gc<im_rc::HashMap<SteelVal, SteelVal>>),
-}
-
-impl Properties {
-    pub fn ptr_eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Local(l), Self::Local(r)) => Gc::ptr_eq(l, r),
-            (Self::BuiltIn, Self::BuiltIn) => true,
-            _ => false,
-        }
-    }
-}
-
-#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
-// Wrap the usize, store this and this only. We use this as an index into the VTable.
-pub struct StructTypeDescriptor(usize);
-
-impl Custom for StructTypeDescriptor {}
-
-impl StructTypeDescriptor {
-    fn name(&self) -> InternedString {
-        VTABLE.with(|x| x.borrow().entries[self.0].name)
-    }
-}
-
-pub struct SerializableUserDefinedStruct {
-    pub(crate) fields: Vec<SerializableSteelVal>,
-
-    pub(crate) type_descriptor: StructTypeDescriptor,
-}
-
-#[derive(Clone, Debug, Hash)]
-pub struct UserDefinedStruct {
-    // pub(crate) name: InternedString,
-
-    // TODO: Consider using... just a vec here.
-    #[cfg(feature = "smallvec")]
-    pub(crate) fields: smallvec::SmallVec<[SteelVal; 5]>,
-
-    #[cfg(not(feature = "smallvec"))]
-    pub(crate) fields: Vec<SteelVal>,
-
-    // Type Descriptor. Use this as an index into the VTable to find anything that we need.
-    pub(crate) type_descriptor: StructTypeDescriptor,
-}
-
-impl UserDefinedStruct {
-    pub fn name(&self) -> InternedString {
-        self.type_descriptor.name()
-    }
-
-    pub fn is_transparent(&self) -> bool {
-        self.get(&TRANSPARENT_KEY.with(|x| x.clone()))
-            .and_then(|x| x.as_bool())
-            .unwrap_or_default()
-    }
-}
-
-// TODO: This could blow the stack for big trees...
-impl PartialEq for UserDefinedStruct {
-    fn eq(&self, other: &Self) -> bool {
-        self.type_descriptor == other.type_descriptor && self.fields == other.fields
-    }
-}
-
-impl std::fmt::Display for UserDefinedStruct {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self
-            .get(&SteelVal::SymbolV(SteelString::from("#:transparent")))
-            .is_some()
-        {
-            write!(f, "({}", self.type_descriptor.name())?;
-            // for i in 0..self.len - 1 {
-            //     write!(f, " {}", self.fields[i])?;
-            // }
-
-            for i in self.fields.iter() {
-                write!(f, " {}", i)?;
-            }
-
-            write!(f, ")")
-        } else {
-            write!(f, "({})", self.name())
-        }
-    }
-}
-
-impl UserDefinedStruct {
-    fn new(
-        // name: InternedString,
-        type_descriptor: StructTypeDescriptor,
-        fields: &[SteelVal],
-    ) -> Self {
-        // let (options, rest) = fields.split_first().ok_or_else(
-        //     throw!(ArityMismatch => "struct constructor expects at least one argument"),
-        // )?;
-
-        // let (proc, rest) = rest.split_first().ok_or_else(
-        //     throw!(ArityMismatch => "struct constructor expects at least one argument"),
-        // )?;
-
-        // todo!()
-
-        Self {
-            // name,
-            fields: fields.to_vec(),
-            // properties: Properties::BuiltIn,
-            // proc: None,
-            type_descriptor,
-        }
-
-        // Ok(Self {
-
-        // })
-
-        // TODO: Don't use a hashmap for these properties. Probably best to have some kind of fixed purpose
-        // data structure? A hashmap is also fine, but something that is required to be constructed with only
-        // constants could be helpful.
-        // if let SteelVal::HashMapV(properties) = options.clone() {
-        // Don't do this - we don't want to have to do a hash every time?
-        // let proc = PROC_PROPERTY.with(|property_keyword| {
-        //     properties
-        //         .get(property_keyword)
-        //         .and_then(|value| value.as_usize())
-        // });
-
-        // Ok(Self {
-        // name,
-        // fields: rest.into(),
-        // len: fields.len(),
-        // properties: Properties::Local(properties),
-        // proc: proc.as_usize(),
-        // type_descriptor,
-        // })
-        // } else {
-        // stop!(TypeMismatch => format!("struct constructor expected a hashmap, found: {options}"))
-        // }
-    }
-
-    pub(crate) fn get(&self, val: &SteelVal) -> Option<SteelVal> {
-        VTABLE.with(|x| {
-            x.borrow().entries[self.type_descriptor.0]
-                .properties
-                .get(val)
-                .cloned()
-        })
-
-        // match &self.properties {
-        // Properties::BuiltIn => VTable::get(&self.name).and_then(|x| x.get(val).cloned()),
-        // Properties::Local(p) => p.get(val).cloned(),
-        // }
-    }
-
-    #[inline(always)]
-    fn new_ok<T: IntoSteelVal>(value: T) -> Result<SteelVal> {
-        OK_CONSTRUCTOR.with(|x| x(&[value.into_steelval()?]))
-    }
-
-    #[inline(always)]
-    fn new_err<T: IntoSteelVal>(value: T) -> Result<SteelVal> {
-        ERR_CONSTRUCTOR.with(|x| x(&[value.into_steelval()?]))
-    }
-
-    // TODO: This doesn't particularly play nice with dynamic libraries. Should probably just assign some IDs
-    // to these structs and use them that way
-    #[inline(always)]
-    fn is_ok(&self) -> bool {
-        // todo!()
-        self.type_descriptor.name() == *OK_RESULT_LABEL
-        // Arc::ptr_eq(&self.name, &OK_RESULT_LABEL.with(|x| Rc::clone(x)))
-        //     || self.name == OK_RESULT_LABEL.with(|x| Rc::clone(x))
-    }
-
-    #[inline(always)]
-    fn is_err(&self) -> bool {
-        // todo!()
-        self.type_descriptor.name() == *ERR_RESULT_LABEL
-        // Arc::ptr_eq(&self.name, &ERR_RESULT_LABEL.with(|x| Rc::clone(x)))
-        //     || self.name == ERR_RESULT_LABEL.with(|x| Rc::clone(x))
-    }
-
-    pub(crate) fn maybe_proc(&self) -> Option<&SteelVal> {
-        // self.proc.as_ref().map(|s| &self.fields[*s])
-
-        VTABLE.with(|x| {
-            x.borrow().entries[self.type_descriptor.0]
-                .proc
-                .as_ref()
-                .map(|s| &self.fields[*s])
-        })
-    }
-
-    fn new_with_options(
-        // name: InternedString,
-        properties: Properties,
-        type_descriptor: StructTypeDescriptor,
-        rest: &[SteelVal],
-    ) -> Self {
-        Self {
-            // name,
-            fields: rest.to_vec(),
-            // len: rest.len() + 1,
-            // properties,
-            // proc: None,
-            type_descriptor,
-        }
-    }
-
-    fn constructor_thunk(
-        // options: Properties,
-        len: usize,
-        descriptor: StructTypeDescriptor,
-    ) -> impl Fn(&[SteelVal]) -> Result<SteelVal> {
-        move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != len {
-                let error_message = format!(
-                    "{} expected {} arguments, found {}",
-                    descriptor.name(),
-                    args.len(),
-                    len
-                );
-                stop!(ArityMismatch => error_message);
-            }
-
-            let new_struct =
-                UserDefinedStruct::new_with_options(Properties::BuiltIn, descriptor, args);
-
-            Ok(SteelVal::CustomStruct(Gc::new(new_struct)))
-        }
-    }
-
-    fn constructor_with_options(
-        // options: Gc<HashMap<SteelVal, SteelVal>>,
-        // options: Properties,
-        len: usize,
-        descriptor: StructTypeDescriptor,
-    ) -> SteelVal {
-        // let out_name = Arc::clone(&name);
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != len {
-                let error_message = format!(
-                    "{} expected {} arguments, found {}",
-                    descriptor.name().clone(),
-                    args.len(),
-                    len
-                );
-                stop!(ArityMismatch => error_message);
-            }
-
-            let new_struct =
-                UserDefinedStruct::new_with_options(Properties::BuiltIn, descriptor, args);
-
-            Ok(SteelVal::CustomStruct(Gc::new(new_struct)))
-        };
-
-        SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-            Arc::new(f),
-            Some(descriptor.name().resolve().to_string().into()),
-            Some(len),
-        )))
-    }
-
-    fn constructor(
-        name: InternedString,
-        len: usize,
-        type_descriptor: StructTypeDescriptor,
-    ) -> SteelVal {
-        // let out_name = Arc::clone(&name);
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != len {
-                let error_message = format!(
-                    "{} expected {} arguments, found {}",
-                    name.clone(),
-                    args.len(),
-                    len
-                );
-                stop!(ArityMismatch => error_message);
-            }
-
-            // Definitely use interned symbols for these. Otherwise we're going to be doing A LOT of
-            // arc cloning, and we don't want that.
-            let new_struct = UserDefinedStruct::new(type_descriptor, args);
-
-            Ok(SteelVal::CustomStruct(Gc::new(new_struct)))
-        };
-
-        SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-            Arc::new(f),
-            Some(name.resolve().to_string().into()),
-            Some(len),
-        )))
-    }
-
-    fn predicate(descriptor: StructTypeDescriptor) -> SteelVal {
-        // let out_name = Arc::clone(&name);
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                let error_message = format!(
-                    "{}? expected one argument, found {}",
-                    descriptor.name(),
-                    args.len()
-                );
-                stop!(ArityMismatch => error_message);
-            }
-            Ok(SteelVal::BoolV(match &args[0] {
-                SteelVal::CustomStruct(my_struct) if my_struct.type_descriptor == descriptor => {
-                    true
-                }
-                // SteelVal::CustomStruct(my_struct) if my_struct.name == name => true,
-                _ => false,
-            }))
-        };
-
-        SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-            Arc::new(f),
-            // Some(out_name),
-            Some(descriptor.name().resolve().to_string().into()),
-            Some(1),
-        )))
-    }
-
-    fn getter_prototype(descriptor: StructTypeDescriptor) -> SteelVal {
-        // let out_name = Arc::clone(&name);
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 2 {
-                stop!(ArityMismatch => format!("{} expected two arguments", descriptor.name()));
-            }
-
-            let steel_struct = &args[0].clone();
-            let idx = &args[1].clone();
-
-            match (&steel_struct, &idx) {
-                (SteelVal::CustomStruct(s), SteelVal::IntV(idx)) => {
-                    if s.type_descriptor != descriptor {
-                        // println!("{}, {}", s.borrow().name.resolve(), name.resolve());
-
-                        stop!(TypeMismatch => format!("Struct getter expected {}, found {:?}, {:?}", descriptor.name(), &s, &steel_struct));
-                    }
-
-                    if *idx < 0 {
-                        stop!(Generic => "struct-ref expected a non negative index");
-                    }
-
-                    s.fields
-                        .get(*idx as usize)
-                        .cloned()
-                        .ok_or_else(throw!(Generic => "struct-ref: index out of bounds"))
-                }
-                _ => {
-                    let error_message = format!(
-                        "{} expected a struct and an int, found: {} and {}",
-                        descriptor.name(),
-                        steel_struct,
-                        idx
-                    );
-                    stop!(TypeMismatch => error_message)
-                }
-            }
-        };
-
-        SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-            Arc::new(f),
-            // Some(out_name),
-            Some(descriptor.name().resolve().to_string().into()),
-            Some(2),
-        )))
-    }
-
-    fn getter_prototype_index(descriptor: StructTypeDescriptor, index: usize) -> SteelVal {
-        // let out_name = Arc::clone(&name);
-
-        let f = move |args: &[SteelVal]| -> Result<SteelVal> {
-            if args.len() != 1 {
-                stop!(ArityMismatch => "struct-ref expected one argument");
-            }
-
-            let steel_struct = &args[0].clone();
-
-            match &steel_struct {
-                SteelVal::CustomStruct(s) => {
-                    // println!("{}, {}", s.borrow().name.resolve(), name.resolve());
-
-                    if s.type_descriptor != descriptor {
-                        stop!(TypeMismatch => format!("Struct getter expected {}, found {:?}, {:?}", descriptor.name(), &s, &steel_struct));
-                    }
-
-                    s.fields
-                        .get(index)
-                        .cloned()
-                        .ok_or_else(throw!(Generic => "struct-ref: index out of bounds"))
-                }
-                _ => {
-                    let error_message = format!(
-                        "{} expected a struct and an int, found: {} and {}",
-                        descriptor.name(),
-                        steel_struct,
-                        index
-                    );
-                    stop!(TypeMismatch => error_message)
-                }
-            }
-        };
-
-        SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-            Arc::new(f),
-            Some(descriptor.name().resolve().to_string().into()),
-            Some(1),
-        )))
-    }
-
-    // pub fn properties(&self) -> SteelVal {
-    // SteelVal::HashMapV(self.properties.clone())
-    // }
-}
-
-pub fn make_struct_type(args: &[SteelVal]) -> Result<SteelVal> {
-    if args.len() != 2 {
-        stop!(ArityMismatch => "make-struct-type expects 2 args, found: {}", args.len())
-    }
-
-    // Convert the string into an Arc'd string - this now makes the generated functions
-    // thread safe.
-    let name: InternedString = if let SteelVal::SymbolV(s) = &args[0] {
-        Ok::<_, SteelErr>(s)
-    } else {
-        stop!(TypeMismatch => format!("make-struct-type expected a symbol for the name, found: {}", &args[0]));
-    }?.as_str().into();
-
-    let field_count = if let SteelVal::IntV(i) = &args[1] {
-        Ok::<_, SteelErr>(i)
-    } else {
-        stop!(TypeMismatch => format!("make-struct-type expected an integer for the field count, found: {}", &args[0]));
-    }?;
-
-    // Make a slot in the VTable for this struct
-    let struct_type_descriptor = VTable::new_entry(name, None);
-
-    // Build out the constructor and the predicate
-    let struct_constructor =
-        UserDefinedStruct::constructor(name, *field_count as usize, struct_type_descriptor);
-    let struct_predicate = UserDefinedStruct::predicate(struct_type_descriptor);
-
-    let getter_prototype = UserDefinedStruct::getter_prototype(struct_type_descriptor);
-
-    // We do not have the properties yet. Should probably intern the
-    // let struct_type_id = new_type_id(name, address_or_name)
-
-    Ok(SteelVal::ListV(
-        vec![
-            // Convert this into a descriptor before we're done
-            struct_type_descriptor.into_steelval().unwrap(),
-            struct_constructor,
-            struct_predicate,
-            getter_prototype,
-            // struct_type_descriptor,
-        ]
-        .into(),
-    ))
-}
-
-/*
-TODO:
-
-Create something like a type-id - dispatch from there to the proper implementation by consulting
-the VTable.
-
-Implementing a trait for a type should error if the trait is already implemented, and the predicate
-for checking if a trait is implemented should just consult the table.
-
-There should be a way to move things over
-
-
-*/
-
-// Implement internal thing here?
-struct SteelTrait {
-    name: InternedString,
-    method_names: Vec<InternedString>,
-}
-
-struct SteelTraitImplementation {}
-
-// Thread local v-table reference.
-// Rather than have structs hold their options directly, we will include a map which
-// is just a weak reference to the original arc. Then, in order to access the vtable, we use the Arc'd
-// name as a key, and use that to grab the properties. Under any circumstance that I am aware of,
-// the entry in the vtable should be alive for as long as the struct is legally allowed to be accessed.
-pub struct VTable {
-    map: fxhash::FxHashMap<InternedString, Gc<im_rc::HashMap<SteelVal, SteelVal>>>,
-
-    traits: fxhash::FxHashMap<InternedString, fxhash::FxHashMap<InternedString, Vec<SteelVal>>>,
-
-    entries: Vec<VTableEntry>,
-}
-
-impl VTable {
-    fn insert(name: InternedString, options: Gc<im_rc::HashMap<SteelVal, SteelVal>>) {
-        VTABLE.with(|x| x.borrow_mut().map.insert(name, options));
-    }
-
-    fn get(name: &InternedString) -> Option<Gc<im_rc::HashMap<SteelVal, SteelVal>>> {
-        VTABLE.with(|x| x.borrow().map.get(name).cloned())
-    }
-
-    pub(crate) fn sendable_entries(
-        serializer: &mut std::collections::HashMap<usize, SerializableSteelVal>,
-        visited: &mut std::collections::HashSet<usize>,
-    ) -> Result<Vec<SendableVTableEntry>> {
-        VTABLE.with(|x| {
-            x.borrow()
-                .entries
-                .iter()
-                .map(|entry| {
-                    Ok(SendableVTableEntry {
-                        name: entry.name,
-                        proc: entry.proc,
-                        transparent: entry.transparent,
-                        mutable: entry.mutable,
-                        properties: entry
-                            .properties
-                            .iter()
-                            .map(|(key, value)| {
-                                Ok((
-                                    into_serializable_value(key.clone(), serializer, visited)?,
-                                    into_serializable_value(value.clone(), serializer, visited)?,
-                                ))
-                            })
-                            .collect::<Result<Vec<_>>>()?,
-                    })
-                })
-                .collect()
-        })
-    }
-
-    pub(crate) fn initialize_new_thread(
-        values: Vec<SendableVTableEntry>,
-        heap: &mut HeapSerializer,
-    ) {
-        for (index, entry) in values.into_iter().enumerate() {
-            Self::new_entry(entry.name, entry.proc);
-
-            let properties = Gc::new(
-                entry
-                    .properties
-                    .into_iter()
-                    .map(|(k, v)| {
-                        (
-                            from_serializable_value(heap, k),
-                            from_serializable_value(heap, v),
-                        )
-                    })
-                    .collect(),
-            );
-
-            Self::set_entry(&StructTypeDescriptor(index), entry.proc, properties);
-        }
-    }
-
-    // Returns a type descriptor, in this case it is just a usize
-    pub fn new_entry(name: InternedString, proc: Option<usize>) -> StructTypeDescriptor {
-        VTABLE.with(|x| {
-            let mut guard = x.borrow_mut();
-            let length = guard.entries.len();
-
-            guard.entries.push(VTableEntry::new(name, proc));
-
-            StructTypeDescriptor(length)
-        })
-    }
-
-    // Updates the entry with the now available property information
-    pub fn set_entry(
-        descriptor: &StructTypeDescriptor,
-        proc: Option<usize>,
-        properties: Gc<im_rc::HashMap<SteelVal, SteelVal>>,
-    ) {
-        VTABLE.with(|x| {
-            let mut guard = x.borrow_mut();
-
-            let index = descriptor.0;
-
-            let value = &mut guard.entries[index];
-
-            value.proc = proc;
-
-            // TODO: Lift these strings to the thread local
-            value.transparent = properties
-                .get(&TRANSPARENT_KEY.with(|x| x.clone()))
-                .and_then(|x| x.as_bool())
-                .unwrap_or_default();
-            value.mutable = properties
-                .get(&MUTABLE_KEY.with(|x| x.clone()))
-                .and_then(|x| x.as_bool())
-                .unwrap_or_default();
-
-            value.properties = properties;
-        })
-    }
-
-    // fn define_trait()
-}
-
-pub static OK_RESULT_LABEL: Lazy<InternedString> = Lazy::new(|| "Ok".into());
-pub static SOME_OPTION_LABEL: Lazy<InternedString> = Lazy::new(|| "Some".into());
-pub static ERR_RESULT_LABEL: Lazy<InternedString> = Lazy::new(|| "Err".into());
-pub static NONE_OPTION_LABEL: Lazy<InternedString> = Lazy::new(|| "None".into());
-pub static TYPE_ID: Lazy<InternedString> = Lazy::new(|| "TypeId".into());
-
-pub static STRUCT_DEFINITIONS: Lazy<Arc<std::sync::RwLock<SymbolMap>>> =
-    Lazy::new(|| Arc::new(std::sync::RwLock::new(SymbolMap::default())));
-
-// TODO: Just make these Arc'd and lazy static instead of thread local.
-thread_local! {
-
-    pub static TRANSPARENT_KEY: SteelVal = SteelVal::SymbolV("#:transparent".into());
-    pub static MUTABLE_KEY: SteelVal = SteelVal::SymbolV("#:mutable".into());
-
-    // Consult this to get values. It is possible, the vtable is _not_ populated for a given thread.
-    // The only way that can happen is if a struct is constructed on another thread?
-    // The value inside should explicitly be a thread safe value.
-    pub static VTABLE: Rc<RefCell<VTable>> = {
-
-        let mut map = fxhash::FxHashMap::default();
-
-        let result_options = Gc::new(im_rc::hashmap! {
-            SteelVal::SymbolV("#:transparent".into()) => SteelVal::BoolV(true),
-        });
-
-        map.insert("Ok".into(), result_options.clone());
-        map.insert("Err".into(), result_options.clone());
-        map.insert("Some".into(), result_options.clone());
-        map.insert("None".into(), result_options.clone());
-        map.insert("TypeId".into(), result_options.clone());
-
-        Rc::new(RefCell::new(VTable {
-            map,
-            traits: fxhash::FxHashMap::default(),
-            entries: Vec::new(),
-        }))
-    };
-
-    pub static DEFAULT_PROPERTIES: Gc<im_rc::HashMap<SteelVal, SteelVal>> = Gc::new(im_rc::HashMap::new());
-    pub static STANDARD_OPTIONS: Gc<im_rc::HashMap<SteelVal, SteelVal>> = Gc::new(im_rc::hashmap! {
-            SteelVal::SymbolV("#:transparent".into()) => SteelVal::BoolV(true),
-    });
-
-
-    pub static OK_DESCRIPTOR: StructTypeDescriptor = VTable::new_entry(*OK_RESULT_LABEL, None);
-    pub static ERR_DESCRIPTOR: StructTypeDescriptor = VTable::new_entry(*ERR_RESULT_LABEL, None);
-    pub static SOME_DESCRIPTOR: StructTypeDescriptor = VTable::new_entry(*SOME_OPTION_LABEL, None);
-    pub static NONE_DESCRIPTOR: StructTypeDescriptor = VTable::new_entry(*NONE_OPTION_LABEL, None);
-
-
-    // pub static OK_RESULT_LABEL: Rc<String> = Rc::new("Ok".into());
-    // pub static ERR_RESULT_LABEL: Rc<String> = Rc::new("Err".into());
-    // pub static RESULT_OPTIONS: Gc<im_rc::HashMap<SteelVal, SteelVal>> = Gc::new(im_rc::hashmap! {
-        // SteelVal::SymbolV("#:transparent".into()) => SteelVal::BoolV(true),
-    // });
-    pub static OK_CONSTRUCTOR: Rc<Box<dyn Fn(&[SteelVal]) -> Result<SteelVal>>> = {
-            Rc::new(Box::new(UserDefinedStruct::constructor_thunk(
-            1,
-            OK_DESCRIPTOR.with(|x| *x),
-        )))
-    };
-
-    pub static ERR_CONSTRUCTOR: Rc<Box<dyn Fn(&[SteelVal]) -> Result<SteelVal>>> = {
-        // let name = ERR_RESULT_LABEL.with(|x| Rc::clone(x));
-        Rc::new(Box::new(UserDefinedStruct::constructor_thunk(
-            1,
-            ERR_DESCRIPTOR.with(|x| *x),
-        )))
-    };
-
-    // pub static SOME_OPTION_LABEL: Rc<String> = Rc::new("Some".into());
-    // pub static NONE_LABEL: Rc<String> = Rc::new("None".into());
-    pub static OPTION_OPTIONS: Gc<im_rc::HashMap<SteelVal, SteelVal>> = Gc::new(im_rc::hashmap! {
-        SteelVal::SymbolV("#:transparent".into()) => SteelVal::BoolV(true),
-    });
-    pub static SOME_CONSTRUCTOR: Rc<Box<dyn Fn(&[SteelVal]) -> Result<SteelVal>>> = {
-        // let name = SOME_OPTION_LABEL.with(|x| Rc::clone(x));
-        Rc::new(Box::new(UserDefinedStruct::constructor_thunk(
-            1,
-            SOME_DESCRIPTOR.with(|x| *x),
-        )))
-    };
-
-    pub static NONE_CONSTRUCTOR: Rc<Box<dyn Fn(&[SteelVal]) -> Result<SteelVal>>> = {
-        // let name = NONE_LABEL.with(|x| Rc::clone(x));
-        Rc::new(Box::new(UserDefinedStruct::constructor_thunk(
-            0,
-            NONE_DESCRIPTOR.with(|x| *x),
-        )))
-    };
-}
-
-pub(crate) fn build_type_id_module() -> BuiltInModule {
-    let mut module = BuiltInModule::new("steel/core/types");
-
-    let name = *TYPE_ID;
-
-    let type_descriptor = VTable::new_entry(name, None);
-
-    // Build the getter for the first index
-    let getter = UserDefinedStruct::getter_prototype_index(type_descriptor, 0);
-    let predicate = UserDefinedStruct::predicate(type_descriptor);
-
-    let constructor = Arc::new(UserDefinedStruct::constructor_thunk(2, type_descriptor));
-
-    module
-        .register_fn("#%vtable-update-entry!", VTable::set_entry)
-        // .register_value(
-        //     "TypeId",
-        //     SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-        //         constructor,
-        //         Some(name.resolve().to_string().into()),
-        //         Some(2),
-        //     ))),
-        // )
-        .register_value("TypeId?", predicate);
-    // .register_native_fn_definition(CUSTOM_TYPE_ID_DEFINITION);
-
-    module
-}
-
-pub(crate) fn build_result_structs() -> BuiltInModule {
-    // Build module
-    let mut module = BuiltInModule::new("steel/core/result".to_string());
-
-    {
-        let name = *OK_RESULT_LABEL;
-
-        let type_descriptor = OK_DESCRIPTOR.with(|x| *x);
-
-        // Build the getter for the first index
-        let getter = UserDefinedStruct::getter_prototype_index(type_descriptor, 0);
-        let predicate = UserDefinedStruct::predicate(type_descriptor);
-
-        VTable::set_entry(
-            &OK_DESCRIPTOR.with(|x| *x),
-            None,
-            STANDARD_OPTIONS.with(|x| x.clone()),
-        );
-
-        VTable::set_entry(
-            &ERR_DESCRIPTOR.with(|x| *x),
-            None,
-            STANDARD_OPTIONS.with(|x| x.clone()),
-        );
-
-        module
-            .register_value(
-                "Ok",
-                SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-                    Arc::new(UserDefinedStruct::constructor_thunk(
-                        // Rc::clone(&name),
-                        1,
-                        OK_DESCRIPTOR.with(|x| *x),
-                    )),
-                    // Some(Rc::clone(&name)),
-                    Some(name.resolve().to_string().into()),
-                    Some(1),
-                ))),
-            )
-            .register_value("Ok?", predicate)
-            .register_value("Ok->value", getter);
-    }
-
-    {
-        // let name = ERR_RESULT_LABEL.with(|x| Rc::clone(x));
-        let name = *ERR_RESULT_LABEL;
-
-        let type_descriptor = ERR_DESCRIPTOR.with(|x| *x);
-
-        // let constructor = UserDefinedStruct::constructor(Rc::clone(&name), 1);
-        let predicate = UserDefinedStruct::predicate(type_descriptor);
-
-        // Build the getter for the first index
-        let getter = UserDefinedStruct::getter_prototype_index(type_descriptor, 0);
-
-        module
-            .register_value(
-                "Err",
-                SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-                    Arc::new(UserDefinedStruct::constructor_thunk(
-                        // Rc::clone(&name),
-                        1,
-                        ERR_DESCRIPTOR.with(|x| *x),
-                    )),
-                    Some(name.resolve().to_string().into()),
-                    Some(1),
-                ))),
-            )
-            .register_value("Err?", predicate)
-            .register_value("Err->value", getter);
-    }
-
-    module
-}
-
-pub(crate) fn build_option_structs() -> BuiltInModule {
-    // Build module
-    let mut module = BuiltInModule::new("steel/core/option".to_string());
-
-    VTable::set_entry(
-        &SOME_DESCRIPTOR.with(|x| *x),
-        None,
-        STANDARD_OPTIONS.with(|x| x.clone()),
-    );
-
-    VTable::set_entry(
-        &NONE_DESCRIPTOR.with(|x| *x),
-        None,
-        STANDARD_OPTIONS.with(|x| x.clone()),
-    );
-
-    {
-        // let name = SOME_OPTION_LABEL.with(|x| Rc::clone(x));
-        let name = *SOME_OPTION_LABEL;
-        let type_descriptor = SOME_DESCRIPTOR.with(|x| *x);
-
-        // Build the getter for the first index
-        let getter = UserDefinedStruct::getter_prototype_index(type_descriptor, 0);
-        let predicate = UserDefinedStruct::predicate(type_descriptor);
-
-        module
-            .register_value(
-                "Some",
-                SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-                    Arc::new(UserDefinedStruct::constructor_thunk(
-                        // Rc::clone(&name),
-                        1,
-                        SOME_DESCRIPTOR.with(|x| *x),
-                    )),
-                    Some(name.resolve().to_string().into()),
-                    Some(1),
-                ))),
-            )
-            .register_value("Some?", predicate)
-            .register_value("Some->value", getter);
-    }
-
-    {
-        // let name = NONE_LABEL.with(|x| Rc::clone(x));
-        let name = *NONE_OPTION_LABEL;
-        let type_descriptor = NONE_DESCRIPTOR.with(|x| *x);
-        let predicate = UserDefinedStruct::predicate(type_descriptor);
-
-        module
-            .register_value(
-                "None",
-                SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new_owned(
-                    Arc::new(UserDefinedStruct::constructor_thunk(
-                        0,
-                        NONE_DESCRIPTOR.with(|x| *x),
-                    )),
-                    Some(name.resolve().to_string().into()),
-                    Some(0),
-                ))),
-            )
-            .register_value("None?", predicate);
-    }
-
-    module
-}
-
-pub struct RecoverableResult<T, E>(std::result::Result<T, E>);
-
-impl<T: IntoSteelVal, E: IntoSteelVal> IntoSteelVal for RecoverableResult<T, E> {
-    #[inline(always)]
-    fn into_steelval(self) -> Result<SteelVal> {
-        match self.0 {
-            Ok(s) => s.into_steelval(),
-            Err(e) => UserDefinedStruct::new_err(e.into_steelval()?),
-        }
-    }
-}
-
-impl<T: IntoSteelVal, E: IntoSteelVal> From<RecoverableResult<T, E>> for std::result::Result<T, E> {
-    fn from(value: RecoverableResult<T, E>) -> Self {
-        value.0
-    }
-}
-
-impl<T: IntoSteelVal, E: IntoSteelVal> From<std::result::Result<T, E>> for RecoverableResult<T, E> {
-    fn from(value: std::result::Result<T, E>) -> Self {
-        RecoverableResult(value)
-    }
-}
-
-/// Result type that automatically maps into the equivalent Result type within Steel.
-/// For example, `Ok(10)` will map to `(Ok 10)`, and `Err(10)` will map to `(Err 10)`.
-pub struct SteelResult<T, E>(std::result::Result<T, E>);
-impl<T: IntoSteelVal, E: IntoSteelVal> IntoSteelVal for SteelResult<T, E> {
-    #[inline(always)]
-    fn into_steelval(self) -> Result<SteelVal> {
-        match self.0 {
-            Ok(s) => UserDefinedStruct::new_ok(s),
-            Err(e) => UserDefinedStruct::new_err(e.into_steelval()?),
-        }
-    }
-}
-
-impl<T: IntoSteelVal, E: IntoSteelVal> From<SteelResult<T, E>> for std::result::Result<T, E> {
-    fn from(value: SteelResult<T, E>) -> Self {
-        value.0
-    }
-}
-
-impl<T: IntoSteelVal, E: IntoSteelVal> From<std::result::Result<T, E>> for SteelResult<T, E> {
-    fn from(value: std::result::Result<T, E>) -> Self {
-        SteelResult(value)
-    }
-}
-
-// By default, the standard result type will automatically unwrap ok values, and raise errors
-// if they occur as genuine steel errors. If you'd like to catch these, you can set up an exception handler.
-// The runtime cost for this is relatively low.
-impl<T: IntoSteelVal, E: IntoSteelVal> IntoSteelVal for std::result::Result<T, E> {
-    fn into_steelval(self) -> Result<SteelVal> {
-        match self {
-            Ok(s) => s.into_steelval(),
-            Err(e) => Err(SteelErr::new(
-                ErrorKind::Generic,
-                e.into_steelval()?.to_string(),
-            )),
-        }
-    }
-}
-
-impl<T: FromSteelVal, E: FromSteelVal> FromSteelVal for std::result::Result<T, E> {
-    fn from_steelval(val: &SteelVal) -> Result<Self> {
-        if let SteelVal::CustomStruct(s) = val {
-            if s.is_ok() {
-                Ok(Ok(T::from_steelval(s.fields.get(0).unwrap())?))
-            } else if s.is_err() {
-                Ok(Err(E::from_steelval(s.fields.get(0).unwrap())?))
-            } else {
-                stop!(ConversionError => format!("Failed attempting to convert an instance of a steelval into a result type: {val:?}"))
-            }
-        } else {
-            stop!(ConversionError => format!("Failed attempting to convert an instance of a steelval into a result type - value is not a struct: {val:?}"));
-        }
-    }
-}
-
-// #[cfg(test)]
-// mod struct_tests {
-
-//     use super::*;
-
-//     fn apply_function(func: SteelVal, args: Vec<SteelVal>) -> Result<SteelVal> {
-//         let func = func
-//             .boxed_func_or_else(throw!(BadSyntax => "string tests"))
-//             .unwrap();
-
-//         func(&args)
-//     }
-
-//     #[test]
-//     fn constructor_normal() {
-//         let args = vec![SteelVal::IntV(1), SteelVal::IntV(2)];
-//         let res = apply_function(constructor(Rc::from("Promise"), 2), args);
-//         let expected = SteelVal::StructV(Gc::new(SteelStruct {
-//             name: Rc::from("Promise"),
-//             fields: vec![SteelVal::IntV(1), SteelVal::IntV(2)],
-//         }));
-//         assert_eq!(res.unwrap(), expected)
-//     }
-
-//     #[test]
-//     fn setter_position_0() {
-//         let args = vec![
-//             SteelVal::StructV(Gc::new(SteelStruct {
-//                 name: Rc::from("Promise"),
-//                 fields: vec![SteelVal::IntV(1), SteelVal::IntV(2)],
-//             })),
-//             SteelVal::IntV(100),
-//         ];
-
-//         let res = apply_function(setter(Rc::from("Promise"), 0), args);
-//         let expected = SteelVal::StructV(Gc::new(SteelStruct {
-//             name: Rc::from("Promise"),
-//             fields: vec![SteelVal::IntV(100), SteelVal::IntV(2)],
-//         }));
-//         assert_eq!(res.unwrap(), expected);
-//     }
-
-//     #[test]
-//     fn setter_position_1() {
-//         let args = vec![
-//             SteelVal::StructV(Gc::new(SteelStruct {
-//                 name: Rc::from("Promise"),
-//                 fields: vec![SteelVal::IntV(1), SteelVal::IntV(2)],
-//             })),
-//             SteelVal::IntV(100),
-//         ];
-
-//         let res = apply_function(setter(Rc::from("Promise"), 1), args);
-//         let expected = SteelVal::StructV(Gc::new(SteelStruct {
-//             name: Rc::from("Promise"),
-//             fields: vec![SteelVal::IntV(1), SteelVal::IntV(100)],
-//         }));
-//         assert_eq!(res.unwrap(), expected);
-//     }
-
-//     #[test]
-//     fn getter_position_0() {
-//         let args = vec![SteelVal::StructV(Gc::new(SteelStruct {
-//             name: Rc::from("Promise"),
-//             fields: vec![SteelVal::IntV(1), SteelVal::IntV(2)],
-//         }))];
-
-//         let res = apply_function(getter(Rc::from("Promise"), 0), args);
-//         let expected = SteelVal::IntV(1);
-//         assert_eq!(res.unwrap(), expected);
-//     }
-// }
-
-// #[test]
-// fn small_vec_size() {
-//     println!(
-//         "{:?}",
-//         std::mem::size_of::<smallvec::SmallVec<[SteelVal; 5]>>()
-//     );
-//     println!("{:?}", std::mem::size_of::<MaybeHeapVec>())
-// }
diff --git a/crates/steel-core/src/values/transducers.rs b/crates/steel-core/src/values/transducers.rs
deleted file mode 100644
index 8ae02c28a..000000000
--- a/crates/steel-core/src/values/transducers.rs
+++ /dev/null
@@ -1,178 +0,0 @@
-use crate::gc::Gc;
-use crate::rvals::Result;
-use crate::SteelVal;
-
-use crate::core::utils::{arity_check, declare_const_ref_functions};
-
-// Make a transducer actually contain an option to a rooted value, otherwise
-// it is a source agnostic transformer on the (eventual) input
-#[derive(Clone, PartialEq, Hash)]
-pub struct Transducer {
-    // root: Gc<SteelVal>,
-    pub ops: Vec<Transducers>,
-}
-
-impl Transducer {
-    pub fn new() -> Self {
-        Transducer { ops: Vec::new() }
-    }
-
-    pub fn append(&mut self, mut other: Self) {
-        self.ops.append(&mut other.ops)
-    }
-
-    pub fn push(&mut self, t: Transducers) {
-        self.ops.push(t);
-    }
-}
-
-impl Default for Transducer {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[derive(Clone, PartialEq, Hash)]
-pub enum Transducers {
-    Map(SteelVal),          // function
-    Filter(SteelVal),       // function
-    Take(SteelVal),         // integer
-    Drop(SteelVal),         // integer
-    FlatMap(SteelVal),      // function
-    Flatten,                // Takes nothing
-    Window(SteelVal),       // integer
-    TakeWhile(SteelVal),    // function
-    DropWhile(SteelVal),    // function
-    Extend(SteelVal),       // Collection
-    Cycle,                  // Continue forever
-    Enumerating,            // turns (a b c) into ((0 a) (1 b) (2 c))
-    Zipping(SteelVal),      // Combine with another iterator, either a Collection or a Transducer
-    Interleaving(SteelVal), // Interleave with another interator, either a Collection or a Transducer
-}
-
-// This should just describe how a sequence of values can be reduced
-// assert that the function passed in has an arity of 2
-// and the initival
-#[derive(Clone, Debug)]
-pub struct ReducerFunc {
-    pub(crate) initial_value: SteelVal,
-    pub(crate) function: SteelVal,
-}
-
-impl ReducerFunc {
-    fn new(initial_value: SteelVal, function: SteelVal) -> Self {
-        ReducerFunc {
-            initial_value,
-            function,
-        }
-    }
-}
-
-// Defines how to collect a function
-// defaults to the same input type?
-
-#[derive(Clone, Debug)]
-pub enum Reducer {
-    // Sum the sequence
-    Sum,
-    // Multiply the sequence
-    Multiply,
-    // Find the Max of the sequence
-    Max,
-    // Find the min of the sequence
-    Min,
-    // Count the elements in the sequence
-    Count,
-    // Give the nth elements
-    Nth(usize),
-    // Collect into a list
-    List,
-    // Collect into a vector
-    Vector,
-    // Collect into a hash map
-    HashMap,
-    // Collect into a hash set
-    HashSet,
-    // Collect into a string
-    String,
-    // Consumes the iterator, giving the last value
-    Last,
-    // For-each -> calls a function for each value in the sequence
-    ForEach(SteelVal),
-    // Collect according to the function
-    Generic(ReducerFunc),
-}
-
-macro_rules! into_collection {
-    ($($name:tt => $collection:tt),* $(,)? ) => {
-        $ (
-            fn $name(args: &[SteelVal]) -> Result<SteelVal> {
-                arity_check!($name, args, 0);
-                Ok(SteelVal::ReducerV(Gc::new(Reducer::$collection)))
-            }
-        ) *
-    }
-}
-
-declare_const_ref_functions! {
-    INTO_SUM => into_sum,
-    INTO_PRODUCT => into_multiply,
-    INTO_MAX => into_max,
-    INTO_MIN => into_min,
-    INTO_COUNT => into_count,
-    INTO_LIST => into_list,
-    INTO_VECTOR => into_vector,
-    INTO_HASHMAP => into_hashmap,
-    INTO_HASHSET => into_hashset,
-    INTO_STRING => into_string,
-    INTO_LAST => into_last,
-    FOR_EACH => for_each,
-    REDUCER => generic,
-    NTH => nth,
-}
-
-into_collection! {
-    into_sum => Sum,
-    into_multiply => Multiply,
-    into_max => Max,
-    into_min => Min,
-    into_count => Count,
-    into_list => List,
-    into_vector => Vector,
-    into_hashmap => HashMap,
-    into_hashset => HashSet,
-    into_string => String,
-    into_last => Last
-}
-
-fn for_each(args: &[SteelVal]) -> Result<SteelVal> {
-    arity_check!(for_each, args, 1);
-    let function = args[0].clone();
-    Ok(SteelVal::ReducerV(Gc::new(Reducer::ForEach(function))))
-}
-
-fn generic(args: &[SteelVal]) -> Result<SteelVal> {
-    arity_check!(reducer, args, 2);
-    let function = args[0].clone();
-    let initial_value = args[1].clone();
-    Ok(SteelVal::ReducerV(Gc::new(Reducer::Generic(
-        ReducerFunc::new(initial_value, function),
-    ))))
-}
-
-fn nth(args: &[SteelVal]) -> Result<SteelVal> {
-    arity_check!(nth, args, 1);
-
-    let number = args[0].clone();
-
-    if let SteelVal::IntV(n) = number {
-        if n < 0 {
-            stop!(TypeMismatch => format!("nth expected a (postive) integer, found: {number}"));
-        }
-        Ok(SteelVal::ReducerV(Gc::new(Reducer::Nth(n as usize))))
-    } else {
-        stop!(TypeMismatch => format!("nth expected a (postive) integer, found: {number}"))
-    }
-}
-
-// Reducer functions
diff --git a/crates/steel-core/tests/helpers.rs b/crates/steel-core/tests/helpers.rs
deleted file mode 100644
index 93599903b..000000000
--- a/crates/steel-core/tests/helpers.rs
+++ /dev/null
@@ -1,68 +0,0 @@
-extern crate steel;
-
-use std::fs::File;
-use std::io::{BufRead, BufReader};
-// use steel::interpreter::evaluator::Evaluator;
-// use steel::parser::*;
-use steel::PRELUDE;
-use steel::{steel_vm::engine::Engine, SteelVal};
-
-// use std::collections::HashMap;
-
-/// test to make sure file used as input leads to output
-pub fn test_from_files(input_path: &str, output_path: &str) {
-    let inputfile = File::open(input_path).unwrap();
-    let outputfile = File::open(output_path).unwrap();
-    test_lines(BufReader::new(inputfile), BufReader::new(outputfile));
-}
-
-pub fn test_lines(input: impl BufRead, output: impl BufRead) {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-
-    let io_lines = input.lines().zip(output.lines());
-    for (line_in, line_out) in io_lines {
-        let line_in = line_in.unwrap();
-        let line_out = line_out.unwrap();
-        test_line(&line_in, &[&line_out], &mut evaluator);
-    }
-}
-
-// TODO -> clean this up
-// the many references are broken
-pub fn test_line(input: &str, output: &[&str], evaluator: &mut Engine) {
-    let result = evaluator.compile_and_run_raw_program(input);
-    match result {
-        Ok(vals) => {
-            println!("Expected values: {output:?}");
-            println!("Resulting values: {vals:?}");
-
-            let vals: Vec<_> = vals
-                .into_iter()
-                .filter(|x| x.clone() != SteelVal::Void)
-                .collect();
-
-            let output: Vec<&&str> = output.iter().filter(|x| **x != "#<void>").collect();
-
-            println!("post - Expected values: {output:?}");
-            println!("post - Resulting values: {vals:?}");
-
-            // TODO -> this shouldn't check this here
-            // voids should be skipped if the outputs don't match
-            // as in -> leading voids can be skipped
-            assert_eq!(output.len(), vals.len());
-
-            for (expr, &&expected) in vals.iter().zip(output.iter()) {
-                println!("expr to string: {:?}", expr.to_string());
-                println!("expected to string: {expected:?}");
-
-                assert_eq!(expr.to_string(), expected);
-                // match expr {
-                //     Ok(x) => assert_eq!(x.to_string(), expected),
-                //     Err(x) => assert_eq!(x.to_string(), expected),
-                // }
-            }
-        }
-        Err(e) => assert_eq!(e.to_string(), output[0]),
-    }
-}
diff --git a/crates/steel-core/tests/modules/a.rkt b/crates/steel-core/tests/modules/a.rkt
deleted file mode 100644
index da244566b..000000000
--- a/crates/steel-core/tests/modules/a.rkt
+++ /dev/null
@@ -1,17 +0,0 @@
-(require "b.rkt")
-
-(provide a)
-
-; (define *volatile* 0)
-
-(define (a x) (a-private) (b 100))
-(define (a-private) "hi this is a private function")
-; (define (update!) 
-;     (set! *volatile* (+ *volatile* 1)))
-
-; (define (fetch-value) *volatile*)
-
-; (provide capture-func)
-
-; (define (capture-func x)
-;     (lambda (y) (+ x y)))
\ No newline at end of file
diff --git a/crates/steel-core/tests/modules/b.rkt b/crates/steel-core/tests/modules/b.rkt
deleted file mode 100644
index 6323346e8..000000000
--- a/crates/steel-core/tests/modules/b.rkt
+++ /dev/null
@@ -1,5 +0,0 @@
-(provide b)
-
-(define (b x) (+ x 27))
-(define (c x) (+ x 350))
-(define (b-private) "hi this is a private function change this part")
\ No newline at end of file
diff --git a/crates/steel-core/tests/modules/main.rkt b/crates/steel-core/tests/modules/main.rkt
deleted file mode 100644
index 4b9877c23..000000000
--- a/crates/steel-core/tests/modules/main.rkt
+++ /dev/null
@@ -1,9 +0,0 @@
-(require "a.rkt")
-(require "b.rkt")
-; (require "sort_export.rkt")
-
-(a 10)
-(b 20)
-
-; (capture-func 10)
-
diff --git a/crates/steel-core/tests/modules/sort.rkt b/crates/steel-core/tests/modules/sort.rkt
deleted file mode 100644
index 764cfac01..000000000
--- a/crates/steel-core/tests/modules/sort.rkt
+++ /dev/null
@@ -1,39 +0,0 @@
-(provide merge-sort)
-
-;;; Define a merge sort for sake of simplicity
-(define (merge-lists l1 l2)
-  (cond [(null? l1) l2]
-        [(null? l2) l1]
-        [(< (car l1) (car l2))
-         (cons (car l1) (merge-lists (cdr l1) l2))]
-        [else
-         (cons (car l2) (merge-lists (cdr l2) l1))]))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in even positions
-
-(define (even-numbers l)
-  (cond [(null? l) '()]
-        [(null? (cdr l)) '()]
-        [else
-         (cons (car (cdr l)) (even-numbers (cdr (cdr l))))]))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in odd positions
-
-(define (odd-numbers l)
-  (cond [(null? l) '()]
-        [(null? (cdr l)) (list (car l))]
-        [else
-         (cons (car l) (odd-numbers (cdr (cdr l))))]))
-
-;;; ---------------------------------------------------------------------
-;;; Use the procedures above to create a simple and efficient merge-sort
-
-(define (merge-sort l)
-  (cond [(null? l) l]
-        [(null? (cdr l)) l]
-        [else
-         (merge-lists
-          (merge-sort (odd-numbers l))
-          (merge-sort (even-numbers l)))]))
\ No newline at end of file
diff --git a/crates/steel-core/tests/modules/sort_export.rkt b/crates/steel-core/tests/modules/sort_export.rkt
deleted file mode 100644
index 09e0e63f1..000000000
--- a/crates/steel-core/tests/modules/sort_export.rkt
+++ /dev/null
@@ -1,5 +0,0 @@
-(require "sort.rkt")
-
-(provide sort)
-
-(define (sort x) (merge-sort x))
\ No newline at end of file
diff --git a/crates/steel-core/tests/test_files/input_tests.rkt b/crates/steel-core/tests/test_files/input_tests.rkt
deleted file mode 100644
index 2073a65bd..000000000
--- a/crates/steel-core/tests/test_files/input_tests.rkt
+++ /dev/null
@@ -1,24 +0,0 @@
-1
-(+ 1 1)
-#f
-())
-(define (fac n) (if (= n 1) 1 (* n (fac (- n 1)))))
-(fac 5)
-(define (fib n) (if (<= n 2) 1 (+ (fib (- n 1)) (fib (- n 2)))))
-(fib 10)
-(define (fib-helper a b n) (if (= n 0) a (fib-helper b (+ a b) (- n 1))))
-(define (fib n) (fib-helper 0 1 n))
-(fib 60)
-(define my-func (lambda (arg1 arg2) (lambda (b) (+ arg1 arg2 b))))
-((my-func 1 2) 3)
-(define foo (lambda (w) (lambda (x) (lambda (y) (lambda (z) (+ w x y z))))))
-((((foo 1) 2) 3) 4)
-(number? (+ 1 2))
-(number? "foo")
-(string? "ye")
-(string? (- 1 2))
-(symbol? 'a)
-(symbol? "nop")
-(vector? '(1 2 3))
-(list? 'a)
-list
diff --git a/crates/steel-core/tests/test_files/output_tests.rkt b/crates/steel-core/tests/test_files/output_tests.rkt
deleted file mode 100644
index d5d9a9e7c..000000000
--- a/crates/steel-core/tests/test_files/output_tests.rkt
+++ /dev/null
@@ -1,24 +0,0 @@
-1
-2
-#false
-Error: Parse: Parse: Unexpected token: CloseParen
-#<void>
-120
-#<void>
-55
-#<void>
-#<void>
-1548008755920
-#<void>
-6
-#<void>
-10
-#true
-#false
-#true
-#false
-#true
-#false
-#false
-#false
-#<function:list>
\ No newline at end of file
diff --git a/crates/steel-core/tests/testbench.rs b/crates/steel-core/tests/testbench.rs
deleted file mode 100644
index 9631f507d..000000000
--- a/crates/steel-core/tests/testbench.rs
+++ /dev/null
@@ -1,383 +0,0 @@
-mod helpers;
-extern crate steel;
-
-use std::{io::Read, path::PathBuf};
-
-use helpers::*;
-use steel::steel_vm::engine::Engine;
-use steel::PRELUDE;
-
-#[test]
-fn basic_test() {
-    test_from_files(
-        "tests/test_files/input_tests.rkt",
-        "tests/test_files/output_tests.rkt",
-    );
-}
-
-// Fixes issue reported https://github.com/mattwparas/steel/issues/73
-#[test]
-fn top_level_error_allows_redefining() {
-    let mut evaluator = Engine::new();
-
-    evaluator.run("(define (x) (- x 2))").unwrap();
-
-    evaluator.run("(x)").unwrap_err();
-
-    evaluator.run("(define (x) (- x 2))").unwrap();
-}
-
-#[test]
-fn module_test() {
-    let mut evaluator = Engine::new();
-
-    let path_buf = PathBuf::from("tests/modules/main.rkt");
-    let mut file = std::fs::File::open(&path_buf).unwrap();
-    let mut exprs = String::new();
-    file.read_to_string(&mut exprs).unwrap();
-
-    evaluator
-        .compile_and_run_raw_program_with_path(&exprs, path_buf)
-        .unwrap();
-    test_line("(a 10)", &["127"], &mut evaluator);
-    test_line("(b 20)", &["47"], &mut evaluator);
-    evaluator
-        .compile_and_run_raw_program("b-private")
-        .unwrap_err();
-}
-
-#[test]
-fn redefinition_of_values_over_time() {
-    let mut vm = Engine::new();
-
-    vm.compile_and_run_raw_program("(define + -)").unwrap();
-    let res = vm.compile_and_run_raw_program("(+ 10 20)").unwrap();
-
-    assert_eq!(res[0], steel::SteelVal::IntV(-10));
-}
-
-#[test]
-fn redefinition_of_functions_for_constant_evaluation() {
-    let mut vm = Engine::new();
-
-    vm.compile_and_run_raw_program("(define foo-bar (lambda (x y) (+ x y)))")
-        .unwrap();
-    let res = vm.compile_and_run_raw_program("(foo-bar 10 20)").unwrap();
-
-    assert_eq!(res[0], steel::SteelVal::IntV(30));
-
-    vm.compile_and_run_raw_program("(define foo-bar (lambda (x y) (#%black-box) (- x y)))")
-        .unwrap();
-    let res = vm.compile_and_run_raw_program("(foo-bar 10 20)").unwrap();
-    assert_eq!(res[0], steel::SteelVal::IntV(-10));
-}
-
-#[test]
-fn module_test_chain() {
-    let mut vm = Engine::new();
-    vm.compile_and_run_raw_program(
-        r#"
-        (require "tests/modules/sort_export.rkt")
-
-        (define sorted (sort '(1000 342 1 5534 34243 223 23495)))
-    "#,
-    )
-    .unwrap();
-}
-
-#[test]
-fn if_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    test_line("(if #t 'a 2)", &["'a"], &mut evaluator);
-    test_line("(if 'a 'b 1)", &["'b"], &mut evaluator);
-    test_line(
-        "(if (= 1 (begin (display 10) 1)) a 2)",
-        &["Error: FreeIdentifier: a"],
-        &mut evaluator,
-    );
-    test_line(
-        "(if (= 1 (begin (display 10) 1)) a 2)",
-        &["Error: FreeIdentifier: a"],
-        &mut evaluator,
-    );
-    test_line(
-        "(if (= 1 1))",
-        &["Error: Parse: Parse: Syntax Error: if expects a then condition, found none"],
-        &mut evaluator,
-    );
-    test_line(
-        "(if 1 2 3 4)",
-        &["Error: Parse: Parse: Syntax Error: if takes only 3 expressions"],
-        &mut evaluator,
-    );
-}
-
-#[test]
-fn define_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("a", &["Error: FreeIdentifier: a"], e);
-    test_line(
-        "(define a (lambda (x) (+ x 1)) wat)",
-        &["Error: Parse: Parse: Syntax Error: Define expected only one expression after the identifier"],
-        e,
-    );
-    test_line(
-        "(define a)",
-        &["Error: Parse: Parse: Syntax Error: define statement expected a body, found none"],
-        e,
-    );
-    test_line("(define a (lambda (x) (+ x 1)))", &["#<void>"], e);
-    test_line("a", &["#<bytecode-closure>"], e);
-    test_line("(a 2)", &["3"], e);
-    test_line("(define (b a1 a2 a3) (+ a1 a2 a3))", &["#<void>"], e);
-    test_line("(b 10 20 30)", &["60"], e);
-    test_line("(define b 10)", &["#<void>"], e);
-    test_line("b", &["10"], e);
-    test_line("a1", &["Error: FreeIdentifier: a1"], e);
-}
-
-#[test]
-fn lambda_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(lambda (x) 1 2)", &["#<bytecode-closure>"], e);
-    // test_line(
-    //     "(lambda x 1)",
-    //     &["Error: Parse: Parse: Syntax Error: lambda function expected a list of identifiers"],
-    //     e,
-    // );
-    test_line("(lambda () 1)", &["#<bytecode-closure>"], e);
-    test_line(
-        "(lambda () (lambda () (lambda () (lambda () 1))))",
-        &["#<bytecode-closure>"],
-        e,
-    );
-    test_line(
-        "(define x (lambda (w) (lambda (x y) (lambda (z) (lambda (a) (+ w x y z a))))))",
-        &["#<void>"],
-        e,
-    );
-    test_line("((((x 1) 2 3) 4) 5)", &["15"], e);
-}
-
-#[test]
-fn set_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(set! x 10)", &["Error: FreeIdentifier: x"], e);
-    test_line(
-        "(set! x)",
-        &["Error: Parse: Parse: Arity mismatch: set! expects an identifier and an expression"],
-        e,
-    );
-    test_line(
-        "(set! x 1 2)",
-        &["Error: Parse: Parse: Arity mismatch: set! expects an identifier and an expression"],
-        e,
-    );
-    test_line(
-        "(define x 100) (set! x (+ x 1)) x",
-        &["#<void>", "100", "101"],
-        e,
-    );
-    test_line(
-        "(define x (lambda () (begin (define a 10) (set! a 20) a))) (x)",
-        &["#<void>", "20"],
-        e,
-    );
-    test_line(
-        "(define a 1000) (define x (lambda () (begin (set! a 20)  a))) (x)",
-        &["#<void>", "#<void>", "20"],
-        e,
-    );
-}
-
-#[test]
-fn let_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(let ((x 10)) (+ x x))", &["20"], e);
-    test_line("(let ((x 10) (y 20)) (+ x y))", &["30"], e);
-    test_line("(let () 1)", &["1"], e);
-    test_line(
-        "(let ((1)) x)",
-        &["Error: Parse: Parse: Syntax Error: let expected a list of variable binding pairs, found a pair with length 1"],
-        e,
-    );
-    test_line(
-        "(let ((x 1) (1)) x)",
-        &["Error: Parse: Parse: Syntax Error: let expected a list of variable binding pairs, found a pair with length 1"],
-        e,
-    );
-    test_line(
-        "(let ((x 1)))",
-        &["Error: Parse: Parse: Syntax Error: let expects an expression, found none"],
-        e,
-    );
-    test_line("(let ((x 1)) 1 2 3 4)", &["4"], e);
-}
-
-#[test]
-fn and_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(and #t #f)", &["#false"], e);
-    test_line("(and #t #t)", &["#true"], e);
-    test_line("(and a #t)", &["Error: FreeIdentifier: a"], e);
-    test_line(
-        "(and (begin (display 10) #t) a)",
-        &["Error: FreeIdentifier: a"],
-        e,
-    );
-    test_line(
-        "(and (= 1 (begin (display 10) 1)) (= 1 (begin (display 10) 2)) who are you)",
-        &["Error: FreeIdentifier: who"],
-        e,
-    );
-    test_line("(and (= 1 1) (= (+ 1 1) 2) (< 3 4))", &["#true"], e);
-}
-
-#[test]
-fn or_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(or #t #f)", &["#true"], e);
-    test_line("(or #t #t)", &["#true"], e);
-    test_line("(or #f #t)", &["#true"], e);
-    test_line(
-        "(or (= 1 (begin (display 10) 1)) a)",
-        &["Error: FreeIdentifier: a"],
-        e,
-    );
-    test_line(
-        "(or (= 1 (begin (display 10) 1)) a)",
-        &["Error: FreeIdentifier: a"],
-        e,
-    );
-    // test_line(
-    //     "(or (= 1 (begin (display 10) 1)) whatever you want idk)",
-    //     &["Error: FreeIdentifier: whatever"],
-    //     e,
-    // );
-    test_line("(or (> 3 4) (> 4 5) (> 5 6) (= 1 1))", &["#true"], e);
-}
-
-#[test]
-fn cond_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(cond [else 10])", &["10"], e);
-    test_line("(cond [#f 10] [else 20])", &["20"], e);
-    test_line(
-        "(cond
-            [#f 1]
-            [#f 2]
-            [#t 25
-                50]
-            [else 100])",
-        &["50"],
-        e,
-    );
-}
-
-#[test]
-fn when_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(when #t 10)", &["10"], e);
-    test_line("(when #f 10)", &["#<void>"], e);
-}
-
-#[test]
-fn unless_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(unless #t 10)", &["#<void>"], e);
-    test_line("(unless #f 10)", &["10"], e);
-}
-
-#[test]
-fn thread_first_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line(
-        "(->> (list 1 2 3 4)
-            (map (lambda (x) (* 2 x)))
-            (append (list 5 6))
-            (map (lambda (x) (* 5 x)))
-            (append (list 1 2 3 4)))",
-        &["'(1 2 3 4 25 30 10 20 30 40)"],
-        e,
-    );
-}
-
-#[test]
-fn thread_last_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line(
-        "(-> (list 1 2 3 4)
-            (drop 2)
-            (append (list 5 6)))",
-        &["'(3 4 5 6)"],
-        e,
-    );
-}
-
-#[test]
-fn first_apply_test() {
-    let mut evaluator = Engine::new();
-    // evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("((f> append (list 3 4)) (list 1 2))", &["'(1 2 3 4)"], e);
-}
-
-#[test]
-fn last_apply_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("((l> append (list 3 4)) (list 1 2))", &["'(3 4 1 2)"], e);
-}
-
-#[test]
-fn while_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(define x 0)", &["#<void>"], e);
-    test_line("(while (< x 5) (set! x (+ x 1))) x", &["#<void>", "5"], e);
-}
-
-#[test]
-fn map_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line(
-        "(map (lambda (x) (* 2 x)) (list 1 2 3 4))",
-        &["'(2 4 6 8)"],
-        e,
-    );
-}
-
-#[test]
-fn filter_test() {
-    let mut evaluator = Engine::new();
-    evaluator.compile_and_run_raw_program(PRELUDE).unwrap();
-    let e = &mut evaluator;
-    test_line("(filter even? (list 1 2 3 4 5))", &["'(2 4)"], e);
-}
diff --git a/crates/steel-derive/.gitignore b/crates/steel-derive/.gitignore
deleted file mode 100644
index 693699042..000000000
--- a/crates/steel-derive/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-/target
-**/*.rs.bk
-Cargo.lock
diff --git a/crates/steel-derive/Cargo.toml b/crates/steel-derive/Cargo.toml
deleted file mode 100644
index f45afb62c..000000000
--- a/crates/steel-derive/Cargo.toml
+++ /dev/null
@@ -1,19 +0,0 @@
-[package]
-name = "steel-derive"
-version = "0.4.0"
-authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
-edition = "2021"
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/mattwparas/steel"
-description = "Derive macros for use within steel"
-
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[lib]
-proc-macro = true
-
-[dependencies]
-syn = { version = "2.0.18", features = ["full"] }
-quote = "1.0.28"
-proc-macro2 = "1.0.51"
\ No newline at end of file
diff --git a/crates/steel-derive/src/lib.rs b/crates/steel-derive/src/lib.rs
deleted file mode 100644
index d85739d78..000000000
--- a/crates/steel-derive/src/lib.rs
+++ /dev/null
@@ -1,498 +0,0 @@
-extern crate proc_macro;
-extern crate proc_macro2;
-#[macro_use]
-extern crate syn;
-extern crate quote;
-use std::collections::HashMap;
-
-use proc_macro::TokenStream;
-use quote::{quote, ToTokens};
-use syn::{
-    punctuated::Punctuated, Data, DeriveInput, Expr, ExprLit, FnArg, Ident, ItemFn, Lit, Meta,
-    ReturnType, Signature, Type,
-};
-
-#[proc_macro_derive(Steel)]
-pub fn derive_steel(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    let name = &input.ident;
-
-    match &input.data {
-        Data::Struct(_) | Data::Enum(_) => {
-            let gen = quote! {
-                impl steel::rvals::Custom for #name {}
-            };
-
-            gen.into()
-        }
-        _ => {
-            let output = quote! { #input };
-            output.into()
-        }
-    }
-}
-
-fn _parse_key_value_pair(args: &Punctuated<Meta, Token![,]>) -> (String, String) {
-    for nested_meta in args.iter() {
-        if let Meta::NameValue(n) = nested_meta {
-            let key = n.path.get_ident().unwrap().to_string();
-            if let Expr::Lit(ExprLit {
-                lit: Lit::Str(s), ..
-            }) = &n.value
-            {
-                return (key, s.value());
-            }
-        }
-
-        panic!("Expected a key value pair");
-    }
-
-    panic!("Expected a key value pair");
-}
-
-fn parse_key_value_pairs(args: &Punctuated<Meta, Token![,]>) -> HashMap<String, String> {
-    let mut map = HashMap::new();
-
-    for nested_meta in args.iter() {
-        if let Meta::NameValue(n) = nested_meta {
-            let key = n.path.get_ident().unwrap().to_string();
-
-            match &n.value {
-                Expr::Lit(ExprLit {
-                    lit: Lit::Str(s), ..
-                }) => {
-                    map.insert(key, s.value());
-                }
-                Expr::Lit(ExprLit {
-                    lit: Lit::Bool(b), ..
-                }) => {
-                    map.insert(key, b.value().to_string());
-                }
-                _ => {}
-            }
-        }
-    }
-
-    map
-}
-
-fn parse_doc_comment(input: ItemFn) -> Option<String> {
-    let maybe_str_literals = input
-        .attrs
-        .into_iter()
-        .filter_map(|attr| match attr.meta {
-            Meta::NameValue(name_value) if name_value.path.is_ident("doc") => {
-                Some(name_value.value)
-            }
-            _ => None,
-        })
-        .map(|expr| match expr {
-            Expr::Lit(ExprLit {
-                lit: Lit::Str(s), ..
-            }) => Ok(s.value()),
-            e => Err(e),
-        })
-        .collect::<Result<Vec<_>, _>>();
-
-    let literals = match maybe_str_literals {
-        Ok(lits) => lits,
-        Err(_) => {
-            return None;
-            // Error::new(expr.span(), "Doc comment is not a string literal")
-            //     .into_compile_error()
-            //     .into()
-        }
-    };
-
-    if literals.is_empty() {
-        return None;
-        // Error::new(ident.span(), "No doc comment found on this type")
-        //     .into_compile_error()
-        //     .into();
-    }
-
-    let trimmed: Vec<_> = literals
-        .iter()
-        .flat_map(|lit| lit.split('\n').collect::<Vec<_>>())
-        .map(|line| line.trim().to_string())
-        .collect();
-
-    Some(trimmed.join("\n"))
-}
-
-#[proc_macro_attribute]
-pub fn define_module(
-    args: proc_macro::TokenStream,
-    input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
-    let args = parse_macro_input!(args with Punctuated::<Meta, Token![,]>::parse_terminated);
-    let input = parse_macro_input!(input as ItemFn);
-    let keyword_map = parse_key_value_pairs(&args);
-
-    let value = keyword_map
-        .get("name")
-        .expect("native definition requires a name!");
-
-    let sign: Signature = input.sig.clone();
-
-    let maybe_doc_comments = parse_doc_comment(input.clone());
-
-    let function_name = sign.ident;
-
-    if let Some(doc_comments) = maybe_doc_comments {
-        quote! {
-            pub fn #function_name() -> BuiltInModule {
-                #input
-
-                let mut module = #function_name();
-
-                module.register_doc(#value, crate::steel_vm::builtin::MarkdownDoc(#doc_comments));
-
-                module
-            }
-        }
-        .into()
-    } else {
-        quote! {
-            #input
-        }
-        .into()
-    }
-}
-
-#[proc_macro_attribute]
-pub fn native(
-    args: proc_macro::TokenStream,
-    input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
-    let args = parse_macro_input!(args with Punctuated::<Meta, Token![,]>::parse_terminated);
-
-    let keyword_map = parse_key_value_pairs(&args);
-
-    let value = keyword_map
-        .get("name")
-        .expect("native definition requires a name!");
-
-    let arity_number = keyword_map
-        .get("arity")
-        .expect("native definition requires an arity");
-
-    let is_const = keyword_map
-        .get("constant")
-        .map(|x| x == "true")
-        .unwrap_or_default();
-
-    let arity_number: syn::Expr =
-        syn::parse_str(arity_number).expect("Unable to parse arity definition");
-
-    let input = parse_macro_input!(input as ItemFn);
-
-    let modified_input = input.clone();
-    let sign: Signature = input.clone().sig;
-
-    let maybe_doc_comments = parse_doc_comment(input);
-    let function_name = sign.ident.clone();
-
-    let doc_name = Ident::new(
-        &(function_name.to_string().to_uppercase() + "_DEFINITION"),
-        sign.ident.span(),
-    );
-
-    let definition_struct = if let Some(doc) = maybe_doc_comments {
-        quote! {
-            pub const #doc_name: crate::steel_vm::builtin::NativeFunctionDefinition = crate::steel_vm::builtin::NativeFunctionDefinition {
-                name: #value,
-                func: #function_name,
-                arity: crate::steel_vm::builtin::Arity::#arity_number,
-                doc: Some(crate::steel_vm::builtin::MarkdownDoc(#doc)),
-                is_const: #is_const,
-            };
-        }
-    } else {
-        quote! {
-            pub const #doc_name: crate::steel_vm::builtin::NativeFunctionDefinition = crate::steel_vm::builtin::NativeFunctionDefinition {
-                name: #value,
-                func: #function_name,
-                arity: crate::steel_vm::builtin::Arity::#arity_number,
-                doc: None,
-                is_const: #is_const,
-            };
-        }
-    };
-
-    let output = quote! {
-        // Not sure why, but it says this is unused even when generating functions
-        // marked as pub
-        #[allow(dead_code)]
-        #modified_input
-
-        #definition_struct
-    };
-
-    // Uncomment this to see the generated code
-    // eprintln!("{}", output.to_string());
-
-    output.into()
-}
-
-// See REmacs : https://github.com/remacs/remacs/blob/16b6fb9319a6d48fbc7b27d27c3234990f6718c5/rust_src/remacs-macros/lib.rs#L17-L161
-// TODO: Pass the new name in to this function
-#[proc_macro_attribute]
-pub fn function(
-    args: proc_macro::TokenStream,
-    input: proc_macro::TokenStream,
-) -> proc_macro::TokenStream {
-    let args = parse_macro_input!(args with Punctuated::<Meta, Token![,]>::parse_terminated);
-
-    // let (_, value) = parse_key_value_pair(&args);
-
-    let keyword_map = parse_key_value_pairs(&args);
-
-    let value = keyword_map
-        .get("name")
-        .expect("native definition requires a name!");
-
-    // If this is constant evaluatable
-    let is_const = keyword_map
-        .get("constant")
-        .map(|x| x == "true")
-        .unwrap_or_default();
-
-    let function_name_with_colon = value.clone() + ": ";
-
-    let input = parse_macro_input!(input as ItemFn);
-
-    let modified_input = input.clone();
-    // let ident = input.sig.ident.clone();
-    let sign: Signature = input.clone().sig;
-
-    let maybe_doc_comments = parse_doc_comment(input);
-
-    // modified_input.attrs = Vec::new();
-
-    // let sign: Signature = input.clone().sig;
-
-    let return_type: ReturnType = sign.output;
-
-    let ret_val = match return_type {
-        ReturnType::Default => quote! {
-            Ok(SteelVal::Void)
-        },
-        ReturnType::Type(_, r) => {
-            if let Type::Path(val) = *r {
-                let last = val.path.segments.into_iter().last();
-                if let Some(last) = last {
-                    match last.ident.into_token_stream().to_string().as_str() {
-                        "Result" => quote! { res },
-                        _ => quote! {
-                            res.into_steelval().map_err(err_thunk)
-                        },
-                    }
-                } else {
-                    quote! {
-                        Ok(SteelVal::Void)
-                    }
-                }
-            } else {
-                quote! {
-                    res.into_steelval().map_err(err_thunk)
-                }
-            }
-        }
-    };
-
-    let mut type_vec: Vec<Box<Type>> = Vec::new();
-
-    let mut rest_arg_generic_inner_type = false;
-
-    for (i, arg) in sign.inputs.iter().enumerate() {
-        if let FnArg::Typed(pat_ty) = arg.clone() {
-            if let Type::Path(p) = pat_ty.ty.as_ref() {
-                let primary_type = p.path.segments.iter().last();
-                if let Some(ty) = primary_type {
-                    match ty.ident.to_token_stream().to_string().as_str() {
-                        "RestArgs" | "RestArgsIter" => {
-                            if rest_arg_generic_inner_type {
-                                panic!("There cannot be multiple `RestArg`s for a given function.")
-                            }
-
-                            if i != sign.inputs.len() - 1 {
-                                panic!(
-                                    "The rest argument must be the last argument in the function."
-                                )
-                            }
-                            rest_arg_generic_inner_type = true;
-                        }
-                        _ => {}
-                    }
-                }
-            }
-
-            type_vec.push(pat_ty.ty);
-        }
-    }
-
-    // panic!("{:?}", type_vec);
-
-    let arity_number = type_vec.len();
-
-    // TODO: Might be able to handle types with lifetimes here, both coming in and leaving
-    let conversion_functions = type_vec.clone().into_iter().map(|x| {
-        if let Type::Reference(_) = *x {
-            quote! { primitive_as_ref }
-        } else {
-            quote! { from_steelval }
-        }
-    });
-
-    let arg_enumerate = type_vec.into_iter().enumerate();
-    let arg_type = arg_enumerate.clone().map(|(_, x)| x);
-    let arg_index = arg_enumerate.clone().map(|(i, _)| i);
-    // let function_names_with_colon = std::iter::repeat(function_name_with_colon.clone());
-    let function_name = sign.ident.clone();
-    let _arity_name = Ident::new(
-        &(function_name.to_string().to_uppercase() + "_ARITY"),
-        sign.ident.span(),
-    );
-    let copied_function_name = Ident::new(
-        &("steel_".to_string() + &function_name.to_string()),
-        sign.ident.span(),
-    );
-
-    let doc_name = Ident::new(
-        &(function_name.to_string().to_uppercase() + "_DEFINITION"),
-        sign.ident.span(),
-    );
-
-    let arity_exactness = if rest_arg_generic_inner_type {
-        quote! { AtLeast }
-    } else {
-        quote! { Exact }
-    };
-
-    let definition_struct = if let Some(doc) = maybe_doc_comments {
-        quote! {
-            pub const #doc_name: crate::steel_vm::builtin::NativeFunctionDefinition = crate::steel_vm::builtin::NativeFunctionDefinition {
-                name: #value,
-                func: #copied_function_name,
-                arity: crate::steel_vm::builtin::Arity::#arity_exactness(#arity_number),
-                doc: Some(crate::steel_vm::builtin::MarkdownDoc(#doc)),
-                is_const: #is_const,
-            };
-        }
-    } else {
-        quote! {
-            pub const #doc_name: crate::steel_vm::builtin::NativeFunctionDefinition = crate::steel_vm::builtin::NativeFunctionDefinition {
-                name: #value,
-                func: #copied_function_name,
-                arity: crate::steel_vm::builtin::Arity::#arity_exactness(#arity_number),
-                doc: None,
-                is_const: #is_const,
-            };
-        }
-    };
-
-    // If we have a rest arg, we need to modify passing in values to pass in a slice to the remaining
-    // values in the
-    if rest_arg_generic_inner_type {
-        let mut conversion_functions = conversion_functions.collect::<Vec<_>>();
-        let arg_enumerate = arg_enumerate;
-        let mut arg_index = arg_enumerate
-            .map(|(i, _)| quote! { #i })
-            .collect::<Vec<_>>();
-
-        if let Some(last) = arg_index.last_mut() {
-            *last = quote! { #last.. };
-        }
-
-        let arity_number = arity_number - 1;
-
-        if let Some(last) = conversion_functions.last_mut() {
-            *last = quote! { from_slice };
-        }
-
-        let function_name = sign.ident;
-
-        let output = quote! {
-            // Not sure why, but it says this is unused even when generating functions
-            // marked as pub
-            #[allow(dead_code)]
-            #modified_input
-
-            #definition_struct
-
-            pub fn #copied_function_name(args: &[SteelVal]) -> std::result::Result<SteelVal, crate::rerrs::SteelErr> {
-
-                use crate::rvals::{IntoSteelVal, FromSteelVal, PrimitiveAsRef};
-
-                if args.len() < #arity_number {
-                    crate::stop!(ArityMismatch => format!("{} expected {} arguments, got {}", #value, #arity_number.to_string(), args.len()))
-                }
-
-                fn err_thunk(mut err: crate::rerrs::SteelErr) -> crate::rerrs::SteelErr {
-                    err.prepend_message(#function_name_with_colon);
-                    err.set_kind(crate::rerrs::ErrorKind::TypeMismatch);
-                    err
-                };
-
-                let res = #function_name(
-                    #(
-                        // TODO: Distinguish reference types here if possible - make a special implementation
-                        // for builtin pointer types here to distinguish them
-                        <#arg_type>::#conversion_functions(&args[#arg_index])
-                            .map_err(err_thunk)
-                        ?,
-                    )*
-                );
-
-                #ret_val
-            }
-        };
-
-        // Uncomment this to see the generated code
-        // eprintln!("{}", output.to_string());
-
-        return output.into();
-    }
-
-    let output = quote! {
-        // Not sure why, but it says this is unused even when generating functions
-        // marked as pub
-        #[allow(dead_code)]
-        #modified_input
-
-        #definition_struct
-
-        pub fn #copied_function_name(args: &[SteelVal]) -> std::result::Result<SteelVal, crate::rerrs::SteelErr> {
-
-            use crate::rvals::{IntoSteelVal, FromSteelVal, PrimitiveAsRef};
-
-            if args.len() != #arity_number {
-                crate::stop!(ArityMismatch => format!("{} expected {} arguments, got {}", #value, #arity_number.to_string(), args.len()))
-            }
-
-
-            fn err_thunk(mut err: crate::rerrs::SteelErr) -> crate::rerrs::SteelErr {
-                err.prepend_message(#function_name_with_colon);
-                err.set_kind(crate::rerrs::ErrorKind::TypeMismatch);
-                err
-            };
-
-            let res = #function_name(
-                #(
-                    // TODO: Distinguish reference types here if possible - make a special implementation
-                    // for builtin pointer types here to distinguish them
-                    <#arg_type>::#conversion_functions(&args[#arg_index])
-                        .map_err(err_thunk)?,
-                )*
-            );
-
-            #ret_val
-        }
-    };
-
-    // Uncomment this to see the generated code
-    // eprintln!("{}", output.to_string());
-
-    output.into()
-}
diff --git a/crates/steel-doc/Cargo.toml b/crates/steel-doc/Cargo.toml
deleted file mode 100644
index 2ab3bdb64..000000000
--- a/crates/steel-doc/Cargo.toml
+++ /dev/null
@@ -1,13 +0,0 @@
-[package]
-name = "steel-doc"
-version.workspace = true
-edition = "2021"
-authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/mattwparas/steel"
-description = "Document generation for steel"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-steel-core = { path = "../steel-core", version = "0.5.0", features = ["modules"] }
\ No newline at end of file
diff --git a/crates/steel-doc/move-docs.sh b/crates/steel-doc/move-docs.sh
deleted file mode 100644
index 7051f5388..000000000
--- a/crates/steel-doc/move-docs.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-# Build the docs, clear the target location, move the new docs there
-cargo run && \
-  rm -rf ../../docs/src/builtins && \
-  mv generated/ ../../docs/src/builtins
diff --git a/crates/steel-doc/src/lib.rs b/crates/steel-doc/src/lib.rs
deleted file mode 100644
index 98212f8c0..000000000
--- a/crates/steel-doc/src/lib.rs
+++ /dev/null
@@ -1,179 +0,0 @@
-#![allow(unused)]
-
-use std::{env::current_dir, error::Error, io::BufWriter, path::PathBuf};
-
-use steel::steel_vm::engine::Engine;
-
-use std::collections::HashSet;
-use std::io::Write;
-
-struct DocumentGenerator {
-    // Root directory for generated documentation to go
-    output_dir: PathBuf,
-    // Final output locations
-    writers: HashSet<PathBuf>,
-}
-
-impl DocumentGenerator {
-    pub fn new(output_dir: Option<PathBuf>) -> Self {
-        let output_dir = output_dir.unwrap_or({
-            // TODO: Come back and remove this unwrap
-            let mut current_dir = current_dir().unwrap();
-
-            current_dir.push("/docs");
-
-            if !current_dir.exists() {
-                std::fs::create_dir(&current_dir).unwrap();
-            }
-
-            current_dir
-        });
-
-        Self {
-            output_dir,
-            writers: HashSet::new(),
-        }
-    }
-
-    pub fn record(&mut self, path: PathBuf) {
-        self.writers.insert(path);
-    }
-}
-
-fn walk_for_defines<W: Write>(
-    writer: &mut W,
-    ast: &[steel::parser::ast::ExprKind],
-) -> Result<(), Box<dyn Error>> {
-    let mut nodes = ast.iter();
-
-    while let Some(node) = nodes.next() {
-        match &node {
-            steel::parser::ast::ExprKind::Define(d) => {
-                let name = d.name.atom_identifier().unwrap().resolve();
-
-                // We'll only check things that are values
-                if !name.starts_with("mangler") && name.ends_with("__doc__") {
-                    writeln!(writer, "### **{}**", name.trim_end_matches("__doc__"))?;
-
-                    // println!("{}")
-
-                    let ast_node = nodes.next().unwrap();
-
-                    // println!("{:?}", ast_node);
-
-                    if let steel::parser::ast::ExprKind::Define(def) = &ast_node {
-                        if let steel::parser::ast::ExprKind::Quote(q) = &def.body {
-                            if let steel::parser::ast::ExprKind::Define(d) = &q.expr {
-                                if let steel::parser::ast::ExprKind::LambdaFunction(l) = &d.body {
-                                    writeln!(writer, "```scheme")?;
-                                    write!(writer, "({}", name.trim_end_matches("__doc__"))?;
-
-                                    for arg in &l.args {
-                                        if let Some(ident) = arg.atom_identifier() {
-                                            // Macros will generate unreadable symbols - so for the sake
-                                            // of the documentation generator, we probably want to make this
-                                            // more human readable
-                                            write!(
-                                                writer,
-                                                " {}",
-                                                ident.resolve().trim_start_matches('#')
-                                            )?;
-                                        } else {
-                                            write!(writer, " {arg}")?;
-                                        }
-                                    }
-
-                                    if l.rest && l.args.len() == 1 {
-                                        write!(writer, " ...")?;
-                                    }
-
-                                    writeln!(writer, ")")?;
-                                    writeln!(writer, "```")?;
-                                }
-                            }
-                        }
-                    }
-
-                    writeln!(writer, "{}", d.body.string_literal().unwrap())?;
-                }
-            }
-
-            steel::parser::ast::ExprKind::Begin(b) => {
-                walk_for_defines(writer, &b.exprs)?;
-            }
-
-            _ => {}
-        }
-    }
-
-    Ok(())
-}
-
-fn top_level_walk_directory(path: PathBuf, vm: &mut Engine) {
-    todo!()
-}
-
-pub fn walk_dir<W: Write>(
-    writer: &mut W,
-    path: PathBuf,
-    vm: &mut Engine,
-) -> Result<(), Box<dyn Error>> {
-    if path.is_dir() {
-        // If contents are a cog module, then we should grab it
-        // OR, if at any point in the recursion we've found a cog module in the directory, we should
-        // be good to check it out
-        let directory_contents = path.read_dir()?.collect::<Result<Vec<_>, _>>()?;
-
-        for file in directory_contents {
-            let path = file.path();
-            walk_dir(writer, path, vm)?;
-        }
-    } else if path.extension().and_then(|x| x.to_str()) == Some("scm")
-        && path.file_name().and_then(|x| x.to_str()) != Some("cog.scm")
-    {
-        writeln!(writer, "# {}", path.to_str().unwrap())?;
-
-        let contents = std::fs::read_to_string(&path)?;
-
-        // let full_path = std::fs::canonicalize(path.clone()).expect("Unable to canonicalize path!");
-
-        // {
-        //     println!("Requiring: {:?}", full_path);
-        //     vm.emit_fully_expanded_ast(
-        //         &format!("(require {:?})", full_path),
-        //         Some(full_path.clone()),
-        //     )
-        //     .unwrap();
-        // }
-
-        let ast = vm.emit_fully_expanded_ast(&contents, Some(path.clone()))?;
-
-        // println!("{:?}", vm.modules().keys().collect::<Vec<_>>());
-
-        // if let Some(module) = module {
-        //     println!("{:?}", module.get_requires());
-        // }
-
-        walk_for_defines(writer, &ast)?;
-
-        // let module = vm.modules().get(&full_path);
-
-        // println!("{:?}", vm.modules().keys().collect::<Vec<_>>());
-
-        // if let Some(module) = module {
-        //     println!("{:?}", module.get_requires());
-        // }
-    }
-
-    writer.flush()?;
-
-    Ok(())
-}
-
-// Parse the cog file located at the path, and return the package name
-// Other things are probably important, but for now we'll just deal with that
-pub fn parse_cog_file(path: PathBuf) -> steel::rvals::Result<String> {
-    let contents = std::fs::read_to_string(path)?;
-    let exprs = steel::parser::parser::Parser::parse(&contents)?;
-    todo!()
-}
diff --git a/crates/steel-doc/src/main.rs b/crates/steel-doc/src/main.rs
deleted file mode 100644
index fb1d8f7cb..000000000
--- a/crates/steel-doc/src/main.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use std::io::Write;
-use steel::steel_vm::engine::Engine;
-
-fn format_markdown_doc<W: Write>(writer: &mut W, doc: &str) {
-    for line in doc.lines() {
-        if line.starts_with("# ") {
-            write!(writer, "###").unwrap();
-        }
-        writeln!(writer, "{}", line).unwrap();
-    }
-}
-
-fn main() {
-    let engine = Engine::new();
-
-    // Create the generated directory
-    std::fs::DirBuilder::new()
-        .recursive(true)
-        .create("generated")
-        .unwrap();
-
-    for (module_name, module) in engine.builtin_modules().inner().iter() {
-        if module.documentation().definitions().is_empty() {
-            continue;
-        }
-
-        let module_name_without_slashes = module_name.replace("/", "_");
-
-        let mut module_file =
-            std::fs::File::create(format!("generated/{}.md", module_name_without_slashes)).unwrap();
-
-        writeln!(&mut module_file, "# {}", module_name).unwrap();
-
-        for (name, value) in module.documentation().definitions() {
-            match value {
-                steel::steel_vm::builtin::Documentation::Markdown(m) => {
-                    writeln!(&mut module_file, "### **{}**", name).unwrap();
-
-                    format_markdown_doc(&mut module_file, m.0);
-                }
-                _ => {}
-            }
-        }
-    }
-}
diff --git a/crates/steel-gen/Cargo.toml b/crates/steel-gen/Cargo.toml
deleted file mode 100644
index 47d8dd5c1..000000000
--- a/crates/steel-gen/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "steel-gen"
-version = "0.2.0"
-edition = "2021"
-license = "MIT OR Apache-2.0"
-authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
-repository = "https://github.com/mattwparas/steel"
-description = "Code generation crates for use within steel"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-codegen = "0.2.0"
-serde = { version = "1.0.152", features = ["derive"] }
-serde_derive = "1.0.152"
diff --git a/crates/steel-gen/src/lib.rs b/crates/steel-gen/src/lib.rs
deleted file mode 100644
index c6718252d..000000000
--- a/crates/steel-gen/src/lib.rs
+++ /dev/null
@@ -1,1061 +0,0 @@
-// TODO: Create stack to ssa representation of the op codes, via macros
-#![allow(unused)]
-
-pub mod opcode;
-pub mod permutations;
-use std::{borrow::Cow, fmt::Write};
-
-pub use opcode::OpCode;
-
-use codegen::{Function, Scope};
-
-// If we can provide hints on the types, this can help with constant folding of operations
-// that we know the types of
-//
-// For instance, this can also allow specializing _lots_ of the list operations if we can pull it off
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-enum TypeHint {
-    Int,
-    Bool,
-    Float,
-    Void,
-    None,
-}
-
-#[derive(PartialEq, Clone, Debug)]
-struct LocalVariable {
-    id: u16,
-    type_hint: TypeHint,
-}
-
-impl LocalVariable {
-    pub fn kind(mut self, type_hint: TypeHint) -> Self {
-        self.type_hint = type_hint;
-        self
-    }
-}
-
-struct GenSym {
-    count: u16,
-}
-
-impl GenSym {
-    pub fn new() -> Self {
-        Self { count: 0 }
-    }
-
-    // Generate a fresh variable
-    fn fresh(&mut self) -> LocalVariable {
-        let count = self.count;
-        self.count += 1;
-        LocalVariable {
-            id: count,
-            type_hint: TypeHint::None,
-        }
-    }
-}
-
-impl std::fmt::Display for LocalVariable {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "x{}", self.id)
-    }
-}
-
-fn op_code_to_handler(op_code: Pattern) -> String {
-    format!("opcode_to_ssa_handler!({op_code})")
-}
-
-struct StackToSSAConverter {
-    generator: GenSym,
-    stack: Vec<LocalVariable>,
-    local_offset: Option<usize>,
-}
-
-#[derive(Clone, Debug, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub enum Pattern {
-    Single(OpCode),
-    Double(OpCode, usize),
-}
-
-impl std::fmt::Display for Pattern {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            Pattern::Single(op) => write!(f, "{op:?}"),
-            Pattern::Double(op, payload) => write!(f, "{op:?}{payload}"),
-        }
-    }
-}
-
-#[derive(Default)]
-struct FunctionLines {
-    lines: Vec<String>,
-}
-
-impl FunctionLines {
-    fn line(&mut self, line: impl Into<String>) {
-        self.lines.push(line.into())
-    }
-}
-
-impl StackToSSAConverter {
-    pub fn new() -> Self {
-        Self {
-            generator: GenSym::new(),
-            stack: Vec::new(),
-            local_offset: None,
-        }
-    }
-
-    pub fn reset(&mut self) {
-        self.generator.count = 0;
-        self.stack.clear();
-        self.local_offset = None;
-    }
-
-    // Get the current local offset
-    // pub fn local_offset(&self) -> usize {
-    //     self.local_offset
-    // }
-
-    pub fn push(&mut self) -> LocalVariable {
-        let var = self.generator.fresh();
-        self.stack.push(var.clone());
-        var
-    }
-
-    pub fn push_with_hint(&mut self, type_hint: TypeHint) -> LocalVariable {
-        let var = self.generator.fresh().kind(type_hint);
-        self.stack.push(var.clone());
-        var
-    }
-
-    pub fn pop(&mut self) -> LocalVariable {
-        self.stack.pop().unwrap()
-    }
-
-    pub fn process_sequence(&mut self, op_codes: &[Pattern]) -> Function {
-        use OpCode::*;
-        use Pattern::*;
-
-        // let mut scope = Scope::new();
-        let mut function = Function::new(
-            op_codes
-                .iter()
-                .map(|x| format!("{x}").to_lowercase())
-                .join("_"),
-        );
-
-        function.vis("pub(crate)");
-
-        function.arg("ctx", codegen::Type::new("&mut VmCore<'_>"));
-        function.arg("payload", codegen::Type::new("usize"));
-        function.ret(codegen::Type::new("Result<()>"));
-
-        let mut lines = FunctionLines::default();
-
-        lines.line("use OpCode::*;");
-        lines.line("use steel_gen::Pattern::*;");
-
-        let mut max_local_offset_read = 0;
-        let mut max_ip_read = 0;
-
-        // TODO: Don't use the function line pushing directly, use a vec manually, and then insert an assertion for the instruction count
-        // to help reduce the bounds checks that we have to pay
-
-        // READLOCAL0,
-        // LOADINT2,
-        // MUL,
-        // MOVEREADLOCAL1,
-        // LOADINT1,
-        // SUB,
-        // READLOCAL2,
-        // LOADINT1,
-        // SUB,
-        // READLOCAL3,
-        // CALLGLOBAL
-
-        let last = op_codes.len();
-
-        for (index, op) in op_codes.iter().enumerate() {
-            match op {
-                Double(BEGINSCOPE, n) => {
-                    self.local_offset = Some(*n);
-                    lines.line("ctx.ip += 1;");
-                }
-
-                Single(PUSHCONST) => {
-                    let local = self.push();
-                    lines.line(format!(
-                        "let {local} = opcode_to_ssa_handler!(PUSHCONST)(ctx)?;"
-                    ));
-                }
-
-                // Single(LetVar) => {
-                //     let local = self.pop();
-                //     function.line(format!("ctx.stack.push({}.into());", local));
-                // }
-                Single(VOID) => {
-                    let local = self.push_with_hint(TypeHint::Void);
-                    lines.line(format!("let {local} = SteelVal::Void;"));
-                    lines.line("ctx.ip += 1;");
-                }
-                Single(LOADINT0) => {
-                    let local = self.push_with_hint(TypeHint::Int);
-                    // Load the immediate for 0
-                    lines.line(format!("let {} = {};", local, 0));
-                    lines.line("ctx.ip += 1;");
-                }
-                Single(LOADINT1) => {
-                    let local = self.push_with_hint(TypeHint::Int);
-                    // Load the immediate for 1
-                    lines.line(format!("let {} = {};", local, 1));
-                    lines.line("ctx.ip += 1;");
-
-                    max_ip_read += 1;
-                }
-                Single(LOADINT2) => {
-                    let local = self.push_with_hint(TypeHint::Int);
-                    // Load the immediate for 2
-                    lines.line(format!("let {} = {};", local, 2));
-                    lines.line("ctx.ip += 1;");
-
-                    max_ip_read += 1;
-                }
-                Double(CALLGLOBAL, n) => {
-                    // println!("Stack: {:?}", self.stack);
-
-                    let args = self
-                        .stack
-                        .split_off(self.stack.len() - n)
-                        .into_iter()
-                        .map(|x| x.to_string() + ".into(), ")
-                        .collect::<String>();
-
-                    if index == last - 1 {
-                        // For whatever is left, push on to the SteelThread stack
-                        for value in &self.stack {
-                            match value.type_hint {
-                                TypeHint::Int | TypeHint::Bool | TypeHint::Float => {
-                                    lines.line(format!("ctx.thread.stack.push({value}.into());"))
-                                }
-                                // It is already confirmed to be... something thats non primitive.
-                                _ => lines.line(format!("ctx.thread.stack.push({value});")),
-                            };
-                        }
-
-                        self.stack.clear();
-
-                        lines.line(format!(
-                            "opcode_to_ssa_handler!(CALLGLOBAL, Tail)(ctx, &mut [{args}])?;"
-                        ));
-                    } else {
-                        let local = self.push();
-
-                        lines.line(format!(
-                            "let {local} = opcode_to_ssa_handler!(CALLGLOBAL)(ctx, &mut [{args}])?;"
-                        ));
-                    }
-                }
-                Double(READLOCAL, n) => {
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > *n
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(*n);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(*n).unwrap();
-                        lines.line(format!("let {local} = {var}.clone();"));
-                    }
-                }
-                Single(READLOCAL0) => {
-                    // If we're dealing with a let var, then we can only specialize it _iff_ the
-                    // value we're reading exceeds the current function arguments.
-                    // For instance, if we have a function like this:
-                    // (lambda (x y z) (let ((foo 10)) (+ x y z foo))
-                    // Then foo should be something like READLOCAL(4)
-                    // In this case, we can safely snag it from the Rust stack
-                    // Otherwise, we need to read it from the steel stack.
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > 0
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(0);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(0).unwrap();
-
-                        if &local == var {
-                            lines.line(format!(
-                                "let {} = {}(ctx)?;",
-                                local,
-                                op_code_to_handler(*op)
-                            ));
-                        } else {
-                            lines.line(format!("let {local} = {var}.clone();"));
-                        }
-                    }
-                }
-                Single(READLOCAL1) => {
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > 1
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(1);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(1).unwrap();
-
-                        if &local == var {
-                            // let local = self.pop();
-
-                            let var = self.stack.get(0).unwrap();
-
-                            lines.line(format!("let {local} = {var}.clone();"));
-                            lines.line("ctx.ip += 1;")
-
-                            // lines.line(format!(
-                            //     "let {} = {}(ctx)?;",
-                            //     local,
-                            //     op_code_to_handler(*op)
-                            // ));
-                        } else {
-                            lines.line(format!("let {local} = {var}.clone();"));
-                        }
-
-                        // lines.line(format!("let {local} = {var}.clone();"));
-                    }
-                }
-                Single(READLOCAL2) => {
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > 2
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(2);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(2).unwrap();
-                        lines.line(format!("let {local} = {var}.clone();"));
-                    }
-                }
-                Single(READLOCAL3) => {
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > 3
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(3);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(3).unwrap();
-                        lines.line(format!("let {local} = {var}.clone();"));
-                    }
-                }
-                Double(MOVEREADLOCAL, n) => {
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > *n
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(*n);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(*n).unwrap();
-                        lines.line(format!("let {local} = {var};"));
-                    }
-                }
-                Single(MOVEREADLOCAL0) => {
-                    // If we're dealing with a let var, then we can only specialize it _iff_ the
-                    // value we're reading exceeds the current function arguments.
-                    // For instance, if we have a function like this:
-                    // (lambda (x y z) (let ((foo 10)) (+ x y z foo))
-                    // Then foo should be something like READLOCAL(4)
-                    // In this case, we can safely snag it from the Rust stack
-                    // Otherwise, we need to read it from the steel stack.
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > 0
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(0);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(0).unwrap();
-                        lines.line(format!("let {local} = {var};"));
-                    }
-                }
-                Single(MOVEREADLOCAL1) => {
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > 1
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(1);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(1).unwrap();
-                        lines.line(format!("let {local} = {var};"));
-                    }
-                }
-                Single(MOVEREADLOCAL2) => {
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > 2
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(2);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(2).unwrap();
-                        lines.line(format!("let {local} = {var};"));
-                    }
-                }
-                Single(MOVEREADLOCAL3) => {
-                    if self.local_offset.is_none()
-                        || self.local_offset.is_some() && self.local_offset.unwrap() > 3
-                    {
-                        let local = self.push();
-                        lines.line(format!(
-                            "let {} = {}(ctx)?;",
-                            local,
-                            op_code_to_handler(*op)
-                        ));
-
-                        max_local_offset_read = max_local_offset_read.max(3);
-                    } else {
-                        let local = self.push();
-                        let var = self.stack.get(3).unwrap();
-                        lines.line(format!("let {local} = {var};"));
-                    }
-                }
-                Single(PUSH | READCAPTURED | TAILCALL | CALLGLOBAL) => {
-                    let local = self.push();
-                    lines.line(format!(
-                        "let {} = {}(ctx)?;",
-                        local,
-                        op_code_to_handler(*op)
-                    ));
-                }
-                // Single(PUSH) => {
-                //     // Consider embedding some type hints on these for even more specialization if possible
-                //     let local = self.push();
-                //     function.line(format!("{} = {}(ctx)?;", local, op_code_to_handler(*op)));
-                // }
-                // Single(READCAPTURED) => {
-                //     let local = self.push();
-                //     function.line(format!("{} = {}(ctx)?;", local, op_code_to_handler(*op)));
-                // }
-                Single(IF) => {
-                    // (if <test> <then> <else>)
-                    let test_condition = self.pop();
-
-                    // If we're dealing with an int, just unbox it directly
-                    match test_condition.type_hint {
-                        TypeHint::Bool => {
-                            lines.line(format!(
-                                "if_to_ssa_handler!(IF, Bool)(ctx, {test_condition});"
-                            ));
-                        }
-                        _ => {
-                            lines.line(format!(
-                                "if_to_ssa_handler!(IF)(ctx, {test_condition}.into());"
-                            ));
-                        }
-                    }
-                }
-                Double(LTE | EQUAL, 2) => {
-                    let right = self.pop();
-                    let left = self.pop();
-
-                    lines.line("ctx.ip += 2;");
-
-                    max_ip_read += 2;
-
-                    match (left.type_hint, right.type_hint) {
-                        (a, b) if a == b => {
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            lines.line(format!("let {local} = {left} == {right};"));
-                            // TODO: This is going to need to be
-                            // lines.line("ctx.ip += 1;");
-                            max_ip_read += 1;
-                        }
-                        (TypeHint::Int, TypeHint::Int) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Int, Int)");
-
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Int, TypeHint::Float) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Int, Float)");
-
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Int, TypeHint::None) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Int, None)");
-
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Float, TypeHint::Int) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Float, Int)");
-
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Float, TypeHint::Float) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Float, Float)");
-
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Float, TypeHint::None) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Float, None)");
-
-                            // Probably needs to be promoted to a float in this case
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::None, TypeHint::Int) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, None, Int)");
-
-                            // Probably needs to be promoted to a float in this case
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::None, TypeHint::Float) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, None, Int)");
-
-                            // Probably needs to be promoted to a float in this case
-                            let local = self.push_with_hint(TypeHint::Bool);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (_, _) => todo!(),
-                    }
-                }
-
-                Double(ADDIMMEDIATE, imm) => {
-                    let right = self.pop();
-
-                    lines.line("ctx.ip += 2;");
-
-                    match right.type_hint {
-                        TypeHint::Int => todo!(),
-                        TypeHint::Bool => todo!(),
-                        TypeHint::Float => todo!(),
-                        TypeHint::Void => todo!(),
-                        TypeHint::None => todo!(),
-                    }
-                }
-
-                // TODO: Need to handle the actual op code as well
-                // READLOCAL0, LOADINT2, LTE, IF
-                Double(ADD | MUL | SUB | DIV, 2) => {
-                    let right = self.pop();
-                    let left = self.pop();
-
-                    lines.line("ctx.ip += 2;");
-
-                    max_ip_read += 2;
-
-                    match (left.type_hint, right.type_hint) {
-                        (TypeHint::Int, TypeHint::Int) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Int, Int)");
-
-                            let local = self.push_with_hint(TypeHint::Int);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Int, TypeHint::Float) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Int, Float)");
-
-                            let local = self.push_with_hint(TypeHint::Float);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Int, TypeHint::None) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Int, None)");
-
-                            let local = self.push_with_hint(TypeHint::None);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Float, TypeHint::Int) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Float, Int)");
-
-                            let local = self.push_with_hint(TypeHint::Float);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Float, TypeHint::Float) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Float, Float)");
-
-                            let local = self.push_with_hint(TypeHint::Float);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::Float, TypeHint::None) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, Float, None)");
-
-                            // Probably needs to be promoted to a float in this case
-                            let local = self.push_with_hint(TypeHint::Float);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::None, TypeHint::Int) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, None, Int)");
-
-                            // Probably needs to be promoted to a float in this case
-                            let local = self.push_with_hint(TypeHint::None);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (TypeHint::None, TypeHint::Float) => {
-                            // Delegate to the binary handler to return an int
-                            let call = format!("binop_opcode_to_ssa_handler!({op}, None, Float)");
-
-                            // Probably needs to be promoted to a float in this case
-                            let local = self.push_with_hint(TypeHint::Float);
-
-                            push_binop(&mut lines, local, call, left, right);
-                        }
-                        (_, _) => todo!(),
-                    }
-                }
-                _ => {
-                    todo!()
-                }
-            }
-        }
-
-        // For whatever is left, push on to the SteelThread stack
-        for value in &self.stack {
-            match value.type_hint {
-                TypeHint::Int | TypeHint::Bool | TypeHint::Float => {
-                    lines.line(format!("ctx.thread.stack.push({value}.into());"))
-                }
-                // It is already confirmed to be... something thats non primitive.
-                _ => lines.line(format!("ctx.thread.stack.push({value});")),
-            };
-        }
-
-        lines.line("Ok(())");
-        // scope.push_fn(function);
-
-        // Emit the assert for bounds checking purposes
-        if max_local_offset_read > 0 {
-            // function.line(format!(
-            //     "assert!(ctx.sp + {max_local_offset_read} < ctx.thread.stack.len());"
-            // ));
-        }
-
-        if max_ip_read > 0 {
-            function.line(format!(
-                "assert!(ctx.ip + {max_ip_read} < ctx.instructions.len());"
-            ));
-        }
-
-        for line in lines.lines {
-            function.line(line);
-        }
-
-        // scope.to_string()
-
-        function
-    }
-}
-
-fn push_binop(
-    function: &mut FunctionLines,
-    local: LocalVariable,
-    call: String,
-    left: LocalVariable,
-    right: LocalVariable,
-) {
-    function.line(format!(
-        "let {} = {}",
-        local,
-        Call::new(
-            call.into(),
-            // op_code_to_handler(*op).into(),
-            vec![
-                "ctx".into(),
-                left.to_string().into(),
-                right.to_string().into()
-            ],
-        ),
-    ));
-}
-
-struct Call<'a> {
-    name: Cow<'a, str>,
-    args: Vec<Cow<'a, str>>,
-}
-
-impl<'a> Call<'a> {
-    pub fn new(name: Cow<'a, str>, args: Vec<Cow<'a, str>>) -> Self {
-        Self { name, args }
-    }
-}
-
-impl<'a> std::fmt::Display for Call<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.name)?;
-        write!(f, "(")?;
-        for arg in &self.args {
-            write!(f, "{arg}, ")?;
-        }
-        write!(f, ")?;")
-    }
-}
-
-// fn call_function(name: &str, args: &[&str]) -> String {
-//     // format!("{}({})")
-
-//     let mut builder = name.to_string() + "(";
-
-// }
-
-// READCAPTURED, TAILCALL
-
-// TODO:
-
-// Code Gen the match statement on the instruction that we will use to do a sliding window opt
-// pub fn identify_pattern(instructions: &mut [Instruction], pattern: &[(OpCode, usize)]) {
-//     todo!()
-// }
-
-impl Pattern {
-    pub fn from_opcodes(op_codes: &[(OpCode, usize)]) -> Vec<Pattern> {
-        let mut buffer: Vec<Pattern> = Vec::new();
-
-        Self::from_opcodes_with_buffer(op_codes, &mut buffer);
-
-        buffer
-    }
-
-    pub fn from_opcodes_with_buffer(op_codes: &[(OpCode, usize)], patterns: &mut Vec<Pattern>) {
-        use OpCode::*;
-
-        patterns.clear();
-
-        let iter = op_codes.iter();
-
-        for op in iter {
-            match op {
-                (
-                    LOADINT0 | LOADINT1 | LOADINT2 | READLOCAL0 | READLOCAL1 | READLOCAL2
-                    | READLOCAL3 | MOVEREADLOCAL0 | MOVEREADLOCAL1 | MOVEREADLOCAL2 | PUSHCONST
-                    | MOVEREADLOCAL3 | IF | PUSH | READCAPTURED | TAILCALL,
-                    _,
-                ) => patterns.push(Pattern::Single(op.0)),
-                (READLOCAL | MOVEREADLOCAL | ADDIMMEDIATE, n) => {
-                    patterns.push(Pattern::Double(op.0, *n))
-                }
-                (ADD | SUB | MUL | DIV | EQUAL | LTE, 2) => patterns.push(Pattern::Double(op.0, 2)),
-                (BEGINSCOPE, n) => patterns.push(Pattern::Double(op.0, *n)),
-                // TODO: Need to introduce a hint to say that these are builtins - these _must_ be builtins
-                // or else this hint will fail! If it isn't a primitive function, we're violating the conditions
-                // for these op codes, since our basic block will switch.
-                //
-                // Even better - this can be speculative! We attempt to call a builtin, but if its not,
-                // we just fall through to the normal calling behavior!
-                (CALLGLOBAL, n) => {
-                    // let arity = iter.next().unwrap();
-                    patterns.push(Pattern::Double(CALLGLOBAL, *n))
-                }
-                _ => {
-                    continue;
-                }
-            }
-        }
-    }
-}
-
-pub trait IteratorExtensions: Iterator {
-    fn join(&mut self, sep: &str) -> String
-    where
-        Self::Item: std::fmt::Display,
-    {
-        match self.next() {
-            None => String::new(),
-            Some(first_elt) => {
-                // estimate lower bound of capacity needed
-                let (lower, _) = self.size_hint();
-                let mut result = String::with_capacity(sep.len() * lower);
-                write!(&mut result, "{}", first_elt).unwrap();
-                self.for_each(|elt| {
-                    result.push_str(sep);
-                    write!(&mut result, "{}", elt).unwrap();
-                });
-                result
-            }
-        }
-    }
-}
-
-impl<T> IteratorExtensions for T where T: Iterator {}
-
-// struct SuperInstructionMap {
-//     map: std::collections::HashMap<Vec<Pattern>, for<'r> fn (&'r mut VmCore<'_>, usize) -> Result<()>>
-// }
-
-pub fn generate_opcode_map() -> String {
-    let patterns = opcode::PATTERNS;
-
-    let mut global_scope = Scope::new();
-
-    // let mut generate = codegen::Function::new("generate_dynamic_op_codes");
-    // generate.ret(codegen::Type::new("SuperInstructionMap"));
-    // generate.vis("pub(crate)");
-
-    // generate.line("use OpCode::*;");
-    // generate.line("use steel_gen::Pattern::*;");
-
-    // generate.line("let mut map = SuperInstructionMap::new();");
-
-    let mut converter = StackToSSAConverter::new();
-
-    let mut pattern_exists_function = codegen::Function::new("pattern_exists");
-    pattern_exists_function.ret(codegen::Type::new("bool"));
-    pattern_exists_function.vis("pub(crate)");
-
-    pattern_exists_function.arg("pattern", codegen::Type::new("&[steel_gen::Pattern]"));
-
-    pattern_exists_function.line("use OpCode::*;");
-    pattern_exists_function.line("use steel_gen::Pattern::*;");
-
-    pattern_exists_function.line("match pattern {");
-
-    let mut vm_match_loop_function = codegen::Function::new("vm_match_dynamic_super_instruction");
-
-    vm_match_loop_function.vis("pub(crate)");
-
-    vm_match_loop_function.arg("ctx", codegen::Type::new("&mut VmCore<'_>"));
-    vm_match_loop_function.ret(codegen::Type::new("Result<()>"));
-    vm_match_loop_function.arg("instr", codegen::Type::new("DenseInstruction"));
-
-    vm_match_loop_function.line("match instr {");
-
-    for pattern in patterns {
-        let original_pattern = pattern;
-        let pattern = Pattern::from_opcodes(&pattern);
-
-        if pattern.is_empty() {
-            dbg!("Pattern produced empty result: {:?}", original_pattern);
-            continue;
-        }
-
-        let generated_name = pattern
-            .iter()
-            .map(|x| format!("{x}").to_lowercase())
-            .join("_");
-        let generated_function = converter.process_sequence(&pattern);
-
-        // let mut scope = Scope::new();
-
-        global_scope.push_fn(generated_function);
-
-        // generate.line(scope.to_string());
-        // generate.line(format!("map.insert(vec!{pattern:?}, {generated_name});"));
-
-        converter.reset();
-
-        pattern_exists_function.line(format!("&{pattern:?} => true,"));
-
-        if let Some(op_code) = opcode::sequence_to_opcode(original_pattern) {
-            dbg!(&original_pattern);
-
-            vm_match_loop_function.line(format!(
-                "DenseInstruction {{ op_code: OpCode::{:?}, payload_size, .. }} => dynamic::{}(ctx, payload_size as usize),",
-                op_code, generated_name
-            ));
-        };
-    }
-
-    pattern_exists_function.line("_ => false,");
-    pattern_exists_function.line("}");
-
-    vm_match_loop_function.line("_ => {");
-    vm_match_loop_function
-        .line("crate::core::instructions::pretty_print_dense_instructions(&ctx.instructions);");
-    vm_match_loop_function
-        .line(r#"panic!("Unhandled opcode: {:?} @ {}", ctx.instructions[ctx.ip], ctx.ip);"#);
-
-    vm_match_loop_function.line("}");
-    vm_match_loop_function.line("}");
-
-    global_scope.push_fn(pattern_exists_function);
-    global_scope.push_fn(vm_match_loop_function);
-
-    // Return the map now
-    // generate.line("map");
-
-    // This gives me the interface to the super instruction stuff
-    let top_level_definition = r#"
-
-pub(crate) struct SuperInstructionMap {
-    map: std::collections::HashMap<Vec<steel_gen::Pattern>, for<'r> fn (&'r mut VmCore<'_>, usize) -> Result<()>>
-}
-
-impl SuperInstructionMap {
-    pub(crate) fn new() -> Self {
-        Self { map: std::collections::HashMap::new() }
-    }
-
-    pub(crate) fn insert(&mut self, pattern: Vec<steel_gen::Pattern>, func: for<'r> fn (&'r mut VmCore<'_>, usize) -> Result<()>) {
-        self.map.insert(pattern, func);
-    }
-
-    pub(crate) fn get(&self, op_codes: &[(OpCode, usize)]) -> Option<for<'r> fn (&'r mut VmCore<'_>, usize) -> Result<()>> {
-        let pattern = steel_gen::Pattern::from_opcodes(&op_codes);
-        self.map.get(&pattern).copied()
-    }
-}
-
-pub(crate) static DYNAMIC_SUPER_PATTERNS: once_cell::sync::Lazy<SuperInstructionMap> = once_cell::sync::Lazy::new(|| generate_dynamic_op_codes());
-
-pub(crate) fn generate_dynamic_op_codes() -> SuperInstructionMap {
-    SuperInstructionMap::new()
-}
-    
-    "#;
-
-    // global_scope.push_fn(generate);
-
-    format!("{}\n{}", top_level_definition, global_scope.to_string())
-}
-
-#[test]
-fn test() {
-    // let op_codes = vec![
-    //     Pattern::Double(OpCode::BEGINSCOPE, 0),
-    //     Pattern::Single(OpCode::LOADINT0),
-    //     // Pattern::Single(OpCode::BEGINSCOPE),
-    //     Pattern::Single(OpCode::LOADINT1),
-    //     Pattern::Single(OpCode::LOADINT1),
-    //     Pattern::Single(OpCode::LOADINT1),
-    //     Pattern::Single(OpCode::LOADINT1),
-    //     Pattern::Single(OpCode::LOADINT1),
-    //     Pattern::Single(OpCode::READLOCAL0),
-    //     Pattern::Single(OpCode::READLOCAL1),
-    //     Pattern::Pair(OpCode::CALLGLOBAL, OpCode::Arity, 6),
-    //     // Pattern::Single(OpCode::BEGINSCOPE), // Pattern::Double(OpCode::ADD, 2),
-    //     Pattern::Single(OpCode::LOADINT2),
-    //     Pattern::Double(OpCode::EQUAL, 2),
-    //     Pattern::Single(OpCode::IF),
-    // ];
-
-    use OpCode::*;
-
-    let op_codes = vec![
-        (MOVEREADLOCAL0, 0),
-        (LOADINT2, 225),
-        (SUB, 2),
-        (CALLGLOBAL, 1),
-    ];
-
-    let op_codes = Pattern::from_opcodes(&op_codes);
-
-    println!("{op_codes:#?}");
-
-    let mut stack_to_ssa = StackToSSAConverter::new();
-
-    let result = stack_to_ssa.process_sequence(&op_codes);
-
-    let mut scope = Scope::new();
-
-    scope.push_fn(result);
-
-    println!("{}", scope.to_string());
-
-    // println!("{}", ctx_signature().to_string());
-}
-
-#[test]
-fn test_generation() {
-    use OpCode::*;
-
-    // TODO: Come up with better way for this to make it in
-    // let patterns: &'static [&'static [(OpCode, usize)]] = &[&[
-    //     (MOVEREADLOCAL0, 0),
-    //     (LOADINT2, 225),
-    //     (SUB, 2),
-    //     (CALLGLOBAL, 1),
-    // ]];
-
-    println!("{}", generate_opcode_map());
-}
diff --git a/crates/steel-gen/src/opcode.rs b/crates/steel-gen/src/opcode.rs
deleted file mode 100644
index 3062aa053..000000000
--- a/crates/steel-gen/src/opcode.rs
+++ /dev/null
@@ -1,320 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-macro_rules! declare_opcodes {
-
-    ( { $($variant:tt);* } { $( [ $super:tt => $(($k:path, $v:expr),)* ] );* } ) => {
-        #[repr(u8)]
-        #[derive(Copy, Clone, Debug, Hash, PartialEq, Serialize, Deserialize, Eq, PartialOrd, Ord)]
-        pub enum OpCode {
-            $($variant),*
-
-            ,
-
-            $($super),*
-        }
-
-        // $( const $super: &'static [(TestOpCode, usize)] = &[ $($v),* ]; )*
-
-        pub const fn op_code_to_super_instruction_pattern(op_code: OpCode) -> Option<&'static [(OpCode, usize)]> {
-            match op_code {
-                $(OpCode::$super => Some( &[ $(($k, $v)),* ]) ),* ,
-                _ => None
-            }
-        }
-
-        pub const fn sequence_to_opcode(pattern: &[(OpCode, usize)]) -> Option<OpCode> {
-            match pattern {
-                $(&[ $(($k, _)),* ] => Some(OpCode::$super) ),* ,
-                _ => None
-            }
-        }
-
-        pub static PATTERNS: &'static [&'static [(OpCode, usize)]] = &[
-                $( &[ $(($k, $v)),* ] ),* ,
-        ];
-    }
-
-}
-
-declare_opcodes! {
-    {
-        VOID;
-        PUSH;
-        IF;
-        JMP;
-        FUNC;
-        SCLOSURE;
-        ECLOSURE;
-        BIND;
-        SDEF;
-        EDEF;
-        POPPURE;
-        POPN;
-        POPSINGLE;
-        PASS;
-        PUSHCONST;
-        NDEFS;
-        PANIC;
-        TAILCALL;
-        SET;
-        READLOCAL;
-        READLOCAL0;
-        READLOCAL1;
-        READLOCAL2;
-        READLOCAL3;
-        SETLOCAL;
-        COPYCAPTURESTACK;
-        COPYCAPTURECLOSURE;
-        COPYHEAPCAPTURECLOSURE;
-        FIRSTCOPYHEAPCAPTURECLOSURE;
-        TCOJMP;
-        CALLGLOBAL;
-        CALLGLOBALTAIL;
-        LOADINT0; // Load const 0
-        LOADINT1;
-        LOADINT2;
-        CGLOCALCONST;
-        MOVEREADLOCAL;
-        MOVEREADLOCAL0;
-        MOVEREADLOCAL1;
-        MOVEREADLOCAL2;
-        MOVEREADLOCAL3;
-        READCAPTURED;
-        BEGINSCOPE;
-        LETENDSCOPE;
-        PUREFUNC;
-        ADD;
-        SUB;
-        MUL;
-        DIV;
-        EQUAL;
-        LTE;
-        CONS; // Cons should be... probably specialized
-        LIST;
-        CAR;
-        // CDR;
-        NEWBOX;
-        SETBOX;
-        UNBOX;
-        NEWSCLOSURE;
-        ADDREGISTER;
-        SUBREGISTER;
-        LTEREGISTER;
-        SUBREGISTER1;
-        ALLOC;
-        READALLOC;
-        SETALLOC;
-        DynSuperInstruction;
-        Arity;
-        LetVar;
-        ADDIMMEDIATE;
-        SUBIMMEDIATE;
-        LTEIMMEDIATE;
-        BINOPADD;
-        LTEIMMEDIATEIF
-    }
-
-    // Super instructions
-    {
-
-
-        [
-            CaseLambdaDispatch =>
-                                  (OpCode::BEGINSCOPE, 0),
-                                  (OpCode::READLOCAL0, 0),
-                                  (OpCode::CALLGLOBAL, 1),
-                                  (OpCode::Arity, 92),
-                                  (OpCode::READLOCAL1, 1),
-                                  (OpCode::LOADINT0, 0),
-                                  (OpCode::CALLGLOBAL, 2),
-                                  (OpCode::Arity, 181),
-                                  (OpCode::IF, 22),
-        ];
-
-        [
-            ReadLocal1PushConstEqualIf => (OpCode::READLOCAL1, 1),
-                                          (OpCode::PUSHCONST, 335),
-                                          (OpCode::EQUAL, 2),
-                                          (OpCode::PASS, 0),
-                                          (OpCode::IF, 8),
-        ]
-
-        // 16    READLOCAL0         : 0      ##args
-        // 17    CALLGLOBAL         : 1      length
-        // 18    Arity              : 82     length
-        // 19    READLOCAL1         : 1      l
-        // 20    LOADINT0           : 274    0
-        // 21    CALLGLOBAL         : 2      =
-        // 22    Arity              : 180    =
-        // 23    IF                 : 22
-
-        // [
-        //     CaseLambdaDispatch => (OpCode::READLOCAL0, 0),
-        //                           (OpCode::CALLGLOBAL, 1),
-        //                           (OpCode::Arity, 92),
-        //                           (OpCode::READLOCAL1, 1),
-        //                           (OpCode::LOADINT0, 0),
-        //                           (OpCode::CALLGLOBAL, 2),
-        //                           (OpCode::Arity, 181),
-        //                           (OpCode::IF, 22),
-        // ]
-
-        // [ MOVERLLIS2CG => (OpCode::MOVEREADLOCAL, 0), (OpCode::LOADINT2, 225), (OpCode::SUB, 2), (OpCode::CALLGLOBAL, 1), ];
-
-        // [ MOVERLLIS2CGFOO => (OpCode::MOVEREADLOCAL, 1), (OpCode::LOADINT2, 225), (OpCode::SUB, 2), (OpCode::CALLGLOBAL, 1), ]
-
-
-        //         (MOVEREADLOCAL0, 0),
-        //         (LOADINT2, 225),
-        //         (SUB, 2),
-        //         (CALLGLOBAL, 1),
-
-    }
-}
-
-// // expansion
-// enum EntryPoints {
-//     SomeLibCallback(u64),
-
-//     A(),
-//     B(),
-// }
-
-impl OpCode {
-    /// Is this op code created as part of the aggregation of multiple op codes?
-    pub fn is_super_instruction(&self) -> bool {
-        // TODO: Check where super instructions start!
-
-        return *self as u32 > Self::LTEIMMEDIATEIF as u32;
-    }
-
-    /// Statically create the mapping we need for super instruction. Also, as part of the op code map generating,
-    /// the macro used for calling super instructions should also be generated.
-    pub fn super_instructions(&self) -> &'static [&'static [(OpCode, usize)]] {
-        todo!()
-    }
-
-    pub fn is_ephemeral_opcode(&self) -> bool {
-        use OpCode::*;
-
-        match self {
-            ECLOSURE
-            | PASS
-            | Arity
-            | NDEFS
-            | COPYCAPTURECLOSURE
-            | COPYCAPTURESTACK
-            | COPYHEAPCAPTURECLOSURE => true,
-            _ => false,
-        }
-    }
-
-    // TODO better error handling here
-    pub fn from(s: &str) -> Self {
-        use OpCode::*;
-        match s {
-            "VOID" => VOID,
-            "PUSH" => PUSH,
-            "IF" => IF,
-            "JMP" => JMP,
-            "FUNC" => FUNC,
-            "SCLOSURE" => SCLOSURE,
-            "ECLOSURE" => ECLOSURE,
-            // "STRUCT" => STRUCT,
-            "BIND" => BIND,
-            "SDEF" => SDEF,
-            "EDEF" => EDEF,
-            "PASS" => PASS,
-            "PUSHCONST" => PUSHCONST,
-            "NDEFS" => NDEFS,
-            "PANIC" => PANIC,
-            "TAILCALL" => TAILCALL,
-            "SET" => SET,
-            "READLOCAL" => READLOCAL,
-            "SETLOCAL" => SETLOCAL,
-            "TCOJMP" => TCOJMP,
-            "CALLGLOBAL" => CALLGLOBAL,
-            "CALLGLOBALTAIL" => CALLGLOBALTAIL,
-            "LOADINT0" => LOADINT0, // Load const 0
-            "LOADINT1" => LOADINT1,
-            "LOADINT2" => LOADINT2,
-            "CGLOCALCONST" => CGLOCALCONST,
-            "MOVEREADLOCAL" => MOVEREADLOCAL,
-            "BEGINSCOPE" => BEGINSCOPE,
-            "ADD" => ADD,
-            "SUB" => SUB,
-            "MUL" => MUL,
-            "DIV" => DIV,
-            "EQUAL" => EQUAL,
-            "LTE" => LTE,
-            "LETENDSCOPE" => LETENDSCOPE,
-            "PUREFUNC" => PUREFUNC,
-            "POP_PURE" => POPPURE,
-            "READCAPTURED" => READCAPTURED,
-            "COPYCAPTURESTACK" => COPYCAPTURESTACK,
-            "COPYCAPTURECLOSURE" => COPYCAPTURECLOSURE,
-            "COPYHEAPCAPTURECLOSURE" => COPYHEAPCAPTURECLOSURE,
-            "NEWSCLOSURE" => NEWSCLOSURE,
-            "ADDREGISTER" => ADDREGISTER,
-            "SUBREGISTER" => SUBREGISTER,
-            "LTEREGISTER" => LTEREGISTER,
-            "SUBREGISTER1" => SUBREGISTER1,
-            "ALLOC" => ALLOC,
-            "READALLOC" => READALLOC,
-            "SETALLOC" => SETALLOC,
-            _ => panic!("Unable to map string to opcode"),
-        }
-    }
-
-    pub fn width(&self) -> usize {
-        match self {
-            OpCode::VOID => todo!(),
-            OpCode::PUSH => todo!(),
-            OpCode::IF => todo!(),
-            OpCode::JMP => todo!(),
-            OpCode::FUNC => todo!(),
-            OpCode::SCLOSURE => todo!(),
-            OpCode::ECLOSURE => todo!(),
-            // OpCode::STRUCT => todo!(),
-            OpCode::BIND => todo!(),
-            OpCode::SDEF => todo!(),
-            OpCode::EDEF => todo!(),
-            OpCode::POPPURE => todo!(),
-            OpCode::PASS => todo!(),
-            OpCode::PUSHCONST => todo!(),
-            OpCode::NDEFS => todo!(),
-            OpCode::PANIC => todo!(),
-            OpCode::TAILCALL => todo!(),
-            OpCode::SET => todo!(),
-            OpCode::READLOCAL => todo!(),
-            OpCode::SETLOCAL => todo!(),
-            OpCode::COPYCAPTURESTACK => todo!(),
-            OpCode::COPYCAPTURECLOSURE => todo!(),
-            OpCode::TCOJMP => todo!(),
-            OpCode::CALLGLOBAL => 2,
-            OpCode::CALLGLOBALTAIL => todo!(),
-            OpCode::LOADINT0 => todo!(),
-            OpCode::LOADINT1 => todo!(),
-            OpCode::LOADINT2 => todo!(),
-            OpCode::CGLOCALCONST => todo!(),
-            OpCode::MOVEREADLOCAL => todo!(),
-            OpCode::READCAPTURED => todo!(),
-            OpCode::BEGINSCOPE => todo!(),
-            OpCode::LETENDSCOPE => todo!(),
-            OpCode::PUREFUNC => todo!(),
-            OpCode::ADD => 2,
-            OpCode::SUB => todo!(),
-            OpCode::MUL => todo!(),
-            OpCode::DIV => todo!(),
-            OpCode::EQUAL => todo!(),
-            OpCode::LTE => todo!(),
-            OpCode::NEWSCLOSURE => todo!(),
-            OpCode::ADDREGISTER => 2,
-            OpCode::SUBREGISTER => 2,
-            OpCode::LTEREGISTER => 2,
-            OpCode::SUBREGISTER1 => todo!(),
-            OpCode::ALLOC => todo!(),
-            _ => todo!(),
-        }
-    }
-}
diff --git a/crates/steel-gen/src/permutations.rs b/crates/steel-gen/src/permutations.rs
deleted file mode 100644
index f04474162..000000000
--- a/crates/steel-gen/src/permutations.rs
+++ /dev/null
@@ -1,283 +0,0 @@
-use codegen::Impl;
-
-// Awful, ugly back to generate all of the inputs that I need across different params
-
-// It might be worth flattening this vector, but that is quite a bit of contiguous memory to allocate.
-// lets just deal with the fact that this might be broken up and take the cache hits. Alternatively, it would probably
-// make a lot of sense to do this with an iterator.
-
-pub const SUPPORTED_FUNCTION_ARITY: u32 = 5;
-
-fn generate_permutations<T: Copy>(input: &[T]) -> Vec<Vec<Vec<T>>> {
-    let mut buffers = Vec::with_capacity(SUPPORTED_FUNCTION_ARITY as usize);
-
-    for i in 0..SUPPORTED_FUNCTION_ARITY {
-        buffers.push(Vec::with_capacity(input.len().pow(i)));
-    }
-
-    for a in input {
-        buffers[0].push(vec![*a]);
-
-        for b in input {
-            buffers[1].push(vec![*a, *b]);
-
-            for c in input {
-                buffers[2].push(vec![*a, *b, *c]);
-
-                for d in input {
-                    buffers[3].push(vec![*a, *b, *c, *d]);
-
-                    for e in input {
-                        buffers[4].push(vec![*a, *b, *c, *d, *e]);
-
-                        //     // for f in input {
-                        //     //     buffers[5].push(vec![*a, *b, *c, *d, *e, *f]);
-
-                        //     //     // TODO: If this can be done, we want to get up to like 8 parameters if possible?
-
-                        //     //     // for g in input {
-                        //     //     //     buffers[6].push(vec![*a, *b, *c, *d, *e, *f, *g]);
-
-                        //     //     //     for h in input {
-                        //     //     //         buffers[7].push(vec![*a, *b, *c, *d, *e, *f, *g, *h])
-                        //     //     //     }
-                        //     //     // }
-                        // }
-                    }
-                }
-            }
-        }
-    }
-
-    buffers
-}
-
-#[derive(Copy, Clone)]
-enum ValueKind {
-    Value,
-    Reference,
-    MutReference,
-}
-
-impl ValueKind {
-    fn format_array_to_tuple(values: &[ValueKind]) -> String {
-        let mut output = "(".to_string();
-
-        for i in 0..values.len() {
-            output.push('T');
-            output.push_str(&i.to_string());
-            output.push(',');
-        }
-
-        output.push(')');
-
-        output
-    }
-
-    // Fn(&SELF, AREA, &CTX)
-    fn format_array_to_function_args(values: &[ValueKind]) -> String {
-        let mut output = "(".to_string();
-
-        for (i, value) in values.iter().enumerate() {
-            if let Some(reference_modifier) = value.as_reference_type_repr() {
-                output.push_str(reference_modifier);
-                output.push(' ');
-            }
-            output.push('T');
-            output.push_str(&i.to_string());
-            output.push(',');
-        }
-
-        output.push(')');
-
-        output
-    }
-
-    // Convert this to a reference type for the use of code gen
-    fn as_reference_type_repr(&self) -> Option<&'static str> {
-        match self {
-            Self::Value => None,
-            Self::Reference => Some("&"),
-            Self::MutReference => Some("&mut"),
-        }
-    }
-
-    // In theory, we might have more, but I need to iron this out from the
-    // actual implementation side of things.
-    fn as_from_trait_name(&self) -> &'static str {
-        match self {
-            Self::Value => "FromSteelVal",
-            Self::Reference => "AsRefSteelVal",
-            Self::MutReference => "AsRefMutSteelVal",
-        }
-    }
-}
-
-const FN: &str = "FN";
-const RET: &str = "RET";
-
-fn code_gen_permutation(values: &[ValueKind], id: usize, row: usize) -> String {
-    // RegisterFn<FN, MarkerWrapper8<(SELF, AREA, CTX)>, RET>
-    let mut trait_to_impl_type = codegen::Type::new("RegisterFn");
-    trait_to_impl_type.generic(FN);
-    let mut wrapper = codegen::Type::new(format!("Marker{row}{id}"));
-    wrapper.generic(ValueKind::format_array_to_tuple(values));
-    trait_to_impl_type.generic(wrapper);
-    trait_to_impl_type.generic(RET);
-
-    // Target type to impl the trait for
-    // let mut impl_trait = Impl::new("BuiltInModule");
-
-    let mut impl_trait = Impl::new("FakeEngine");
-
-    // We're implementing the above RegisterFn trait
-    impl_trait.impl_trait(trait_to_impl_type);
-
-    let ret_type = codegen::Type::new(RET);
-
-    impl_trait.generic(RET);
-    impl_trait.bound(RET, "IntoSteelVal"); // TODO: Figure out if these bounds are respected or not
-    for (i, value) in values.iter().enumerate() {
-        let type_name = format!("T{i}");
-
-        impl_trait.generic(&type_name);
-        impl_trait.bound(&type_name, value.as_from_trait_name()); // TODO: This is where we're gonna need to match to pick the right kind
-    }
-
-    impl_trait.generic(FN);
-    // impl_trait.bound()
-
-    let function_string = "Fn".to_string()
-        + &ValueKind::format_array_to_function_args(values)
-        + " -> "
-        + "RET + SendSyncStatic";
-
-    impl_trait.bound(FN, &function_string);
-
-    let function_def = impl_trait.new_fn("register_fn");
-
-    // Function signature
-    function_def
-        .arg_mut_self()
-        .arg("name", "&'static str")
-        .arg("func", FN)
-        .ret("&mut Self");
-
-    function_def.line("let f = move |args: &[SteelVal]| -> Result<SteelVal> {");
-    function_def.line(format!("if args.len() != {} {{", values.len()));
-    function_def.line(format!(
-        "stop!(ArityMismatch => \"{{}} expected {} arguments, got {{}}\", name, args.len());",
-        values.len(),
-    ));
-    function_def.line("}");
-
-    for (i, value) in values.iter().enumerate() {
-        match value {
-            ValueKind::Value => {
-                function_def.line(format!(
-                    "let mut v{i} = <T{i}>::from_steelval(&args[{i}])?;"
-                ));
-            }
-            ValueKind::Reference => {
-                function_def.line(format!(
-                    "let mut nursery{i} = <T{i} as AsRefSteelVal>::Nursery::default();"
-                ));
-                function_def.line(format!(
-                    "let mut v{i} = <T{i}>::as_ref(&args[{i}], &mut nursery{i})?;"
-                ));
-            }
-            ValueKind::MutReference => {
-                function_def.line(format!("let mut v{i} = <T{i}>::as_mut_ref(&args[{i}])?;"));
-            }
-        }
-    }
-
-    {
-        function_def.line("let res = func(");
-
-        for (i, value) in values.iter().enumerate() {
-            // function_def.line
-
-            let mut var = String::new();
-            if let Some(modifier) = value.as_reference_type_repr() {
-                var.push_str(modifier);
-            }
-
-            var.push_str(&format!(" v{i},"));
-
-            function_def.line(var);
-        }
-
-        function_def.line(");");
-
-        function_def.line("res.into_steelval()");
-    }
-
-    function_def.line("};");
-
-    function_def.line(format!(
-        r#"
-
-        self.register_value(
-            name,
-            SteelVal::BoxedFunction(Rc::new(BoxedDynFunction::new(
-                Arc::new(f), 
-                Some(name), 
-                Some({})
-            ))),
-        )
-            
-        "#,
-        values.len()
-    ));
-
-    let mut scope = codegen::Scope::new();
-
-    let mut marker = scope.new_struct(&format!("Marker{row}{id}"));
-
-    marker.generic("ARGS");
-    marker.tuple_field("PhantomData<ARGS>");
-
-    scope.push_impl(impl_trait);
-
-    scope.to_string()
-}
-
-pub fn code_gen() -> String {
-    let values = &[
-        ValueKind::Value,
-        ValueKind::Reference,
-        ValueKind::MutReference,
-    ];
-
-    let permutations = generate_permutations(values);
-
-    let mut out = Vec::new();
-
-    for (r, row) in permutations.into_iter().enumerate() {
-        for (index, column) in row.into_iter().enumerate() {
-            out.push(code_gen_permutation(&column, index, r));
-        }
-    }
-
-    out.join("\n")
-}
-
-#[test]
-fn simple_code_gen() {
-    let values = &[
-        ValueKind::Value,
-        ValueKind::Reference,
-        ValueKind::MutReference,
-    ];
-
-    // println!("{}", code_gen_permutation(values));
-
-    let permutations = generate_permutations(values);
-
-    for (r, row) in permutations.into_iter().enumerate() {
-        for (index, column) in row.into_iter().enumerate() {
-            println!("{}", code_gen_permutation(&column, index, r));
-        }
-    }
-}
diff --git a/crates/steel-language-server/Cargo.toml b/crates/steel-language-server/Cargo.toml
deleted file mode 100644
index 565a03588..000000000
--- a/crates/steel-language-server/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "steel-language-server"
-edition = "2021"
-version.workspace = true
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-env_logger = "0.10.0"
-ropey = "1.5.0"
-serde_json = "1.0.92"
-tokio = { version = "1.29.1", features = ["full"] }
-tower-lsp = { version = "0.20.0", features = ["proposed"] }
-serde = { version = "1.0.152", features = ["derive"] }
-dashmap = "5.1.0"
-log = "0.4.17"
-steel-core = { path = "../steel-core", version = "0.5.0" }
-once_cell = "1.18.0"
diff --git a/crates/steel-language-server/README.md b/crates/steel-language-server/README.md
deleted file mode 100644
index 1773c2844..000000000
--- a/crates/steel-language-server/README.md
+++ /dev/null
@@ -1,67 +0,0 @@
-# Steel language server
-
-## Installation
-
-From the directory of this crate, run:
-
-```
-cargo install --path .
-```
-
-This will install the `steel-language-server` to your path.
-
-Configuration in helix can be done by adding the following to your `languages.toml` file:
-
-```toml
-[[language]]
-name = "scheme"
-language-servers = [ "steel-language-server" ]
-
-[language-server.steel-language-server]
-command = "steel-language-server"
-args = []
-```
-
-VSCode, neovim, and emacs installation instructions coming soon.
-
-## Configuration
-
-If you're embedding steel within a host application, it is possible the language server does not have knowledge
-of the globals given by the host application. To make these available to the language server, create a configuration file
-for the language server under the path specified by the env var `STEEL_LSP_HOME`.
-
-For example, I have set my `STEEL_LSP_HOME` to `~/.config/steel-lsp/` and added the file `globals.scm`:
-
-```scheme
-
-(define keymaps (#%module "helix/core/keymaps"))
-
-(define (register-values module values)
-  (map (lambda (ident) (#%module-add module (symbol->string ident) void)) values))
-
-(register-values keymaps
-                 '(helix-current-keymap *buffer-or-extension-keybindings*
-                                        *reverse-buffer-map*
-                                        helix-merge-keybindings
-                                        helix-string->keymap
-                                        *global-keybinding-map*
-                                        helix-deep-copy-keymap))
-
-(define typable-commands (#%module "helix/core/typable"))
-(define static-commands (#%module "helix/core/static"))
-(define editor (#%module "helix/core/editor"))
-
-(register-values typable-commands '())
-
-(#%ignore-unused-identifier "_")
-
-keymaps
-
-```
-
-The following rules apply: Any global value that is defined as a builtin module, will be interpreted by the LSP and used, or evaluated as a top level env var. So either defining `keymaps` or evaluating like so on the last line of the example will get the module to show up.
-
-Any symbol added with `#%ignore-unused-identifier` will escape that symbol from being shown as an unused identifier.
-
-Any global registered with `#%register-global` will be ignored as a free identifier as well.
-
diff --git a/crates/steel-language-server/config/globals.scm b/crates/steel-language-server/config/globals.scm
deleted file mode 100644
index e69de29bb..000000000
diff --git a/crates/steel-language-server/src/backend.rs b/crates/steel-language-server/src/backend.rs
deleted file mode 100644
index 0cfca7c6b..000000000
--- a/crates/steel-language-server/src/backend.rs
+++ /dev/null
@@ -1,922 +0,0 @@
-use std::{
-    cell::RefCell,
-    collections::{HashMap, HashSet},
-    error::Error,
-    path::PathBuf,
-    sync::Arc,
-};
-
-use dashmap::{DashMap, DashSet};
-
-use ropey::Rope;
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use steel::{
-    compiler::passes::analysis::{
-        query_top_level_define, query_top_level_define_on_condition, RequiredIdentifierInformation,
-        SemanticAnalysis,
-    },
-    parser::{ast::ExprKind, expander::SteelMacro, interner::InternedString, parser::SourceId},
-    rvals::FromSteelVal,
-    steel_vm::{builtin::BuiltInModule, engine::Engine},
-};
-use tower_lsp::jsonrpc::Result;
-use tower_lsp::lsp_types::notification::Notification;
-use tower_lsp::lsp_types::*;
-use tower_lsp::{Client, LanguageServer};
-
-use tower_lsp::lsp_types::SemanticTokenType;
-
-use crate::diagnostics::{
-    DiagnosticContext, DiagnosticGenerator, FreeIdentifiersAndUnusedIdentifiers, StaticArityChecker,
-};
-
-pub const LEGEND_TYPE: &[SemanticTokenType] = &[
-    SemanticTokenType::FUNCTION,
-    SemanticTokenType::VARIABLE,
-    SemanticTokenType::STRING,
-    SemanticTokenType::COMMENT,
-    SemanticTokenType::NUMBER,
-    SemanticTokenType::KEYWORD,
-    SemanticTokenType::OPERATOR,
-    SemanticTokenType::PARAMETER,
-];
-
-pub struct Backend {
-    pub client: Client,
-    pub ast_map: DashMap<String, Vec<ExprKind>>,
-    pub document_map: DashMap<String, Rope>,
-    // TODO: This needs to hold macros to help with resolving definitions
-    pub _macro_map: DashMap<String, HashMap<InternedString, SteelMacro>>,
-    pub ignore_set: Arc<DashSet<InternedString>>,
-    pub globals_set: Arc<DashSet<InternedString>>,
-    pub defined_globals: DashSet<String>,
-}
-
-#[tower_lsp::async_trait]
-impl LanguageServer for Backend {
-    async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
-        Ok(InitializeResult {
-            server_info: None,
-            offset_encoding: None,
-            capabilities: ServerCapabilities {
-                inlay_hint_provider: Some(OneOf::Left(true)),
-                text_document_sync: Some(TextDocumentSyncCapability::Kind(
-                    TextDocumentSyncKind::FULL,
-                )),
-                completion_provider: Some(CompletionOptions {
-                    resolve_provider: Some(false),
-                    trigger_characters: Some(vec!["(".to_string()]),
-                    work_done_progress_options: Default::default(),
-                    all_commit_characters: None,
-                    completion_item: None,
-                }),
-                execute_command_provider: Some(ExecuteCommandOptions {
-                    commands: vec![],
-                    work_done_progress_options: Default::default(),
-                }),
-
-                workspace: Some(WorkspaceServerCapabilities {
-                    workspace_folders: Some(WorkspaceFoldersServerCapabilities {
-                        supported: Some(true),
-                        change_notifications: Some(OneOf::Left(true)),
-                    }),
-                    file_operations: None,
-                }),
-                semantic_tokens_provider: Some(
-                    SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(
-                        SemanticTokensRegistrationOptions {
-                            text_document_registration_options: {
-                                TextDocumentRegistrationOptions {
-                                    document_selector: Some(vec![DocumentFilter {
-                                        language: Some("scheme".to_string()),
-                                        scheme: Some("file".to_string()),
-                                        pattern: None,
-                                    }]),
-                                }
-                            },
-                            semantic_tokens_options: SemanticTokensOptions {
-                                work_done_progress_options: WorkDoneProgressOptions::default(),
-                                legend: SemanticTokensLegend {
-                                    token_types: LEGEND_TYPE.into(),
-                                    token_modifiers: vec![],
-                                },
-                                range: Some(true),
-                                full: Some(SemanticTokensFullOptions::Bool(true)),
-                            },
-                            static_registration_options: StaticRegistrationOptions::default(),
-                        },
-                    ),
-                ),
-                definition_provider: Some(OneOf::Left(true)),
-                references_provider: Some(OneOf::Left(true)),
-                rename_provider: Some(OneOf::Left(true)),
-                hover_provider: Some(HoverProviderCapability::Simple(true)),
-                ..ServerCapabilities::default()
-            },
-        })
-    }
-    async fn initialized(&self, _: InitializedParams) {
-        self.client
-            .log_message(MessageType::INFO, "initialized!")
-            .await;
-    }
-
-    async fn shutdown(&self) -> Result<()> {
-        Ok(())
-    }
-
-    async fn did_open(&self, params: DidOpenTextDocumentParams) {
-        self.client
-            .log_message(MessageType::INFO, "file opened!")
-            .await;
-        self.on_change(TextDocumentItem {
-            uri: params.text_document.uri,
-            text: params.text_document.text,
-            version: params.text_document.version,
-        })
-        .await
-    }
-
-    async fn did_change(&self, mut params: DidChangeTextDocumentParams) {
-        self.on_change(TextDocumentItem {
-            uri: params.text_document.uri,
-            text: std::mem::take(&mut params.content_changes[0].text),
-            version: params.text_document.version,
-        })
-        .await
-    }
-
-    // TODO: In order to get changes in one file to propagate to another,
-    // This _should_ trigger a recompile for the file - this will need to probably
-    // read the whole file, and then re run the analysis?
-    async fn did_save(&self, _: DidSaveTextDocumentParams) {
-        self.client
-            .log_message(MessageType::INFO, "file saved!")
-            .await;
-    }
-
-    async fn did_close(&self, _: DidCloseTextDocumentParams) {
-        self.client
-            .log_message(MessageType::INFO, "file closed!")
-            .await;
-    }
-
-    async fn hover(&self, params: HoverParams) -> Result<Option<Hover>> {
-        // TODO: In order for this to work, we'll have to both
-        // expose a span -> URI function, as well as figure out how to
-        // decide if a definition refers to an import. I think deciding
-        // if something is a module import should be like:
-        let definition = || -> Option<Hover> {
-            let uri = params.text_document_position_params.text_document.uri;
-            let mut ast = self.ast_map.get_mut(uri.as_str())?;
-
-            let position = params.text_document_position_params.position;
-            let rope = self.document_map.get(uri.as_str())?;
-            let char = rope.try_line_to_char(position.line as usize).ok()?;
-            let offset = char + position.character as usize;
-
-            let analysis = SemanticAnalysis::new(&mut ast);
-
-            let (syntax_object_id, information) =
-                analysis.find_identifier_at_offset(offset, uri_to_source_id(&uri).unwrap())?;
-
-            let mut syntax_object_id_to_interned_string = HashMap::new();
-            syntax_object_id_to_interned_string.insert(*syntax_object_id, None);
-
-            // If this is a builtin, reference the engine's internal documentation
-            // Note: This does not handle resolving the identifier if it has been brought into scope
-            // with some kind of prefix. This should be relatively easy to resolve - the analysis
-            // can most likely identify if this is a builtin by checking what it was bought into scope
-            // with. For example, it would be brought into scope with:
-            // (define foo.list (%proto-hash-get% ...)
-            //
-            // The ability to then just check what the original identifier was can help us resolve
-            // the binding, by just checking against the interned string stored in the proto hash get.
-            if information.builtin {
-                analysis.syntax_object_ids_to_identifiers(&mut syntax_object_id_to_interned_string);
-
-                let name = syntax_object_id_to_interned_string.get(syntax_object_id)?;
-
-                let doc =
-                    ENGINE.with_borrow(|x| x.builtin_modules().get_doc((*name)?.resolve()))?;
-
-                return Some(Hover {
-                    contents: HoverContents::Scalar(MarkedString::String(doc)),
-                    range: None,
-                });
-            }
-
-            // Refers to something - keep that around as well
-            let refers_to = information.refers_to?;
-
-            // See if we can find this as well.
-            syntax_object_id_to_interned_string.insert(refers_to, None);
-
-            let maybe_definition = analysis.get_identifier(refers_to)?;
-
-            log::debug!("Refers to information: {:?}", &maybe_definition);
-
-            if maybe_definition.is_required_identifier {
-                match analysis.resolve_required_identifier(refers_to)? {
-                    RequiredIdentifierInformation::Resolved(_) => {
-                        // Maybe include the span?
-                        // resulting_span = resolved.span;
-
-                        // Find the doc associated with this span then
-                        analysis.syntax_object_ids_to_identifiers(
-                            &mut syntax_object_id_to_interned_string,
-                        );
-
-                        // Guaranteed to be here given that we've resolve it above
-                        let definition_name = syntax_object_id_to_interned_string
-                            .get(&refers_to)
-                            .clone()?
-                            .clone()?;
-
-                        // Memoize a lot of these lookups if possible, or at least share the memory;
-                        let doc_suffix = definition_name.resolve().to_string() + "__doc__";
-
-                        let define = analysis.query_top_level_define(&doc_suffix)?;
-
-                        // This _should_ be the resolved documentation. And then we just extract the
-                        // string from the definition.
-
-                        let definition = define.body.to_string_literal()?;
-
-                        return Some(Hover {
-                            contents: HoverContents::Scalar(MarkedString::String(
-                                definition.clone(),
-                            )),
-                            range: None,
-                        });
-                    }
-
-                    RequiredIdentifierInformation::Unresolved(interned, name) => {
-                        let module_path_to_check = name
-                            .trim_start_matches("mangler")
-                            .trim_end_matches(interned.resolve())
-                            .trim_end_matches("__%#__");
-
-                        return ENGINE.with_borrow(|engine| {
-                            let module = engine
-                                .modules()
-                                .get(&PathBuf::from(module_path_to_check))
-                                .unwrap();
-
-                            let module_ast = module.get_ast();
-
-                            // Find the doc form of this
-                            let interned = interned.resolve().to_string() + "__doc__";
-
-                            let top_level_define = query_top_level_define(module_ast, &interned)
-                                .or_else(|| {
-                                    query_top_level_define_on_condition(
-                                        module_ast,
-                                        &interned,
-                                        |name, target| name.ends_with(target),
-                                    )
-                                })?;
-
-                            let definition = top_level_define.body.to_string_literal()?;
-
-                            Some(Hover {
-                                contents: HoverContents::Scalar(MarkedString::String(
-                                    definition.clone(),
-                                )),
-                                range: None,
-                            })
-                        });
-                    }
-                }
-            }
-
-            // Resolve what we've found?
-            analysis.syntax_object_ids_to_identifiers(&mut syntax_object_id_to_interned_string);
-
-            let definition_name = syntax_object_id_to_interned_string
-                .get(&refers_to)
-                .clone()?
-                .clone()?;
-
-            // Memoize a lot of these lookups if possible, or at least share the memory;
-            let doc_suffix = definition_name.resolve().to_string() + "__doc__";
-
-            let define = analysis.query_top_level_define(&doc_suffix)?;
-
-            // This _should_ be the resolved documentation. And then we just extract the
-            // string from the definition.
-
-            let definition = define.body.to_string_literal()?;
-
-            Some(Hover {
-                contents: HoverContents::Scalar(MarkedString::String(definition.clone())),
-                range: None,
-            })
-        };
-
-        Ok(definition())
-
-        // Ok(definition)
-    }
-
-    async fn goto_definition(
-        &self,
-        params: GotoDefinitionParams,
-    ) -> Result<Option<GotoDefinitionResponse>> {
-        // TODO: In order for this to work, we'll have to both
-        // expose a span -> URI function, as well as figure out how to
-        // decide if a definition refers to an import. I think deciding
-        // if something is a module import should be like:
-        let definition = async {
-            let uri = params.text_document_position_params.text_document.uri;
-            let mut ast = self.ast_map.get_mut(uri.as_str())?;
-            let mut rope = self.document_map.get(uri.as_str())?.clone();
-
-            let position = params.text_document_position_params.position;
-            let char = rope.try_line_to_char(position.line as usize).ok()?;
-            let offset = char + position.character as usize;
-
-            let analysis = SemanticAnalysis::new(&mut ast);
-
-            let (_syntax_object_id, information) =
-                analysis.find_identifier_at_offset(offset, uri_to_source_id(&uri).unwrap())?;
-
-            let refers_to = information.refers_to?;
-
-            let maybe_definition = analysis.get_identifier(refers_to)?;
-
-            let mut resulting_span = maybe_definition.span;
-
-            log::debug!("Refers to information: {:?}", &maybe_definition);
-
-            if maybe_definition.is_required_identifier {
-                match analysis.resolve_required_identifier(refers_to)? {
-                    RequiredIdentifierInformation::Resolved(resolved) => {
-                        resulting_span = resolved.span;
-                    }
-
-                    RequiredIdentifierInformation::Unresolved(interned, name) => {
-                        log::debug!("Found unresolved identifier: {} - {}", interned, name);
-
-                        let module_path_to_check = name
-                            .trim_start_matches("mangler")
-                            .trim_end_matches(interned.resolve())
-                            .trim_end_matches("__%#__");
-
-                        resulting_span = ENGINE.with_borrow(|engine| {
-                            log::debug!(
-                                "Compiled modules: {:?}",
-                                engine.modules().keys().collect::<Vec<_>>()
-                            );
-
-                            log::debug!("Searching for: {} in {}", name, module_path_to_check);
-
-                            let module = engine
-                                .modules()
-                                .get(&PathBuf::from(module_path_to_check))
-                                .unwrap();
-
-                            let module_ast = module.get_ast();
-
-                            // for expr in ast {
-                            //     log::debug!("{}", expr);
-                            // }
-
-                            let top_level_define =
-                                query_top_level_define(module_ast, interned.resolve()).or_else(
-                                    || {
-                                        query_top_level_define_on_condition(
-                                            module_ast,
-                                            interned.resolve(),
-                                            |name, target| name.ends_with(target),
-                                        )
-                                    },
-                                )?;
-
-                            log::debug!("Found define: {}", top_level_define);
-
-                            top_level_define.name.atom_syntax_object().map(|x| x.span)
-
-                            // top_level_define
-                        })?;
-                    }
-                }
-
-                log::debug!("Found new definition: {:?}", maybe_definition);
-            }
-
-            let location = source_id_to_uri(resulting_span.source_id()?)?;
-
-            log::debug!("Location: {:?}", location);
-            log::debug!("Rope length: {:?}", rope.len_chars());
-            // log::debug!("span: {:?}", maybe_definition.span);
-
-            if location != uri {
-                log::debug!("Jumping to definition that is not yet in the document map!");
-
-                let expression =
-                    ENGINE.with_borrow(|x| x.get_source(&resulting_span.source_id().unwrap()))?;
-
-                rope = self
-                    .document_map
-                    .get(location.as_str())
-                    .map(|x| x.clone())
-                    .unwrap_or_else(|| Rope::from_str(&expression));
-
-                self.document_map.insert(location.to_string(), rope.clone());
-            }
-
-            log::debug!("Location: {:?}", location);
-            log::debug!("Rope length: {:?}", rope.len_chars());
-            // log::debug!("span: {:?}", maybe_definition.span);
-
-            let start_position = offset_to_position(resulting_span.start, &rope)?;
-            let end_position = offset_to_position(resulting_span.end, &rope)?;
-
-            let range = Range::new(start_position, end_position);
-
-            log::debug!("{:?}", range);
-
-            Some(GotoDefinitionResponse::Scalar(Location::new(
-                location, range,
-            )))
-        }
-        .await;
-        Ok(definition)
-    }
-
-    async fn references(&self, _params: ReferenceParams) -> Result<Option<Vec<Location>>> {
-        Ok(None)
-    }
-
-    async fn semantic_tokens_full(
-        &self,
-        _params: SemanticTokensParams,
-    ) -> Result<Option<SemanticTokensResult>> {
-        Ok(None)
-    }
-
-    async fn semantic_tokens_range(
-        &self,
-        _params: SemanticTokensRangeParams,
-    ) -> Result<Option<SemanticTokensRangeResult>> {
-        Ok(None)
-    }
-
-    async fn inlay_hint(
-        &self,
-        _params: tower_lsp::lsp_types::InlayHintParams,
-    ) -> Result<Option<Vec<InlayHint>>> {
-        Ok(None)
-    }
-
-    async fn completion(&self, params: CompletionParams) -> Result<Option<CompletionResponse>> {
-        let uri = params.text_document_position.text_document.uri;
-        let position = params.text_document_position.position;
-        let mut filter_character = None;
-
-        let completions = || -> Option<Vec<CompletionItem>> {
-            let rope = self.document_map.get(&uri.to_string())?;
-            let mut ast = self.ast_map.get_mut(&uri.to_string())?;
-            let char = rope.try_line_to_char(position.line as usize).ok()?;
-
-            let offset = char + position.character as usize;
-
-            if offset > 0 {
-                let previously_typed = rope.get_char(offset - 1);
-
-                if previously_typed.is_some() && previously_typed != Some('(') {
-                    if offset > 2 {
-                        let prior = rope.get_char(offset - 2);
-
-                        if prior.is_some() && prior.map(char::is_whitespace).unwrap() {
-                            filter_character = previously_typed;
-                        }
-                    } else {
-                        filter_character = previously_typed;
-                    }
-                }
-            }
-
-            let filter_interned_string = |interned_string: &InternedString| {
-                filter_interned_string_with_char(interned_string, filter_character)
-            };
-
-            let analysis = SemanticAnalysis::new(&mut ast);
-
-            // Finds the scoped contexts that we're currently inside of by the span
-            let contexts =
-                analysis.find_contexts_with_offset(offset, uri_to_source_id(&uri).unwrap());
-
-            let now = std::time::Instant::now();
-
-            let mut completions: HashSet<String> =
-                HashSet::with_capacity(contexts.len() + self.defined_globals.len());
-
-            for context in contexts {
-                match context {
-                    steel::compiler::passes::analysis::SemanticInformationType::Function(info) => {
-                        completions.extend(
-                            info.arguments()
-                                .keys()
-                                .filter_map(filter_interned_string)
-                                .chain(
-                                    info.captured_vars()
-                                        .keys()
-                                        .filter_map(filter_interned_string),
-                                ),
-                        );
-                    }
-                    steel::compiler::passes::analysis::SemanticInformationType::Let(info) => {
-                        completions.extend(info.arguments.keys().filter_map(filter_interned_string))
-                    }
-                    _ => {}
-                }
-            }
-
-            // A bit sillys
-            completions.extend(
-                analysis
-                    .find_global_defs()
-                    .into_iter()
-                    .filter_map(|x| filter_interned_string(&x.0)),
-            );
-
-            completions.extend(self.defined_globals.iter().filter_map(|x| {
-                if let Some(c) = filter_character {
-                    if !x.starts_with(c) {
-                        return None;
-                    }
-                }
-
-                Some(x.clone())
-            }));
-
-            // TODO: Build completions from macros that have been introduced into this scope
-            completions.extend(ENGINE.with_borrow(|engine| {
-                engine
-                    .in_scope_macros()
-                    .keys()
-                    .filter_map(|x| {
-                        if let Some(c) = filter_character {
-                            if !x.resolve().starts_with(c) {
-                                return None;
-                            }
-                        }
-
-                        Some(x.resolve().to_string())
-                    })
-                    .collect::<Vec<_>>()
-            }));
-
-            let mut ret = Vec::with_capacity(completions.len());
-            for var in completions {
-                ret.push(CompletionItem {
-                    label: var.clone(),
-                    insert_text: Some(var.clone()),
-                    kind: Some(CompletionItemKind::VARIABLE),
-                    detail: Some(var),
-                    ..Default::default()
-                });
-            }
-
-            log::debug!("Time to calculate completions: {:?}", now.elapsed());
-
-            Some(ret)
-        }();
-
-        Ok(completions.map(CompletionResponse::Array))
-    }
-
-    async fn rename(&self, _params: RenameParams) -> Result<Option<WorkspaceEdit>> {
-        Ok(None)
-    }
-
-    async fn did_change_configuration(&self, _: DidChangeConfigurationParams) {
-        self.client
-            .log_message(MessageType::INFO, "configuration changed!")
-            .await;
-    }
-
-    async fn did_change_workspace_folders(&self, _: DidChangeWorkspaceFoldersParams) {
-        self.client
-            .log_message(MessageType::INFO, "workspace folders changed!")
-            .await;
-    }
-
-    async fn did_change_watched_files(&self, _: DidChangeWatchedFilesParams) {
-        self.client
-            .log_message(MessageType::INFO, "watched files have changed!")
-            .await;
-    }
-
-    async fn execute_command(&self, _: ExecuteCommandParams) -> Result<Option<Value>> {
-        self.client
-            .log_message(MessageType::INFO, "command executed!")
-            .await;
-
-        match self.client.apply_edit(WorkspaceEdit::default()).await {
-            Ok(res) if res.applied => self.client.log_message(MessageType::INFO, "applied").await,
-            Ok(_) => self.client.log_message(MessageType::INFO, "rejected").await,
-            Err(err) => self.client.log_message(MessageType::ERROR, err).await,
-        }
-
-        Ok(None)
-    }
-}
-
-fn filter_interned_string_with_char(
-    interned: &InternedString,
-    filter_char: Option<char>,
-) -> Option<String> {
-    let resolved = interned.resolve();
-
-    if let Some(c) = filter_char {
-        if !resolved.starts_with(c) {
-            return None;
-        }
-    }
-
-    if !resolved.starts_with("#")
-        && !resolved.starts_with("%")
-        && !resolved.starts_with("mangler#%")
-        && !resolved.starts_with("!!dummy-rest")
-    {
-        Some(resolved.to_string())
-    } else {
-        None
-    }
-}
-
-#[derive(Debug, Deserialize, Serialize)]
-struct InlayHintParams {
-    path: String,
-}
-
-enum CustomNotification {}
-impl Notification for CustomNotification {
-    type Params = InlayHintParams;
-    const METHOD: &'static str = "custom/notification";
-}
-struct TextDocumentItem {
-    uri: Url,
-    text: String,
-    version: i32,
-}
-impl Backend {
-    async fn on_change(&self, params: TextDocumentItem) {
-        let now = std::time::Instant::now();
-
-        self.client
-            .log_message(MessageType::INFO, "on change")
-            .await;
-
-        let rope = ropey::Rope::from_str(&params.text);
-        self.document_map
-            .insert(params.uri.to_string(), rope.clone());
-
-        self.client
-            .log_message(MessageType::INFO, &params.uri.as_str())
-            .await;
-
-        let expression = params.text;
-
-        let diagnostics = {
-            let program = ENGINE.with_borrow_mut(|x| {
-                // TODO: Reuse this!a
-                let macro_env_before: HashSet<InternedString> =
-                    x.in_scope_macros().keys().copied().collect();
-
-                // TODO: Add span to the macro definition!
-                let mut introduced_macros: HashMap<InternedString, SteelMacro> = HashMap::new();
-
-                let expressions = x.emit_expanded_ast_without_optimizations(
-                    &expression,
-                    params.uri.to_file_path().ok(),
-                );
-
-                x.in_scope_macros_mut().retain(|key, value| {
-                    if macro_env_before.contains(key) {
-                        return true;
-                    } else {
-                        // FIXME: Try to avoid this clone!
-                        introduced_macros.insert(*key, value.clone());
-                        false
-                    }
-                });
-
-                expressions
-            });
-
-            let mut ast = match program {
-                Ok(ast) => ast,
-                Err(e) => {
-                    // drop(engine_guard);
-
-                    self.client
-                        .log_message(MessageType::INFO, e.to_string())
-                        .await;
-
-                    if let Some(span) = e.span() {
-                        let diagnostics = || {
-                            let start_position = offset_to_position(span.start, &rope)?;
-                            let end_position = offset_to_position(span.end, &rope)?;
-
-                            Some(vec![Diagnostic::new_simple(
-                                Range::new(start_position, end_position),
-                                e.to_string(),
-                            )])
-                        };
-
-                        if let Some(diagnostics) = diagnostics() {
-                            self.client
-                                .publish_diagnostics(
-                                    params.uri.clone(),
-                                    diagnostics,
-                                    Some(params.version),
-                                )
-                                .await;
-                        }
-                    }
-
-                    return;
-                }
-            };
-
-            let id = uri_to_source_id(&params.uri);
-
-            let analysis = SemanticAnalysis::new(&mut ast);
-
-            let diagnostics = ENGINE.with_borrow(|engine| {
-                let mut context = DiagnosticContext {
-                    engine: &engine,
-                    analysis: &analysis,
-                    uri: &params.uri,
-                    source_id: id,
-                    rope: rope.clone(),
-                    globals_set: &self.globals_set,
-                    ignore_set: &self.ignore_set,
-                };
-
-                let mut free_identifiers_and_unused =
-                    FreeIdentifiersAndUnusedIdentifiers.diagnose(&mut context);
-
-                let mut static_arity_checking = StaticArityChecker.diagnose(&mut context);
-
-                free_identifiers_and_unused.append(&mut static_arity_checking);
-
-                // All the diagnostics total
-                free_identifiers_and_unused
-            });
-
-            self.ast_map.insert(params.uri.to_string(), ast);
-
-            diagnostics
-        };
-
-        self.client
-            .publish_diagnostics(params.uri.clone(), diagnostics, Some(params.version))
-            .await;
-
-        log::debug!("On change time taken: {:?}", now.elapsed());
-    }
-}
-
-fn uri_to_source_id(uri: &Url) -> Option<steel::parser::parser::SourceId> {
-    let id = ENGINE.with_borrow(|x| x.get_source_id(&uri.to_file_path().unwrap()));
-    id
-}
-
-fn source_id_to_uri(source_id: SourceId) -> Option<Url> {
-    let path = ENGINE.with_borrow(|x| x.get_path_for_source_id(&source_id))?;
-
-    Some(Url::from_file_path(path).unwrap())
-}
-
-pub fn make_error(mut diagnostic: Diagnostic) -> Diagnostic {
-    diagnostic.severity = Some(DiagnosticSeverity::ERROR);
-    diagnostic
-}
-
-pub struct ExternalModuleResolver {
-    modules: HashMap<String, BuiltInModule>,
-}
-
-impl ExternalModuleResolver {
-    pub fn new(
-        engine: &mut Engine,
-        directory: PathBuf,
-    ) -> std::result::Result<Self, Box<dyn Error>> {
-        let mut modules = HashMap::new();
-
-        for file in std::fs::read_dir(&directory)? {
-            let file = file?;
-
-            if file.path().is_file() {
-                let contents = std::fs::read_to_string(file.path())?;
-
-                let result = engine.compile_and_run_raw_program(&contents)?;
-
-                for value in result {
-                    if let Ok(module) = BuiltInModule::from_steelval(&value) {
-                        modules.insert(module.name().to_string(), module);
-                    }
-                }
-            }
-        }
-
-        // Check globals now - for anything that isn't returned directly
-        for global in engine.globals() {
-            if let Ok(module) = engine.extract::<BuiltInModule>(global.resolve()) {
-                if !modules.contains_key(module.name().as_ref()) {
-                    modules.insert(module.name().to_string(), module);
-                }
-            }
-        }
-
-        Ok(ExternalModuleResolver { modules })
-    }
-}
-
-impl steel::steel_vm::engine::ModuleResolver for ExternalModuleResolver {
-    fn resolve(&self, module: &str) -> Option<BuiltInModule> {
-        self.modules.get(module).cloned()
-    }
-}
-
-thread_local! {
-    pub static ENGINE: RefCell<Engine> = RefCell::new(Engine::new());
-}
-
-// #[tokio::main]
-// async fn main() {
-//     env_logger::init();
-
-//     let stdin = tokio::io::stdin();
-//     let stdout = tokio::io::stdout();
-
-//     // Use this to resolve the module configuration files
-//     let mut resolver_engine = Engine::new();
-
-//     let globals_set = Arc::new(DashSet::new());
-
-//     globals_set.insert("#%ignore-unused-identifier".into());
-//     globals_set.insert("#%register-global".into());
-
-//     let cloned_set = globals_set.clone();
-//     resolver_engine.register_fn("#%register-global", move |global: String| {
-//         cloned_set.insert(InternedString::from(global))
-//     });
-
-//     let ignore_unused_set = Arc::new(DashSet::new());
-//     let cloned_ignore_set = ignore_unused_set.clone();
-//     resolver_engine.register_fn("#%ignore-unused-identifier", move |global: String| {
-//         cloned_ignore_set.insert(InternedString::from(global));
-//     });
-
-//     ENGINE.with_borrow_mut(|x| {
-//         x.register_module_resolver(
-//             ExternalModuleResolver::new(
-//                 &mut resolver_engine,
-//                 PathBuf::from("/home/matt/.config/steel-lsp/"),
-//             )
-//             .unwrap(),
-//         )
-//     });
-
-//     let defined_globals = DashSet::new();
-
-//     ENGINE.with_borrow(|engine| {
-//         for global in engine.globals() {
-//             let resolved = global.resolve();
-//             if !resolved.starts_with("#")
-//                 && !resolved.starts_with("%")
-//                 && !resolved.starts_with("mangler#%")
-//             {
-//                 defined_globals.insert(resolved.to_string());
-//             }
-//         }
-//     });
-
-//     let (service, socket) = LspService::build(|client| Backend {
-//         client,
-//         ast_map: DashMap::new(),
-//         document_map: DashMap::new(),
-//         _macro_map: DashMap::new(),
-//         globals_set,
-//         ignore_set: ignore_unused_set,
-//         defined_globals,
-//     })
-//     .finish();
-
-//     Server::new(stdin, stdout, socket).serve(service).await;
-// }
-
-pub fn offset_to_position(offset: usize, rope: &Rope) -> Option<Position> {
-    let line = rope.try_char_to_line(offset).ok()?;
-    let first_char_of_line = rope.try_line_to_char(line).ok()?;
-    let column = offset - first_char_of_line;
-
-    Some(Position::new(line as u32, column as u32))
-}
diff --git a/crates/steel-language-server/src/client.rs b/crates/steel-language-server/src/client.rs
deleted file mode 100644
index 8b1378917..000000000
--- a/crates/steel-language-server/src/client.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/crates/steel-language-server/src/configuration.rs b/crates/steel-language-server/src/configuration.rs
deleted file mode 100644
index 8b1378917..000000000
--- a/crates/steel-language-server/src/configuration.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/crates/steel-language-server/src/contract.rs b/crates/steel-language-server/src/contract.rs
deleted file mode 100644
index 8b1378917..000000000
--- a/crates/steel-language-server/src/contract.rs
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/crates/steel-language-server/src/diagnostics.rs b/crates/steel-language-server/src/diagnostics.rs
deleted file mode 100644
index 32c761de8..000000000
--- a/crates/steel-language-server/src/diagnostics.rs
+++ /dev/null
@@ -1,710 +0,0 @@
-#![allow(unused)]
-
-use std::{
-    collections::{BTreeSet, HashMap},
-    iter::FlatMap,
-    path::PathBuf,
-};
-
-use dashmap::DashSet;
-use ropey::Rope;
-use steel::{
-    compiler::passes::{
-        analysis::{
-            query_top_level_define, query_top_level_define_on_condition,
-            RequiredIdentifierInformation, SemanticAnalysis,
-        },
-        VisitorMutUnitRef,
-    },
-    define_primitive_symbols, define_symbols,
-    parser::{
-        ast::{Define, ExprKind},
-        interner::InternedString,
-        parser::{SourceId, SyntaxObjectId},
-        span::Span,
-    },
-    steel_vm::{builtin::Arity, engine::Engine},
-    stop, SteelVal,
-};
-use tower_lsp::lsp_types::{Diagnostic, DiagnosticSeverity, Range, Url};
-
-use crate::backend::{make_error, offset_to_position};
-
-pub struct DiagnosticContext<'a> {
-    pub engine: &'a Engine,
-    pub analysis: &'a SemanticAnalysis<'a>,
-    pub uri: &'a Url,
-    pub source_id: Option<SourceId>,
-    pub rope: Rope,
-    pub globals_set: &'a DashSet<InternedString>,
-    pub ignore_set: &'a DashSet<InternedString>,
-}
-
-pub struct FreeIdentifiersAndUnusedIdentifiers;
-
-impl DiagnosticGenerator for FreeIdentifiersAndUnusedIdentifiers {
-    fn diagnose(&mut self, context: &mut DiagnosticContext) -> Vec<Diagnostic> {
-        context
-            .analysis
-            .free_identifiers_with_globals(context.engine.symbol_map())
-            .into_iter()
-            .map(|(ident, info)| (ident, info.span))
-            .flat_map(|(ident, span)| {
-                if span.source_id() != context.source_id {
-                    return None;
-                }
-
-                if context.globals_set.contains(&ident) {
-                    return None;
-                }
-
-                let resolved = ident.resolve();
-
-                // We can just ignore those as well
-                if resolved.starts_with("mangler") {
-                    return None;
-                }
-
-                let start_position = offset_to_position(span.start, &context.rope)?;
-                let end_position = offset_to_position(span.end, &context.rope)?;
-
-                // TODO: Publish the diagnostics for each file separately, if we have them
-                Some(make_error(Diagnostic::new_simple(
-                    Range::new(start_position, end_position),
-                    format!("free identifier: {}", resolved),
-                )))
-            })
-            .chain(
-                context
-                    .analysis
-                    .find_unused_arguments()
-                    .into_iter()
-                    .flat_map(|(ident, span)| {
-                        if span.source_id() != context.source_id {
-                            return None;
-                        }
-
-                        if context.ignore_set.contains(&ident) {
-                            return None;
-                        }
-
-                        let resolved = ident.resolve();
-
-                        // This identifier has been renamed - so we can unmangle it and see if it
-                        // is in the ignore set
-                        if resolved.starts_with("##") && resolved.ends_with(char::is_numeric) {
-                            if context.ignore_set.contains(
-                                &resolved
-                                    .trim_start_matches("##")
-                                    .trim_end_matches(char::is_numeric)
-                                    .into(),
-                            ) {
-                                return None;
-                            }
-                        }
-
-                        let start_position = offset_to_position(span.start, &context.rope)?;
-                        let end_position = offset_to_position(span.end, &context.rope)?;
-
-                        let mut diagnostic = Diagnostic::new_simple(
-                            Range::new(start_position, end_position),
-                            format!("unused variable"),
-                        );
-
-                        diagnostic.severity = Some(DiagnosticSeverity::INFORMATION);
-
-                        Some(diagnostic)
-                    }),
-            )
-            .collect()
-    }
-}
-
-pub struct StaticArityChecker;
-
-impl DiagnosticGenerator for StaticArityChecker {
-    fn diagnose(&mut self, context: &mut DiagnosticContext) -> Vec<Diagnostic> {
-        let mut arity_checker = StaticArityChecking {
-            known_functions: HashMap::new(),
-            analysis: &context.analysis,
-            known_contracts: HashMap::new(),
-        };
-
-        for expr in context.analysis.exprs.iter() {
-            arity_checker.visit(&expr);
-        }
-
-        // TODO: Resolve all required values to their original
-        // values in the other module, and link those known
-        // functions there.
-
-        let mut identifiers = context
-            .analysis
-            .analysis
-            .identifier_info()
-            .iter()
-            .filter_map(|(key, info)| {
-                if info.is_required_identifier {
-                    Some(*key)
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        let required_identifier_information =
-            context.analysis.resolve_required_identifiers(identifiers);
-
-        for (id, required_identifier) in required_identifier_information {
-            match required_identifier {
-                // This is probably going to be annoying?
-                RequiredIdentifierInformation::Resolved(resolved) => {
-                    // TODO: When the identifier is already in the given AST, meaning
-                    // we don't have to go to another AST in order to resolve it,
-                    // we should just do that here.
-                }
-                RequiredIdentifierInformation::Unresolved(interned, name) => {
-                    let module_path_to_check = name
-                        .trim_start_matches("mangler")
-                        .trim_end_matches(interned.resolve())
-                        .trim_end_matches("__%#__");
-
-                    log::debug!("Searching for: {} in {}", name, module_path_to_check);
-
-                    let module = context
-                        .engine
-                        .modules()
-                        .get(&PathBuf::from(module_path_to_check))
-                        .unwrap();
-
-                    let module_ast = module.get_ast();
-
-                    // TODO: This is O(n^2) behavior, and we don't want that.
-                    // We should merge this and the above loop into one pass, collecting
-                    // all of the things that we need. This should be fast enough for small
-                    // enough modules, but it is going to blow up on larger modules.
-                    let top_level_define = query_top_level_define(module_ast, interned.resolve())
-                        .or_else(|| {
-                            query_top_level_define_on_condition(
-                                module_ast,
-                                interned.resolve(),
-                                |name, target| name.ends_with(target),
-                            )
-                        });
-
-                    // Don't include rest args for now
-                    if let Some(d) = top_level_define {
-                        if let ExprKind::LambdaFunction(l) = &d.body {
-                            if !l.rest {
-                                arity_checker.known_functions.insert(id, l.args.len());
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        StaticCallSiteArityChecker {
-            known_functions: arity_checker.known_functions,
-            context,
-            diagnostics: Vec::new(),
-        }
-        .check()
-    }
-}
-
-// Rules for this:
-//
-// The identifier is:
-//     * known, and not mutated.
-//     * We know the arity
-pub struct StaticArityChecking<'a> {
-    // Arity check the known functions
-    known_functions: HashMap<SyntaxObjectId, usize>,
-    // If we can, we can attach the contract information as well,
-    // to do any static error checking at the call site.
-    known_contracts: HashMap<SyntaxObjectId, StaticContract>,
-
-    analysis: &'a SemanticAnalysis<'a>,
-}
-
-impl<'a> VisitorMutUnitRef<'a> for StaticArityChecking<'a> {
-    fn visit_begin(&mut self, begin: &'a steel::parser::ast::Begin) {
-        // Check if this is a define/contract
-        match (begin.exprs.get(0), begin.exprs.get(1)) {
-            (Some(ExprKind::Define(d)), Some(ExprKind::Set(s))) => {
-                if let ExprKind::LambdaFunction(l) = &d.body {
-                    if let Some(contract) = function_contract(&s.expr) {
-                        self.known_functions
-                            .insert(d.name_id().unwrap(), l.args.len());
-
-                        if let Ok(contract) = contract {
-                            self.known_contracts.insert(d.name_id().unwrap(), contract);
-                        }
-                    }
-                }
-            }
-            _ => {}
-        }
-
-        for expr in &begin.exprs {
-            self.visit(expr);
-        }
-    }
-
-    fn visit_define(&mut self, define: &'a Define) {
-        if let Some(function_name) = define.name_id() {
-            if let Some(info) = self.analysis.get_identifier(function_name) {
-                // Note: This means we'll miss functions bound by define/contract.
-                // It could encourage putting the contract at the function boundary,
-                // which is nice.
-                if !info.set_bang {
-                    if let ExprKind::LambdaFunction(l) = &define.body {
-                        if !l.rest {
-                            self.known_functions.insert(function_name, l.args.len());
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-pub struct StaticCallSiteArityChecker<'a, 'b> {
-    known_functions: HashMap<SyntaxObjectId, usize>,
-    context: &'a mut DiagnosticContext<'b>,
-    diagnostics: Vec<Diagnostic>,
-}
-
-impl<'a, 'b> StaticCallSiteArityChecker<'a, 'b> {
-    fn check(mut self) -> Vec<Diagnostic> {
-        for expr in self.context.analysis.exprs.iter() {
-            self.visit(expr);
-        }
-
-        self.diagnostics
-    }
-}
-
-fn create_diagnostic(rope: &Rope, span: &Span, message: String) -> Option<Diagnostic> {
-    let start_position = offset_to_position(span.start, &rope)?;
-    let end_position = offset_to_position(span.end, &rope)?;
-
-    let mut diagnostic = Diagnostic::new_simple(Range::new(start_position, end_position), message);
-
-    diagnostic.severity = Some(DiagnosticSeverity::INFORMATION);
-
-    Some(diagnostic)
-}
-
-impl<'a, 'b> VisitorMutUnitRef<'a> for StaticCallSiteArityChecker<'a, 'b> {
-    fn visit_list(&mut self, l: &'a steel::parser::ast::List) {
-        if let Some(function_call_ident) = l
-            .first()
-            .and_then(|x| x.atom_syntax_object())
-            .map(|x| x.syntax_object_id)
-        {
-            // If it is something that... doesn't happen in the file we're currently
-            // looking at - we probably shouldn't report it there?
-            if !l.first_ident().unwrap().resolve().starts_with("mangler") {
-                if let Some(info) = self.context.analysis.get_identifier(function_call_ident) {
-                    if info.builtin {
-                        let found_arity = self
-                            .context
-                            .engine
-                            .builtin_modules()
-                            .get_metadata_by_name(l.first_ident().unwrap().resolve())
-                            .map(|x| x.arity)
-                            .or_else(|| {
-                                // If this isn't found in the original built in modules,
-                                // attempt to find it registered globally?
-                                if let SteelVal::BoxedFunction(b) = self
-                                    .context
-                                    .engine
-                                    .extract_value(l.first_ident().unwrap().resolve())
-                                    .ok()?
-                                {
-                                    b.arity.map(Arity::Exact)
-                                } else {
-                                    None
-                                }
-                            });
-
-                        match found_arity {
-                            Some(Arity::Exact(arity)) => {
-                                if l.args.len() != arity + 1 {
-                                    let span =
-                                        l.first().unwrap().atom_syntax_object().unwrap().span;
-
-                                    if let Some(diagnostic) = create_diagnostic(
-                                        &self.context.rope,
-                                        &span,
-                                        format!(
-                                            "Arity mismatch: {} expects {} arguments, found {}",
-                                            l.first().unwrap(),
-                                            arity,
-                                            l.args.len() - 1
-                                        ),
-                                    ) {
-                                        self.diagnostics.push(diagnostic);
-                                    }
-                                }
-                            }
-                            Some(Arity::AtLeast(arity)) => {
-                                if l.args.len() <= arity + 1 {
-                                    let span =
-                                        l.first().unwrap().atom_syntax_object().unwrap().span;
-
-                                    if let Some(diagnostic) = create_diagnostic(
-                                    &self.context.rope,
-                                    &span,
-                                    format!(
-                                        "Arity mismatch: {} expects at least {} arguments, found {}",
-                                        l.first().unwrap(),
-                                        arity,
-                                        l.args.len() - 1
-                                    ),
-                                ) {
-                                    self.diagnostics.push(diagnostic);
-                                }
-                                }
-                            }
-                            Some(Arity::AtMost(arity)) => {
-                                if l.args.len() > arity + 1 {
-                                    let span =
-                                        l.first().unwrap().atom_syntax_object().unwrap().span;
-
-                                    if let Some(diagnostic) = create_diagnostic(
-                                        &self.context.rope,
-                                        &span,
-                                        format!(
-                                        "Arity mismatch: {} expects at most {} arguments, found {}",
-                                        l.first().unwrap(),
-                                        arity,
-                                        l.args.len() - 1
-                                    ),
-                                    ) {
-                                        self.diagnostics.push(diagnostic);
-                                    }
-                                }
-                            }
-                            // TODO: Handle this arity if it comes up
-                            Some(Arity::Range(n)) => {}
-                            None => {}
-                        }
-                    } else if let Some(refers_to_id) = info.refers_to {
-                        if let Some(arity) = self.known_functions.get(&refers_to_id) {
-                            if l.args.len() != arity + 1 {
-                                let span = l.first().unwrap().atom_syntax_object().unwrap().span;
-
-                                if let Some(diagnostic) = create_diagnostic(
-                                    &self.context.rope,
-                                    &span,
-                                    format!(
-                                        "Arity mismatch: {} expects {} arguments, found {}",
-                                        l.first().unwrap(),
-                                        arity,
-                                        l.args.len() - 1
-                                    ),
-                                ) {
-                                    self.diagnostics.push(diagnostic);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        for arg in &l.args {
-            self.visit(arg);
-        }
-    }
-}
-
-// Produces LSP compatible diagnostic
-pub trait DiagnosticGenerator {
-    fn diagnose(&mut self, context: &mut DiagnosticContext) -> Vec<Diagnostic>;
-}
-
-// Attempt to bind the contracted values, if possible
-define_symbols! {
-    BIND_C => "bind/c",
-    PRIM_BIND_C => "mangler#%private/steel/contract__%#__bind/c",
-    MAKE_FUNCTION_C => "make-function/c",
-    PRIM_MAKE_FUNCTION_C => "mangler#%private/steel/contract__%#__make-function/c",
-    MAKE_C => "make/c",
-    PRIM_MAKE_C => "mangler#%private/steel/contract__%#__make/c",
-    LIST_OF => "listof",
-    PRIM_LIST_OF => "mangler#%private/steel/contract__%#__listof",
-}
-
-define_primitive_symbols! {
-    (PRIM_INTP, INTP) => "int?",
-    (PRIM_INTEGERP, INTEGERP) => "integer?",
-    (PRIM_STRINGP, STRINGP) => "string?",
-}
-
-fn is_bind_c(ident: &InternedString) -> bool {
-    *ident == *BIND_C || *ident == *PRIM_BIND_C
-}
-
-fn is_make_function_c(ident: &InternedString) -> bool {
-    *ident == *MAKE_FUNCTION_C || *ident == *PRIM_MAKE_FUNCTION_C
-}
-
-fn is_make_c(ident: &InternedString) -> bool {
-    *ident == *MAKE_C || *ident == *PRIM_MAKE_C
-}
-
-fn is_list_of(ident: &InternedString) -> bool {
-    *ident == *LIST_OF || *ident == *PRIM_LIST_OF
-}
-
-// Is this expression referring to a contract (is this a bind/c instance)
-fn is_contract(expr: &ExprKind) -> bool {
-    fn is_contract_option(expr: &ExprKind) -> Option<bool> {
-        expr.list()?.first_ident().map(is_bind_c)
-    }
-
-    if let Some(inner) = is_contract_option(expr) {
-        inner
-    } else {
-        false
-    }
-}
-
-#[derive(Debug, PartialEq, PartialOrd)]
-pub enum BaseTypeKind {
-    Any,
-    Int,
-    String,
-    Float,
-    Boolean,
-    Character,
-    Symbol,
-    Void,
-    Other(InternedString),
-}
-
-impl BaseTypeKind {
-    // TODO -> don't have this just refer directly to unknown
-    fn to_type_info(&self) -> TypeInfo {
-        match self {
-            BaseTypeKind::Any => TypeInfo::Any,
-            BaseTypeKind::Int => TypeInfo::Int,
-            BaseTypeKind::String => TypeInfo::String,
-            BaseTypeKind::Float => TypeInfo::Float,
-            BaseTypeKind::Boolean => TypeInfo::Boolean,
-            BaseTypeKind::Character => TypeInfo::Char,
-            BaseTypeKind::Void => TypeInfo::Void,
-            BaseTypeKind::Symbol => TypeInfo::Symbol,
-            BaseTypeKind::Other(_) => TypeInfo::Unknown,
-        }
-    }
-
-    fn from_str(input: InternedString) -> BaseTypeKind {
-        match input {
-            input
-                if input == *INTP
-                    || input == *INTEGERP
-                    || input == *PRIM_INTP
-                    || input == *PRIM_INTEGERP =>
-            {
-                BaseTypeKind::Int
-            }
-
-            input if input == *PRIM_STRINGP || input == *STRINGP => BaseTypeKind::String,
-            _ => BaseTypeKind::Other(input),
-        }
-    }
-}
-
-#[derive(Debug, PartialEq, PartialOrd)]
-pub enum StaticContract {
-    Atom(BaseTypeKind),
-    ListOf(Box<StaticContract>),
-    UnionOf(Vec<StaticContract>),
-    IntersectionOf(Vec<StaticContract>),
-    Function(Vec<StaticContract>, Box<StaticContract>),
-    // For now just unify the internal representation of built ins vs not
-    AnyArityFunction(Box<StaticContract>, Box<StaticContract>),
-}
-
-// Is this bind/c instance referring to a make-function/c instance
-fn function_contract(expr: &ExprKind) -> Option<steel::rvals::Result<StaticContract>> {
-    let body = expr.list()?;
-
-    if is_bind_c(body.first_ident()?) {
-        let make_function = body.get(1)?;
-
-        if is_make_function_c(make_function.list()?.first_ident()?) {
-            // This just deconstructs the (bind/c into a individual struct for access)
-            // return Some(BindContract::new(make_function, body.get(2)?));
-
-            return Some(StaticContract::from_exprkind(make_function));
-        }
-    }
-
-    None
-}
-
-#[derive(Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
-pub enum TypeInfo {
-    // We don't have enough information to say what this type is
-    // Either, the function has come externally or it was unable to be inferred for some reason
-    Unknown,
-    Any,
-    Void,
-    Int,
-    Float,
-    Boolean,
-    Char,
-    String,
-    Symbol,
-    ListOf(Box<TypeInfo>),
-    // Basic function usage, this has some fixed number of arguments with contracts attached
-    FixedArityFunction(Vec<TypeInfo>, Box<TypeInfo>),
-    // This is something like addition, which has a contract with any arity in the preconditions
-    AnyArityFunction(Box<TypeInfo>, Box<TypeInfo>),
-
-    // Function where the input type directly creates the output type in some fashion
-    DependentFunction(fn(Vec<TypeInfo>) -> TypeInfo),
-
-    // If a function can return multiple things, or the return value can satisfy multiple contracts (or/c)
-    UnionOf(BTreeSet<TypeInfo>),
-    // If the return value of a function must satisfy multiple contracts (and/c)
-    IntersectionOf(BTreeSet<TypeInfo>),
-}
-
-impl StaticContract {
-    fn to_type_info(&self) -> TypeInfo {
-        match self {
-            StaticContract::Atom(a) => a.to_type_info(),
-            StaticContract::ListOf(l) => TypeInfo::ListOf(Box::new(l.to_type_info())),
-            StaticContract::Function(pre, post) => TypeInfo::FixedArityFunction(
-                pre.iter().map(|x| x.to_type_info()).collect(),
-                Box::new(post.to_type_info()),
-            ),
-            StaticContract::AnyArityFunction(pre, post) => TypeInfo::AnyArityFunction(
-                Box::new(pre.to_type_info()),
-                Box::new(post.to_type_info()),
-            ),
-            StaticContract::UnionOf(u) => {
-                TypeInfo::UnionOf(u.iter().map(|x| x.to_type_info()).collect())
-            }
-            StaticContract::IntersectionOf(u) => {
-                TypeInfo::IntersectionOf(u.iter().map(|x| x.to_type_info()).collect())
-            }
-        }
-    }
-
-    fn from_exprkind(expr: &ExprKind) -> steel::rvals::Result<StaticContract> {
-        match expr {
-            ExprKind::Atom(a) => {
-                let name = BaseTypeKind::from_str(*a.ident().unwrap()); // TODO -> clean up this error handling
-
-                Ok(StaticContract::Atom(name))
-            }
-            ExprKind::List(l) => match l.first_ident() {
-                Some(x) if is_list_of(x) => {
-                    let body = l.get(1).unwrap();
-
-                    Ok(StaticContract::ListOf(Box::new(Self::from_exprkind(body)?)))
-                }
-                Some(x) if is_make_c(x) => {
-                    // Just recur on the actual contract here
-                    Self::from_exprkind(l.get(1).unwrap())
-                }
-                Some(x) if is_make_function_c(x) => {
-                    // Pre conditions of the function contract
-                    let pre_conditions = &l.args[1..l.args.len() - 1];
-                    // Post condition of the function contract
-                    let post_condition = &l.args[l.args.len() - 1];
-
-                    let pre_condition_contracts = pre_conditions
-                        .iter()
-                        .map(Self::from_exprkind)
-                        .collect::<steel::rvals::Result<Vec<_>>>()?;
-
-                    let post_condition_contract = Self::from_exprkind(post_condition)?;
-
-                    Ok(StaticContract::Function(
-                        pre_condition_contracts,
-                        Box::new(post_condition_contract),
-                    ))
-                }
-                _ => {
-                    println!("{expr}");
-                    stop!(Generic => "Unexpected contract combinator")
-                }
-            },
-            _ => {
-                stop!(BadSyntax => "contracts can either be atoms or lists")
-            }
-        }
-    }
-}
-
-#[derive(Default, Debug)]
-pub struct GlobalContractCollector {
-    contracts: HashMap<InternedString, StaticContract>,
-    syntax_id_to_string: HashMap<SyntaxObjectId, InternedString>,
-}
-
-impl<'a> VisitorMutUnitRef<'a> for GlobalContractCollector {
-    fn visit_define(&mut self, define: &'a Define) {
-        if let Some(contract) = function_contract(&define.body) {
-            let atom_identifier = define.name.atom_syntax_object().unwrap();
-
-            let name = define.name.atom_identifier().unwrap();
-            let syntax_object_id = atom_identifier.syntax_object_id;
-
-            // If we try to collect contracts on something thats not expanded, we'll have problems anyway
-            self.contracts.insert(*name, contract.unwrap());
-
-            self.syntax_id_to_string.insert(syntax_object_id, *name);
-        }
-    }
-
-    fn visit_set(&mut self, s: &'a steel::parser::ast::Set) {
-        if let Some(contract) = function_contract(&s.expr) {
-            let atom_identifier = s.variable.atom_syntax_object().unwrap();
-            let name = s.variable.atom_identifier().unwrap();
-            let syntax_object_id = atom_identifier.syntax_object_id;
-
-            // If we try to collect contracts on something thats not expanded, we'll have problems anyway
-            self.contracts.insert(*name, contract.unwrap());
-
-            self.syntax_id_to_string.insert(syntax_object_id, *name);
-        }
-    }
-}
-
-#[test]
-fn resolve_contracts() {
-    let expression = r#"
-(define/contract (my-fun-contracted-function x y)
-  (->/c int? int? int?)
-  (+ x y))        
-    "#;
-
-    let mut engine = Engine::new();
-
-    let exprs = engine
-        .emit_expanded_ast_without_optimizations(expression, None)
-        .unwrap();
-
-    let mut collector = GlobalContractCollector {
-        contracts: HashMap::default(),
-        syntax_id_to_string: HashMap::default(),
-    };
-
-    for expr in &exprs {
-        collector.visit(expr);
-    }
-
-    println!("{:#?}", collector.contracts);
-
-    // Now analyze the resulting AST, and build the map
-}
diff --git a/crates/steel-language-server/src/lib.rs b/crates/steel-language-server/src/lib.rs
deleted file mode 100644
index 1c19d67db..000000000
--- a/crates/steel-language-server/src/lib.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-pub mod backend;
-mod client;
-mod configuration;
-mod contract;
-mod diagnostics;
diff --git a/crates/steel-language-server/src/main.rs b/crates/steel-language-server/src/main.rs
deleted file mode 100644
index b691b4315..000000000
--- a/crates/steel-language-server/src/main.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-use std::{path::PathBuf, sync::Arc};
-
-use dashmap::{DashMap, DashSet};
-
-use steel::{
-    parser::interner::InternedString,
-    steel_vm::{engine::Engine, register_fn::RegisterFn},
-};
-use steel_language_server::backend::{Backend, ExternalModuleResolver, ENGINE};
-
-use tower_lsp::{LspService, Server};
-
-#[tokio::main]
-async fn main() {
-    env_logger::init();
-
-    let stdin = tokio::io::stdin();
-    let stdout = tokio::io::stdout();
-
-    // Use this to resolve the module configuration files
-    let mut resolver_engine = Engine::new();
-
-    let globals_set = Arc::new(DashSet::new());
-
-    globals_set.insert("#%ignore-unused-identifier".into());
-    globals_set.insert("#%register-global".into());
-
-    let cloned_set = globals_set.clone();
-    resolver_engine.register_fn("#%register-global", move |global: String| {
-        cloned_set.insert(InternedString::from(global))
-    });
-
-    let ignore_unused_set = Arc::new(DashSet::new());
-    let cloned_ignore_set = ignore_unused_set.clone();
-    resolver_engine.register_fn("#%ignore-unused-identifier", move |global: String| {
-        cloned_ignore_set.insert(InternedString::from(global));
-    });
-
-    let home_directory =
-        std::env::var("STEEL_LSP_HOME").expect("Have you set your STEEL_LSP_HOME path?");
-
-    ENGINE.with_borrow_mut(|x| {
-        x.register_module_resolver(
-            ExternalModuleResolver::new(&mut resolver_engine, PathBuf::from(home_directory))
-                .unwrap(),
-        )
-    });
-
-    let defined_globals = DashSet::new();
-
-    ENGINE.with_borrow(|engine| {
-        for global in engine.globals() {
-            let resolved = global.resolve();
-            if !resolved.starts_with("#")
-                && !resolved.starts_with("%")
-                && !resolved.starts_with("mangler#%")
-            {
-                defined_globals.insert(resolved.to_string());
-            }
-        }
-    });
-
-    let (service, socket) = LspService::build(|client| Backend {
-        client,
-        ast_map: DashMap::new(),
-        document_map: DashMap::new(),
-        _macro_map: DashMap::new(),
-        globals_set,
-        ignore_set: ignore_unused_set,
-        defined_globals,
-    })
-    .finish();
-
-    Server::new(stdin, stdout, socket).serve(service).await;
-}
diff --git a/crates/steel-parser/Cargo.toml b/crates/steel-parser/Cargo.toml
deleted file mode 100644
index 77621dcee..000000000
--- a/crates/steel-parser/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "steel-parser"
-version = "0.4.0"
-edition = "2021"
-license = "MIT OR Apache-2.0"
-authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
-repository = "https://github.com/mattwparas/steel"
-description = "Parser for use within steel"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-serde = { version = "1.0.152", features = ["derive", "rc"] }
-serde_derive = "1.0.152"
-num-bigint = { version = "0.4.0", features = ["serde"] }
-lasso = { version = "0.7.2", features = ["multi-threaded", "serialize"] }
-once_cell = "1.18.0"
-pretty = "0.12.1"
diff --git a/crates/steel-parser/src/ast.rs b/crates/steel-parser/src/ast.rs
deleted file mode 100644
index dc3064e6f..000000000
--- a/crates/steel-parser/src/ast.rs
+++ /dev/null
@@ -1,2342 +0,0 @@
-use crate::{
-    parser::{ParseError, SyntaxObject},
-    tokens::TokenType::{self},
-};
-
-use std::{convert::TryFrom, fmt::Write, sync::atomic::Ordering};
-
-use crate::tokens::MaybeBigInt;
-use pretty::RcDoc;
-use serde::{Deserialize, Serialize};
-use std::fmt;
-use std::ops::Deref;
-
-use super::{
-    interner::InternedString,
-    parser::{SyntaxObjectId, SYNTAX_OBJECT_ID},
-    span::Span,
-};
-
-// TODO: Have this macro share the implementation crate wide
-macro_rules! define_symbols {
-    ($($name:tt => $str:expr,) * ) => {
-        $(
-            pub static $name: once_cell::sync::Lazy<InternedString> = once_cell::sync::Lazy::new(|| $str.into());
-        )*
-    };
-}
-
-define_symbols! {
-    UNREADABLE_MODULE_GET => "##__module-get",
-    STANDARD_MODULE_GET => "%module-get%",
-    PROTO_HASH_GET => "%proto-hash-get%",
-    PROVIDE => "provide",
-    DATUM_SYNTAX => "datum->syntax",
-    SYNTAX_SPAN => "#%syntax-span",
-    IF => "if",
-    DEFINE => "define",
-    LET => "let",
-    QUOTE =>"quote",
-    RETURN => "return!",
-    REQUIRE => "require",
-    SET => "set!",
-    PLAIN_LET => "%plain-let",
-    LAMBDA => "lambda",
-    LAMBDA_SYMBOL => "λ",
-    LAMBDA_FN => "fn",
-    BEGIN => "begin",
-    DOC_MACRO => "@doc",
-    REQUIRE_BUILTIN => "require-builtin",
-    REQUIRE_DYLIB => "#%require-dylib",
-    STRUCT_KEYWORD => "struct",
-    UNQUOTE => "unquote",
-    UNQUOTE_COMMA => "#%unquote-comma",
-    RAW_UNQUOTE => "#%unquote",
-    UNQUOTE_SPLICING => "unquote-splicing",
-    RAW_UNQUOTE_SPLICING => "#%unquote-splicing",
-    QUASIQUOTE => "quasiquote",
-    RAW_QUOTE => "#%quote",
-    QUASISYNTAX => "quasisyntax",
-    UNSYNTAX => "unsyntax",
-    RAW_UNSYNTAX => "#%unsyntax",
-    UNSYNTAX_SPLICING => "unsyntax-splicing",
-    RAW_UNSYNTAX_SPLICING => "#%unsyntax-splicing",
-    SYNTAX_QUOTE => "syntax",
-}
-
-pub trait AstTools {
-    fn pretty_print(&self);
-}
-
-impl AstTools for Vec<ExprKind> {
-    fn pretty_print(&self) {
-        println!("{}", self.iter().map(|x| x.to_pretty(60)).join("\n\n"))
-    }
-}
-
-impl AstTools for Vec<&ExprKind> {
-    fn pretty_print(&self) {
-        println!("{}", self.iter().map(|x| x.to_pretty(60)).join("\n\n"))
-    }
-}
-
-impl AstTools for &mut Vec<ExprKind> {
-    fn pretty_print(&self) {
-        println!("{}", self.iter().map(|x| x.to_pretty(60)).join("\n\n"))
-    }
-}
-
-pub trait IteratorExtensions: Iterator {
-    fn join(&mut self, sep: &str) -> String
-    where
-        Self::Item: std::fmt::Display,
-    {
-        match self.next() {
-            None => String::new(),
-            Some(first_elt) => {
-                // estimate lower bound of capacity needed
-                let (lower, _) = self.size_hint();
-                let mut result = String::with_capacity(sep.len() * lower);
-                write!(&mut result, "{}", first_elt).unwrap();
-                self.for_each(|elt| {
-                    result.push_str(sep);
-                    write!(&mut result, "{}", elt).unwrap();
-                });
-                result
-            }
-        }
-    }
-}
-
-impl<T> IteratorExtensions for T where T: Iterator {}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum ExprKind {
-    Atom(Atom),
-    If(Box<If>),
-    Let(Box<Let>),
-    Define(Box<Define>),
-    LambdaFunction(Box<LambdaFunction>),
-    Begin(Begin),
-    Return(Box<Return>),
-    Quote(Box<Quote>),
-    Macro(Box<Macro>),
-    SyntaxRules(Box<SyntaxRules>),
-    List(List),
-    Set(Box<Set>),
-    Require(Require),
-}
-
-#[test]
-fn check_size() {
-    println!("ExprKind: {}", std::mem::size_of::<ExprKind>());
-    println!("SyntaxRules: {}", std::mem::size_of::<SyntaxRules>());
-    println!("Macro: {}", std::mem::size_of::<Macro>());
-    println!("List: {}", std::mem::size_of::<List>());
-}
-
-#[macro_export]
-macro_rules! expr_list {
-    () => { $crate::ast::ExprKind::List($crate::ast::List::new(vec![])) };
-
-    ( $($x:expr),* ) => {{
-        $crate::ast::ExprKind::List($crate::ast::List::new(vec![$(
-            $x,
-        ) *]))
-    }};
-
-    ( $($x:expr ,)* ) => {{
-        $crate::ast::ExprKind::List($crate::ast::List::new(vec![$($x, )*]))
-    }};
-}
-
-impl ExprKind {
-    pub fn to_string_literal(&self) -> Option<&String> {
-        if let ExprKind::Atom(a) = self {
-            if let TokenType::StringLiteral(s) = &a.syn.ty {
-                Some(s)
-            } else {
-                None
-            }
-        } else {
-            None
-        }
-    }
-
-    pub fn into_lambda_function(self) -> Option<Box<LambdaFunction>> {
-        if let ExprKind::LambdaFunction(func) = self {
-            Some(func)
-        } else {
-            None
-        }
-    }
-
-    pub fn quoted_list() -> ExprKind {
-        ExprKind::Quote(Box::new(Quote::new(
-            Self::empty(),
-            SyntaxObject::default(TokenType::QuoteTick),
-        )))
-    }
-
-    pub fn empty() -> ExprKind {
-        ExprKind::List(List::new(Vec::new()))
-    }
-
-    pub fn integer_literal(value: isize, span: Span) -> ExprKind {
-        ExprKind::Atom(crate::ast::Atom::new(SyntaxObject::new(
-            TokenType::IntegerLiteral(MaybeBigInt::Small(value)),
-            span,
-        )))
-    }
-
-    pub fn atom<T: Into<InternedString>>(name: T) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            name.into(),
-        ))))
-    }
-
-    pub fn ident(name: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            name.into(),
-        ))))
-    }
-
-    pub fn string_lit(input: String) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::StringLiteral(
-            input,
-        ))))
-    }
-
-    pub fn bool_lit(b: bool) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::BooleanLiteral(
-            b,
-        ))))
-    }
-
-    pub fn default_if(test: ExprKind, then: ExprKind, els: ExprKind) -> ExprKind {
-        ExprKind::If(Box::new(If::new(
-            test,
-            then,
-            els,
-            SyntaxObject::default(TokenType::If),
-        )))
-    }
-
-    pub fn into_atom_syntax_object(self) -> Option<SyntaxObject> {
-        match self {
-            Self::Atom(Atom { syn }) => Some(syn),
-            _ => None,
-        }
-    }
-
-    pub fn atom_syntax_object(&self) -> Option<&SyntaxObject> {
-        match self {
-            Self::Atom(Atom { syn }) => Some(syn),
-            _ => None,
-        }
-    }
-
-    pub fn define_syntax_ident(&self) -> bool {
-        match self {
-            Self::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::DefineSyntax,
-                        ..
-                    },
-            }) => true,
-            _ => false,
-        }
-    }
-
-    pub fn atom_identifier_mut(&mut self) -> Option<&mut InternedString> {
-        match self {
-            Self::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::Identifier(s),
-                        ..
-                    },
-            }) => Some(s),
-            _ => None,
-        }
-    }
-
-    pub fn lambda_function(&self) -> Option<&LambdaFunction> {
-        match self {
-            Self::LambdaFunction(l) => Some(l),
-            _ => None,
-        }
-    }
-
-    pub fn atom_identifier_or_else<E, F: FnOnce() -> E>(
-        &self,
-        err: F,
-    ) -> std::result::Result<&InternedString, E> {
-        match self {
-            Self::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::Identifier(s),
-                        ..
-                    },
-            }) => Ok(s),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn atom_identifier(&self) -> Option<&InternedString> {
-        match self {
-            Self::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::Identifier(s),
-                        ..
-                    },
-            }) => Some(s),
-            _ => None,
-        }
-    }
-
-    pub fn string_literal(&self) -> Option<&str> {
-        match self {
-            Self::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::StringLiteral(s),
-                        ..
-                    },
-            }) => Some(s),
-            _ => None,
-        }
-    }
-
-    pub fn list(&self) -> Option<&List> {
-        if let ExprKind::List(l) = self {
-            Some(l)
-        } else {
-            None
-        }
-    }
-
-    pub fn list_or_else<E, F: FnOnce() -> E>(&self, err: F) -> std::result::Result<&List, E> {
-        match self {
-            Self::List(l) => Ok(l),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn list_mut_or_else<E, F: FnOnce() -> E>(
-        &mut self,
-        err: F,
-    ) -> std::result::Result<&mut List, E> {
-        match self {
-            Self::List(l) => Ok(l),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn into_list_or_else<E, F: FnOnce() -> E>(self, err: F) -> std::result::Result<List, E> {
-        match self {
-            Self::List(l) => Ok(l),
-            _ => Err(err()),
-        }
-    }
-
-    pub fn into_list(self) -> List {
-        if let ExprKind::List(l) = self {
-            l
-        } else {
-            panic!("Attempted to coerce a non list to a list");
-        }
-    }
-
-    pub fn unwrap_function(self) -> Option<Box<LambdaFunction>> {
-        if let ExprKind::LambdaFunction(l) = self {
-            Some(l)
-        } else {
-            None
-        }
-    }
-
-    pub fn get_list(&self) -> Option<&List> {
-        if let ExprKind::List(l) = self {
-            Some(l)
-        } else {
-            None
-        }
-    }
-
-    pub fn update_string_in_atom(&mut self, ident: InternedString) {
-        if let ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::Identifier(ref mut s),
-                    ..
-                },
-        }) = self
-        {
-            *s = ident;
-        }
-    }
-}
-
-pub trait ToDoc {
-    fn to_doc(&self) -> RcDoc<()>;
-}
-
-impl ToDoc for ExprKind {
-    fn to_doc(&self) -> RcDoc<()> {
-        match self {
-            ExprKind::Atom(a) => a.to_doc(),
-            ExprKind::If(i) => i.to_doc(),
-            ExprKind::Define(d) => d.to_doc(),
-            ExprKind::LambdaFunction(l) => l.to_doc(),
-            ExprKind::Begin(b) => b.to_doc(),
-            ExprKind::Return(r) => r.to_doc(),
-            ExprKind::Let(l) => l.to_doc(),
-            ExprKind::Quote(q) => q.to_doc(),
-            ExprKind::Macro(m) => m.to_doc(),
-            ExprKind::SyntaxRules(s) => s.to_doc(),
-            ExprKind::List(l) => l.to_doc(),
-            ExprKind::Set(s) => s.to_doc(),
-            ExprKind::Require(r) => r.to_doc(),
-        }
-    }
-}
-
-impl ExprKind {
-    pub fn to_pretty(&self, width: usize) -> String {
-        let mut w = Vec::new();
-        self.to_doc().render(width, &mut w).unwrap();
-        String::from_utf8(w).unwrap()
-    }
-}
-
-impl fmt::Display for ExprKind {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            ExprKind::Atom(a) => write!(f, "{a}"),
-            ExprKind::If(i) => write!(f, "{i}"),
-            ExprKind::Define(d) => write!(f, "{d}"),
-            ExprKind::LambdaFunction(l) => write!(f, "{l}"),
-            ExprKind::Begin(b) => write!(f, "{b}"),
-            ExprKind::Return(r) => write!(f, "{r}"),
-            ExprKind::Let(l) => write!(f, "{l}"),
-            ExprKind::Quote(q) => write!(f, "{q}"),
-            ExprKind::Macro(m) => write!(f, "{m}"),
-            ExprKind::SyntaxRules(s) => write!(f, "{s}"),
-            ExprKind::List(l) => write!(f, "{l}"),
-            ExprKind::Set(s) => write!(f, "{s}"),
-            ExprKind::Require(r) => write!(f, "{r}"),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Atom {
-    pub syn: SyntaxObject,
-}
-
-impl Atom {
-    pub fn new(syn: SyntaxObject) -> Self {
-        Atom { syn }
-    }
-
-    pub fn ident(&self) -> Option<&InternedString> {
-        if let TokenType::Identifier(ref ident) = self.syn.ty {
-            Some(ident)
-        } else {
-            None
-        }
-    }
-
-    pub fn ident_mut(&mut self) -> Option<&mut InternedString> {
-        if let TokenType::Identifier(ref mut ident) = self.syn.ty {
-            Some(ident)
-        } else {
-            None
-        }
-    }
-}
-
-impl fmt::Display for Atom {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.syn.ty)
-    }
-}
-
-impl ToDoc for Atom {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text(self.syn.ty.to_string())
-    }
-}
-
-impl From<Atom> for ExprKind {
-    fn from(val: Atom) -> Self {
-        ExprKind::Atom(val)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Let {
-    pub bindings: Vec<(ExprKind, ExprKind)>,
-    pub body_expr: ExprKind,
-    pub location: SyntaxObject,
-    pub syntax_object_id: usize,
-}
-
-impl Let {
-    pub fn new(
-        bindings: Vec<(ExprKind, ExprKind)>,
-        body_expr: ExprKind,
-        location: SyntaxObject,
-    ) -> Self {
-        Let {
-            bindings,
-            body_expr,
-            location,
-            syntax_object_id: SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed),
-        }
-    }
-
-    pub fn local_bindings(&self) -> impl Iterator<Item = &'_ ExprKind> {
-        self.bindings.iter().map(|x| &x.0)
-    }
-
-    pub fn expression_arguments(&self) -> impl Iterator<Item = &'_ ExprKind> {
-        self.bindings.iter().map(|x| &x.1)
-    }
-}
-
-impl fmt::Display for Let {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "(%plain-let ({}) {})",
-            self.bindings
-                .iter()
-                .map(|x| format!("({} {})", x.0, x.1))
-                .join(" "),
-            self.body_expr
-        )
-    }
-}
-
-impl ToDoc for Let {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(%plain-let")
-            .append(RcDoc::space())
-            .append(RcDoc::text("("))
-            .append(
-                RcDoc::intersperse(
-                    self.bindings.iter().map(|x| {
-                        RcDoc::text("(")
-                            .append(x.0.to_doc())
-                            .append(RcDoc::space())
-                            .append(x.1.to_doc())
-                            .append(RcDoc::text(")"))
-                    }),
-                    RcDoc::line(),
-                )
-                .nest(2)
-                .group(),
-            )
-            .append(RcDoc::text(")"))
-            .append(RcDoc::line())
-            .append(self.body_expr.to_doc())
-            .append(RcDoc::text(")"))
-            .nest(2)
-    }
-}
-
-impl From<Let> for ExprKind {
-    fn from(val: Let) -> Self {
-        ExprKind::Let(Box::new(val))
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Set {
-    pub variable: ExprKind,
-    pub expr: ExprKind,
-    pub location: SyntaxObject,
-}
-
-impl Set {
-    pub fn new(variable: ExprKind, expr: ExprKind, location: SyntaxObject) -> Self {
-        Set {
-            variable,
-            expr,
-            location,
-        }
-    }
-}
-
-impl fmt::Display for Set {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(set! {} {})", self.variable, self.expr)
-    }
-}
-
-impl ToDoc for Set {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(set!")
-            .append(RcDoc::space())
-            .append(self.variable.to_doc())
-            .append(RcDoc::line())
-            .append(self.expr.to_doc())
-            .append(RcDoc::text(")"))
-            .nest(2)
-            .group()
-    }
-}
-
-impl From<Set> for ExprKind {
-    fn from(val: Set) -> Self {
-        ExprKind::Set(Box::new(val))
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct If {
-    pub test_expr: ExprKind,
-    pub then_expr: ExprKind,
-    pub else_expr: ExprKind,
-    pub location: SyntaxObject,
-}
-
-impl ToDoc for If {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(if")
-            .append(RcDoc::space())
-            .append(self.test_expr.to_doc())
-            .append(RcDoc::line())
-            .append(self.then_expr.to_doc())
-            .append(RcDoc::line())
-            .append(self.else_expr.to_doc())
-            .append(RcDoc::text(")"))
-            .nest(2)
-            .group()
-    }
-}
-
-impl fmt::Display for If {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "(if {} {} {})",
-            self.test_expr, self.then_expr, self.else_expr
-        )
-    }
-}
-
-impl If {
-    pub fn new(
-        test_expr: ExprKind,
-        then_expr: ExprKind,
-        else_expr: ExprKind,
-        location: SyntaxObject,
-    ) -> Self {
-        If {
-            test_expr,
-            then_expr,
-            else_expr,
-            location,
-        }
-    }
-}
-
-impl From<If> for ExprKind {
-    fn from(val: If) -> Self {
-        ExprKind::If(Box::new(val))
-    }
-}
-
-// Define normal
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Define {
-    // This could either be name + args
-    pub name: ExprKind,
-    pub body: ExprKind,
-    pub location: SyntaxObject,
-}
-
-impl fmt::Display for Define {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(define {} {})", self.name, self.body)
-    }
-}
-
-impl ToDoc for Define {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(define")
-            .append(RcDoc::space())
-            .append(self.name.to_doc())
-            .append(RcDoc::line())
-            .append(self.body.to_doc())
-            .append(RcDoc::text(")"))
-            .nest(2)
-    }
-}
-
-impl Define {
-    pub fn new(name: ExprKind, body: ExprKind, location: SyntaxObject) -> Self {
-        Define {
-            name,
-            body,
-            location,
-        }
-    }
-
-    pub fn is_an_alias_definition(&self) -> Option<SyntaxObjectId> {
-        if let Some(atom) = self.body.atom_syntax_object() {
-            if let TokenType::Identifier(_) = atom.ty {
-                return Some(atom.syntax_object_id);
-            }
-        }
-
-        None
-    }
-
-    pub fn name_id(&self) -> Option<SyntaxObjectId> {
-        self.name.atom_syntax_object().map(|x| x.syntax_object_id)
-    }
-}
-
-impl From<Define> for ExprKind {
-    fn from(val: Define) -> Self {
-        ExprKind::Define(Box::new(val))
-    }
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct LambdaFunction {
-    pub args: Vec<ExprKind>,
-    pub body: ExprKind,
-    pub location: SyntaxObject,
-    pub rest: bool,
-    pub syntax_object_id: usize,
-}
-
-impl Clone for LambdaFunction {
-    fn clone(&self) -> Self {
-        Self {
-            args: self.args.clone(),
-            body: self.body.clone(),
-            location: self.location.clone(),
-            rest: self.rest,
-            syntax_object_id: SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed),
-        }
-    }
-}
-
-impl PartialEq for LambdaFunction {
-    fn eq(&self, other: &Self) -> bool {
-        self.args == other.args
-            && self.body == other.body
-            && self.location == other.location
-            && self.rest == other.rest
-    }
-}
-
-impl fmt::Display for LambdaFunction {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "(lambda ({}) {})",
-            self.args.iter().map(|x| x.to_string()).join(" "),
-            self.body
-        )
-    }
-}
-
-impl ToDoc for LambdaFunction {
-    fn to_doc(&self) -> RcDoc<()> {
-        if self.rest && self.args.len() == 1 {
-            RcDoc::text("(λ")
-                .append(RcDoc::space())
-                .append(self.args.first().unwrap().to_doc())
-                .append(RcDoc::line())
-                .append(self.body.to_doc())
-                .append(RcDoc::text(")"))
-                .nest(2)
-        } else {
-            RcDoc::text("(λ")
-                .append(RcDoc::space())
-                .append(RcDoc::text("("))
-                .append(
-                    RcDoc::intersperse(self.args.iter().map(|x| x.to_doc()), RcDoc::line())
-                        .nest(2)
-                        .group(),
-                )
-                .append(RcDoc::text(")"))
-                .append(RcDoc::line())
-                .append(self.body.to_doc())
-                .append(RcDoc::text(")"))
-                .nest(2)
-        }
-    }
-}
-
-impl LambdaFunction {
-    pub fn new(args: Vec<ExprKind>, body: ExprKind, location: SyntaxObject) -> Self {
-        LambdaFunction {
-            args,
-            body,
-            location,
-            rest: false,
-            syntax_object_id: SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed),
-        }
-    }
-
-    pub fn new_with_rest_arg(args: Vec<ExprKind>, body: ExprKind, location: SyntaxObject) -> Self {
-        LambdaFunction {
-            args,
-            body,
-            location,
-            rest: true,
-            syntax_object_id: SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed),
-        }
-    }
-
-    pub fn new_maybe_rest(
-        args: Vec<ExprKind>,
-        body: ExprKind,
-        location: SyntaxObject,
-        rest: bool,
-    ) -> Self {
-        LambdaFunction {
-            args,
-            body,
-            location,
-            rest,
-            syntax_object_id: SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed),
-        }
-    }
-
-    pub fn arguments(&self) -> Option<Vec<&InternedString>> {
-        self.args.iter().map(|x| x.atom_identifier()).collect()
-    }
-
-    pub fn arguments_mut(&mut self) -> impl Iterator<Item = &mut InternedString> {
-        self.args.iter_mut().filter_map(|x| x.atom_identifier_mut())
-    }
-}
-
-impl From<LambdaFunction> for ExprKind {
-    fn from(val: LambdaFunction) -> Self {
-        ExprKind::LambdaFunction(Box::new(val))
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Begin {
-    pub exprs: Vec<ExprKind>,
-    pub location: SyntaxObject,
-}
-
-impl fmt::Display for Begin {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(begin {})", self.exprs.iter().join(" "))
-    }
-}
-
-impl ToDoc for Begin {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(begin")
-            .append(RcDoc::line())
-            .nest(5)
-            .append(
-                RcDoc::intersperse(self.exprs.iter().map(|x| x.to_doc()), RcDoc::line())
-                    .nest(5)
-                    .group(),
-            )
-            .append(RcDoc::text(")"))
-            .nest(1)
-            .group()
-    }
-}
-
-impl Begin {
-    pub fn new(exprs: Vec<ExprKind>, location: SyntaxObject) -> Self {
-        Begin { exprs, location }
-    }
-}
-
-impl From<Begin> for ExprKind {
-    fn from(val: Begin) -> Self {
-        ExprKind::Begin(val)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Return {
-    pub expr: ExprKind,
-    pub location: SyntaxObject,
-}
-
-impl Return {
-    pub fn new(expr: ExprKind, location: SyntaxObject) -> Self {
-        Return { expr, location }
-    }
-}
-
-impl ToDoc for Return {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(return")
-            .append(RcDoc::line())
-            .append(self.expr.to_doc())
-            .append(RcDoc::text(")"))
-            .nest(2)
-    }
-}
-
-impl fmt::Display for Return {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(return! {})", self.expr)
-    }
-}
-
-impl From<Return> for ExprKind {
-    fn from(val: Return) -> Self {
-        ExprKind::Return(Box::new(val))
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Require {
-    pub modules: Vec<ExprKind>,
-    pub location: SyntaxObject,
-}
-
-impl Require {
-    pub fn new(modules: Vec<ExprKind>, location: SyntaxObject) -> Self {
-        Require { modules, location }
-    }
-}
-
-impl ToDoc for Require {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(require")
-            .append(RcDoc::line())
-            .append(
-                RcDoc::intersperse(self.modules.iter().map(|x| x.to_doc()), RcDoc::line())
-                    .nest(2)
-                    .group(),
-            )
-            .append(RcDoc::text(")"))
-            .nest(2)
-    }
-}
-
-impl fmt::Display for Require {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(require {})", self.modules.iter().join(" "))
-    }
-}
-
-impl From<Require> for ExprKind {
-    fn from(val: Require) -> Self {
-        ExprKind::Require(val)
-    }
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct List {
-    pub args: Vec<ExprKind>,
-    pub syntax_object_id: usize,
-    pub improper: bool,
-    // TODO: Attach the span from the parser - just the offset
-    // of the open and close parens
-    pub location: Option<Span>,
-}
-
-impl PartialEq for List {
-    fn eq(&self, other: &Self) -> bool {
-        self.args == other.args
-    }
-}
-
-impl List {
-    pub fn new(args: Vec<ExprKind>) -> Self {
-        List {
-            args,
-            syntax_object_id: SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed),
-            improper: false,
-            location: None,
-        }
-    }
-
-    pub fn with_span(mut self, location: Span) -> Self {
-        self.location = Some(location);
-        self
-    }
-
-    pub fn make_improper(mut self) -> Self {
-        self.improper = true;
-        self
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.args.is_empty()
-    }
-
-    pub fn rest_mut(&mut self) -> Option<&mut [ExprKind]> {
-        self.args.split_first_mut().map(|x| x.1)
-    }
-
-    pub fn first_ident_mut(&mut self) -> Option<&mut InternedString> {
-        if let Some(ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::Identifier(s),
-                    ..
-                },
-        })) = self.args.first_mut()
-        {
-            Some(s)
-        } else {
-            None
-        }
-    }
-
-    pub fn is_require(&self) -> bool {
-        if let Some(ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::Require,
-                    ..
-                },
-        })) = self.args.first()
-        {
-            true
-        } else {
-            false
-        }
-    }
-
-    pub fn is_define_syntax(&self) -> bool {
-        if let Some(ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::DefineSyntax,
-                    ..
-                },
-        })) = self.args.first()
-        {
-            self.args.len() == 3
-        } else {
-            false
-        }
-    }
-
-    pub fn is_syntax_rules(&self) -> bool {
-        if let Some(ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::SyntaxRules,
-                    ..
-                },
-        })) = self.args.first()
-        {
-            self.args.len() > 2
-        } else {
-            false
-        }
-    }
-
-    pub fn is_quote(&self) -> bool {
-        if let Some(ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::Quote,
-                    ..
-                },
-        })) = self.args.first()
-        {
-            true
-        } else {
-            false
-        }
-    }
-
-    pub fn first_ident(&self) -> Option<&InternedString> {
-        if let Some(ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::Identifier(s),
-                    ..
-                },
-        })) = self.args.first()
-        {
-            Some(s)
-        } else {
-            None
-        }
-    }
-
-    pub fn second_ident(&self) -> Option<&InternedString> {
-        if let Some(ExprKind::Atom(Atom {
-            syn:
-                SyntaxObject {
-                    ty: TokenType::Identifier(s),
-                    ..
-                },
-        })) = self.args.get(1)
-        {
-            Some(s)
-        } else {
-            None
-        }
-    }
-
-    pub fn is_anonymous_function_call(&self) -> bool {
-        matches!(self.args.get(0), Some(ExprKind::LambdaFunction(_)))
-    }
-
-    pub fn is_a_builtin_expr(&self) -> bool {
-        matches!(self.first_ident(), Some(func) if *func == *UNREADABLE_MODULE_GET || *func == *STANDARD_MODULE_GET)
-    }
-
-    pub fn first_func_mut(&mut self) -> Option<&mut LambdaFunction> {
-        if let Some(ExprKind::LambdaFunction(l)) = self.args.get_mut(0) {
-            Some(l)
-        } else {
-            None
-        }
-    }
-
-    pub fn first_func(&self) -> Option<&LambdaFunction> {
-        if let Some(ExprKind::LambdaFunction(l)) = self.args.get(0) {
-            Some(l)
-        } else {
-            None
-        }
-    }
-}
-
-impl ToDoc for List {
-    fn to_doc(&self) -> RcDoc<()> {
-        if let Some(func) = self.first_func() {
-            let mut args_iter = self.args.iter();
-            args_iter.next();
-
-            let bindings = func.args.iter().zip(args_iter);
-
-            RcDoc::text("(let")
-                .append(RcDoc::space())
-                .append(RcDoc::text("("))
-                .append(
-                    RcDoc::intersperse(
-                        bindings.map(|x| {
-                            RcDoc::text("(")
-                                .append(x.0.to_doc())
-                                .append(RcDoc::space())
-                                .append(x.1.to_doc())
-                                .append(RcDoc::text(")"))
-                        }),
-                        RcDoc::line(),
-                    )
-                    .nest(2)
-                    .group(),
-                )
-                .append(RcDoc::text(")"))
-                .append(RcDoc::line())
-                .append(func.body.to_doc())
-                .append(RcDoc::text(")"))
-                .nest(2)
-        } else {
-            RcDoc::text("(")
-                .append(
-                    RcDoc::intersperse(self.args.iter().map(|x| x.to_doc()), RcDoc::line())
-                        .nest(1)
-                        .group(),
-                )
-                .append(RcDoc::text(")"))
-                .nest(2)
-                .group()
-        }
-    }
-}
-
-impl fmt::Display for List {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "({})", self.args.iter().join(" "))
-    }
-}
-
-impl From<List> for ExprKind {
-    fn from(val: List) -> Self {
-        ExprKind::List(val)
-    }
-}
-
-impl Deref for List {
-    type Target = [ExprKind];
-
-    fn deref(&self) -> &[ExprKind] {
-        &self.args
-    }
-}
-
-// and we'll implement IntoIterator
-impl IntoIterator for List {
-    type Item = ExprKind;
-    type IntoIter = std::vec::IntoIter<Self::Item>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.args.into_iter()
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Quote {
-    pub expr: ExprKind,
-    pub location: SyntaxObject,
-}
-
-impl Quote {
-    pub fn new(expr: ExprKind, location: SyntaxObject) -> Self {
-        Quote { expr, location }
-    }
-}
-
-impl ToDoc for Quote {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(quote")
-            .append(RcDoc::line())
-            .append(self.expr.to_doc())
-            .append(RcDoc::text(")"))
-            .nest(2)
-    }
-}
-
-impl fmt::Display for Quote {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(quote {})", self.expr)
-    }
-}
-
-impl From<Quote> for ExprKind {
-    fn from(val: Quote) -> Self {
-        ExprKind::Quote(Box::new(val))
-    }
-}
-
-// TODO figure out how many fields a macro has
-// put it into here nicely
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct Macro {
-    pub name: Box<ExprKind>,
-    pub syntax_rules: Box<SyntaxRules>,
-    pub location: SyntaxObject,
-}
-
-impl fmt::Display for Macro {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "(define-syntax {} {})", self.name, self.syntax_rules)
-    }
-}
-
-impl ToDoc for Macro {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(define-syntax")
-            .append(RcDoc::line())
-            .append(self.name.to_doc())
-            .append(RcDoc::line())
-            .append(self.syntax_rules.to_doc())
-            .append(RcDoc::text(")"))
-            .nest(1)
-            .group()
-    }
-}
-
-impl Macro {
-    pub fn new(name: ExprKind, syntax_rules: Box<SyntaxRules>, location: SyntaxObject) -> Self {
-        Macro {
-            name: Box::new(name),
-            syntax_rules,
-            location,
-        }
-    }
-}
-
-impl From<Macro> for ExprKind {
-    fn from(val: Macro) -> Self {
-        ExprKind::Macro(Box::new(val))
-    }
-}
-
-// TODO figure out a good mapping immediately to a macro that can be interpreted
-// by the expander
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct SyntaxRules {
-    pub syntax: Vec<ExprKind>,
-    pub patterns: Vec<PatternPair>,
-    pub location: SyntaxObject,
-}
-
-impl SyntaxRules {
-    pub fn new(syntax: Vec<ExprKind>, patterns: Vec<PatternPair>, location: SyntaxObject) -> Self {
-        SyntaxRules {
-            syntax,
-            patterns,
-            location,
-        }
-    }
-}
-
-impl fmt::Display for SyntaxRules {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "(syntax-rules ({}) {})",
-            self.syntax.iter().map(|x| x.to_string()).join(" "),
-            self.patterns.iter().map(|x| x.to_string()).join("\n")
-        )
-    }
-}
-
-impl ToDoc for SyntaxRules {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("(syntax-rules")
-            .append(RcDoc::line())
-            .append(RcDoc::text("("))
-            .append(
-                RcDoc::intersperse(self.syntax.iter().map(|x| x.to_doc()), RcDoc::line())
-                    .nest(1)
-                    .group(),
-            )
-            .append(RcDoc::text(")"))
-            .append(RcDoc::line())
-            .append(
-                RcDoc::intersperse(self.patterns.iter().map(|x| x.to_doc()), RcDoc::line())
-                    .nest(2)
-                    .group(),
-            )
-            .append(RcDoc::text(")"))
-            .nest(2)
-    }
-}
-
-impl From<SyntaxRules> for ExprKind {
-    fn from(val: SyntaxRules) -> Self {
-        ExprKind::SyntaxRules(Box::new(val))
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub struct PatternPair {
-    pub pattern: ExprKind,
-    pub body: ExprKind,
-}
-
-impl PatternPair {
-    pub fn new(pattern: ExprKind, body: ExprKind) -> Self {
-        PatternPair { pattern, body }
-    }
-}
-
-impl ToDoc for PatternPair {
-    fn to_doc(&self) -> RcDoc<()> {
-        RcDoc::text("[")
-            .append(self.pattern.to_doc())
-            .append(RcDoc::line())
-            .append(self.body.to_doc())
-            .append(RcDoc::text("]"))
-            .nest(1)
-            .group()
-    }
-}
-
-impl fmt::Display for PatternPair {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "[{}\n{}]", self.pattern, self.body)
-    }
-}
-
-#[inline]
-pub(crate) fn parse_if<I>(
-    mut value_iter: I,
-    syn: SyntaxObject,
-) -> std::result::Result<ExprKind, ParseError>
-where
-    I: Iterator<Item = ExprKind>,
-{
-    // let mut value_iter = value.into_iter();
-    value_iter.next();
-
-    let ret_value = If::new(
-        value_iter.next().ok_or_else(|| {
-            ParseError::SyntaxError(
-                "if expects a test condition, found none".to_string(),
-                syn.span,
-                None,
-            )
-        })?,
-        value_iter.next().ok_or_else(|| {
-            ParseError::SyntaxError(
-                "if expects a then condition, found none".to_string(),
-                syn.span,
-                None,
-            )
-        })?,
-        // Replace else condition with just a void if its not found!
-        value_iter
-            .next()
-            .unwrap_or_else(|| ExprKind::ident("#%prim.void")),
-        //     ok_or_else(|| {
-        //     ParseError::SyntaxError(
-        //         "if expects an else condition, found none".to_string(),
-        //         syn.span,
-        //         None,
-        //     )
-        // })?,
-        syn.clone(),
-    )
-    .into();
-
-    if value_iter.next().is_some() {
-        Err(ParseError::SyntaxError(
-            "if takes only 3 expressions".to_string(),
-            syn.span,
-            None,
-        ))
-    } else {
-        Ok(ret_value)
-    }
-}
-
-#[inline]
-pub(crate) fn parse_define<I>(
-    mut value_iter: I,
-    syn: SyntaxObject,
-) -> std::result::Result<ExprKind, ParseError>
-where
-    I: Iterator<Item = ExprKind>,
-{
-    value_iter.next();
-
-    match value_iter.next().ok_or_else(|| {
-        ParseError::SyntaxError(
-            "define expects an identifier, found none".to_string(),
-            syn.span,
-            None,
-        )
-    })? {
-        // TODO maybe add implicit begin here
-        // maybe do it later, not sure
-        ExprKind::List(l) => {
-            let name_ref = l.args.first().ok_or_else(|| {
-                ParseError::SyntaxError(
-                    "define expected a function name, found none".to_string(),
-                    syn.span,
-                    None,
-                )
-            })?;
-
-            if let ExprKind::Atom(Atom {
-                syn:
-                    SyntaxObject {
-                        ty: TokenType::Identifier(datum_syntax),
-                        ..
-                    },
-            }) = name_ref
-            {
-                if *datum_syntax == *DATUM_SYNTAX {
-                    return Ok(ExprKind::Define(Box::new(Define::new(
-                        ExprKind::List(List::new(l.args)),
-                        {
-                            let v = value_iter.next().ok_or_else(|| {
-                                ParseError::SyntaxError(
-                                    "define statement expected a body, found none".to_string(),
-                                    syn.span,
-                                    None,
-                                )
-                            })?;
-                            if value_iter.next().is_some() {
-                                return Err(ParseError::SyntaxError(
-                                    "Define expected only one expression after the identifier"
-                                        .to_string(),
-                                    syn.span,
-                                    None,
-                                ));
-                            }
-                            v
-                        },
-                        syn,
-                    ))));
-                }
-            }
-
-            let mut args = l.args.into_iter();
-
-            let name = args.next().ok_or_else(|| {
-                ParseError::SyntaxError(
-                    "define expected a function name, found none".to_string(),
-                    syn.span,
-                    None,
-                )
-            })?;
-
-            let args = args.collect();
-
-            let body_exprs: Vec<_> = value_iter.collect();
-
-            if body_exprs.is_empty() {
-                return Err(ParseError::SyntaxError(
-                    "Function body cannot be empty".to_string(),
-                    syn.span,
-                    None,
-                ));
-            }
-
-            let body = if body_exprs.len() == 1 {
-                body_exprs[0].clone()
-            } else {
-                ExprKind::Begin(Begin::new(
-                    body_exprs,
-                    SyntaxObject::default(TokenType::Begin),
-                ))
-            };
-
-            let lambda = ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                args,
-                body,
-                SyntaxObject::new(TokenType::Lambda, syn.span),
-            )));
-
-            Ok(ExprKind::Define(Box::new(Define::new(name, lambda, syn))))
-        }
-        ExprKind::Atom(a) => Ok(ExprKind::Define(Box::new(Define::new(
-            ExprKind::Atom(a),
-            {
-                let v = value_iter.next().ok_or_else(|| {
-                    ParseError::SyntaxError(
-                        "define statement expected a body, found none".to_string(),
-                        syn.span,
-                        None,
-                    )
-                })?;
-                if value_iter.next().is_some() {
-                    return Err(ParseError::SyntaxError(
-                        "Define expected only one expression after the identifier".to_string(),
-                        syn.span,
-                        None,
-                    ));
-                }
-                v
-            },
-            syn,
-        )))),
-
-        _ => Err(ParseError::SyntaxError(
-            "Define expects either an identifier or a list with the function name and arguments"
-                .to_string(),
-            syn.span,
-            None,
-        )),
-    }
-}
-
-#[inline]
-pub(crate) fn parse_new_let<I>(
-    mut value_iter: I,
-    syn: SyntaxObject,
-) -> std::result::Result<ExprKind, ParseError>
-where
-    I: Iterator<Item = ExprKind>,
-{
-    value_iter.next();
-
-    let let_pairs = if let ExprKind::List(l) = value_iter.next().ok_or_else(|| {
-        ParseError::SyntaxError(
-            "let expected a list of variable bindings pairs in the second position, found none"
-                .to_string(),
-            syn.span,
-            None,
-        )
-    })? {
-        l.args
-    } else {
-        return Err(ParseError::SyntaxError(
-            "let expects a list of variable bindings pairs in the second position".to_string(),
-            syn.span,
-            None,
-        ));
-    };
-
-    let body_exprs: Vec<_> = value_iter.collect();
-
-    if body_exprs.is_empty() {
-        return Err(ParseError::SyntaxError(
-            "let expects an expression, found none".to_string(),
-            syn.span,
-            None,
-        ));
-    }
-
-    let body = if body_exprs.len() == 1 {
-        body_exprs[0].clone()
-    } else {
-        ExprKind::Begin(Begin::new(
-            body_exprs,
-            SyntaxObject::default(TokenType::Begin),
-        ))
-    };
-
-    let mut pairs = Vec::with_capacity(let_pairs.len());
-
-    for pair in let_pairs {
-        if let ExprKind::List(l) = pair {
-            let pair = l.args;
-
-            if pair.len() != 2 {
-                return Err(ParseError::SyntaxError(
-                    format!("let expected a list of variable binding pairs, found a pair with length {}",
-                    pair.len()),
-                    syn.span, None
-                ));
-            }
-
-            let mut iter = pair.into_iter();
-
-            let identifier = iter.next().unwrap();
-            let application_arg = iter.next().unwrap();
-            pairs.push((identifier, application_arg))
-        } else {
-            return Err(ParseError::SyntaxError(
-                "let expected a list of variable binding pairs".to_string(),
-                syn.span,
-                None,
-            ));
-        }
-    }
-
-    Ok(ExprKind::Let(Let::new(pairs, body, syn).into()))
-}
-
-#[inline]
-fn parse_named_let<I>(
-    mut value_iter: I,
-    syn: SyntaxObject,
-    name: ExprKind,
-) -> std::result::Result<ExprKind, ParseError>
-where
-    I: Iterator<Item = ExprKind>,
-{
-    let pairs = if let ExprKind::List(l) = value_iter.next().ok_or_else(|| {
-        ParseError::SyntaxError(
-            "named let expects a list of argument id and init expr pairs, found none".to_string(),
-            syn.span,
-            None,
-        )
-    })? {
-        l.args
-    } else {
-        return Err(ParseError::SyntaxError(
-            "named let expects a list of variable bindings pairs in the second position"
-                .to_string(),
-            syn.span,
-            None,
-        ));
-    };
-
-    let body_exprs: Vec<_> = value_iter.collect();
-
-    if body_exprs.is_empty() {
-        return Err(ParseError::SyntaxError(
-            "let expects an expression, found none".to_string(),
-            syn.span,
-            None,
-        ));
-    }
-
-    let body = if body_exprs.len() == 1 {
-        body_exprs[0].clone()
-    } else {
-        ExprKind::Begin(Begin::new(
-            body_exprs,
-            SyntaxObject::default(TokenType::Begin),
-        ))
-    };
-
-    let mut arguments = Vec::with_capacity(pairs.len());
-
-    // insert args at the end
-    // put the function in the inside
-    let mut application_args = Vec::with_capacity(pairs.len());
-
-    for pair in pairs {
-        if let ExprKind::List(l) = pair {
-            let pair = l.args;
-
-            if pair.len() != 2 {
-                return Err(ParseError::SyntaxError(
-                    format!("let expected a list of variable binding pairs, found a pair with length {}",
-                    pair.len()),
-                    syn.span, None
-                ));
-            }
-
-            let identifier = pair[0].clone();
-            let application_arg = pair[1].clone();
-
-            arguments.push(identifier);
-            application_args.push(application_arg);
-        } else {
-            return Err(ParseError::SyntaxError(
-                "let expected a list of variable binding pairs".to_string(),
-                syn.span,
-                None,
-            ));
-        }
-    }
-
-    // This is the body of the define
-    let function: ExprKind = LambdaFunction::new(arguments, body, syn.clone()).into();
-
-    let define: ExprKind = Define::new(name.clone(), function, syn.clone()).into();
-
-    let application: ExprKind = {
-        let mut application = vec![name];
-        application.append(&mut application_args);
-        List::new(application).into()
-    };
-
-    let begin = ExprKind::Begin(Begin::new(vec![define, application], syn.clone()));
-
-    // Wrap the whole thing inside of an empty function application, to create a new scope
-
-    Ok(List::new(vec![LambdaFunction::new(vec![], begin, syn).into()]).into())
-}
-
-#[inline]
-pub(crate) fn parse_let<I>(
-    mut value_iter: I,
-    mut syn: SyntaxObject,
-) -> std::result::Result<ExprKind, ParseError>
-where
-    I: Iterator<Item = ExprKind>,
-{
-    value_iter.next();
-
-    let let_pairs = match value_iter.next().ok_or_else(|| {
-        ParseError::SyntaxError(
-            "let expected a list of variable bindings pairs in the second position, found none"
-                .to_string(),
-            syn.span,
-            None,
-        )
-    })? {
-        // Standard let
-        ExprKind::List(l) => l.args,
-        // Named let
-        name @ ExprKind::Atom(_) => return parse_named_let(value_iter, syn, name),
-        _ => {
-            return Err(ParseError::SyntaxError(
-                "let expects a list of variable bindings pairs in the second position".to_string(),
-                syn.span,
-                None,
-            ));
-        }
-    };
-
-    let body_exprs: Vec<_> = value_iter.collect();
-
-    if body_exprs.is_empty() {
-        return Err(ParseError::SyntaxError(
-            "let expects an expression, found none".to_string(),
-            syn.span,
-            None,
-        ));
-    }
-
-    let body = if body_exprs.len() == 1 {
-        body_exprs[0].clone()
-    } else {
-        ExprKind::Begin(Begin::new(
-            body_exprs,
-            SyntaxObject::default(TokenType::Begin),
-        ))
-    };
-
-    let mut arguments = Vec::with_capacity(let_pairs.len());
-
-    // insert args at the end
-    // put the function in the inside
-    let mut application_args = Vec::with_capacity(let_pairs.len());
-
-    for pair in let_pairs {
-        if let ExprKind::List(l) = pair {
-            let pair = l.args;
-
-            if pair.len() != 2 {
-                return Err(ParseError::SyntaxError(
-                    format!("let expected a list of variable binding pairs, found a pair with length {}",
-                    pair.len()),
-                    syn.span, None
-                ));
-            }
-
-            let identifier = pair[0].clone();
-            let application_arg = pair[1].clone();
-
-            arguments.push(identifier);
-            application_args.push(application_arg);
-        } else {
-            return Err(ParseError::SyntaxError(
-                "let expected a list of variable binding pairs".to_string(),
-                syn.span,
-                None,
-            ));
-        }
-    }
-
-    // Since we've converted it, we should turn it into a lambda
-    syn.ty = TokenType::Lambda;
-
-    let mut function: Vec<ExprKind> = vec![LambdaFunction::new(arguments, body, syn).into()];
-
-    function.append(&mut application_args);
-
-    Ok(ExprKind::List(List::new(function)))
-}
-
-#[inline]
-pub(crate) fn parse_single_argument<I>(
-    mut value_iter: I,
-    syn: SyntaxObject,
-    name: &'static str,
-    constructor: fn(ExprKind, SyntaxObject) -> ExprKind,
-) -> Result<ExprKind, ParseError>
-where
-    I: Iterator<Item = ExprKind>,
-{
-    value_iter.next();
-
-    let func = value_iter.next().ok_or_else(|| {
-        ParseError::ArityMismatch(
-            format!("{name} expected one argument, found none"),
-            syn.span,
-            None,
-        )
-    })?;
-
-    if value_iter.next().is_some() {
-        Err(ParseError::SyntaxError(
-            format!("{name} expects only one argument"),
-            syn.span,
-            None,
-        ))
-    } else {
-        Ok(constructor(func, syn))
-    }
-}
-
-impl TryFrom<Vec<ExprKind>> for ExprKind {
-    type Error = ParseError;
-    fn try_from(value: Vec<ExprKind>) -> std::result::Result<Self, Self::Error> {
-        // let mut value = value.into_iter().peekable();
-
-        // TODO -> get rid of this clone on the first value
-        if let Some(f) = value.first().cloned() {
-            match f {
-                ExprKind::Atom(a) => {
-                    // let value = value.into_iter();
-
-                    match &a.syn.ty {
-                        // Have this also match on the first argument being a TokenType::Identifier("if")
-                        // Do the same for the rest of the arguments
-                        TokenType::If => parse_if(value.into_iter(), a.syn.clone()),
-                        TokenType::Identifier(expr) if *expr == *IF => {
-                            parse_if(value.into_iter(), a.syn.clone())
-                        }
-
-                        TokenType::Define => parse_define(value.into_iter(), a.syn.clone()),
-                        TokenType::Identifier(expr) if *expr == *DEFINE => {
-                            parse_define(value.into_iter(), a.syn.clone())
-                        }
-
-                        TokenType::Let => parse_let(value.into_iter(), a.syn.clone()),
-                        TokenType::Identifier(expr) if *expr == *LET => {
-                            parse_let(value.into_iter(), a.syn.clone())
-                        }
-
-                        // TODO: Deprecate
-                        TokenType::TestLet => parse_new_let(value.into_iter(), a.syn.clone()),
-                        TokenType::Identifier(expr) if *expr == *PLAIN_LET => {
-                            parse_new_let(value.into_iter(), a.syn.clone())
-                        }
-
-                        TokenType::Quote => parse_single_argument(
-                            value.into_iter(),
-                            a.syn.clone(),
-                            "quote",
-                            |expr, syn| Quote::new(expr, syn).into(),
-                        ),
-                        TokenType::Identifier(expr) if *expr == *QUOTE => parse_single_argument(
-                            value.into_iter(),
-                            a.syn.clone(),
-                            "quote",
-                            |expr, syn| Quote::new(expr, syn).into(),
-                        ),
-
-                        TokenType::Return => parse_single_argument(
-                            value.into_iter(),
-                            a.syn.clone(),
-                            "return!",
-                            |expr, syn| Return::new(expr, syn).into(),
-                        ),
-                        TokenType::Identifier(expr) if *expr == *RETURN => parse_single_argument(
-                            value.into_iter(),
-                            a.syn.clone(),
-                            "return!",
-                            |expr, syn| Return::new(expr, syn).into(),
-                        ),
-
-                        TokenType::Require => parse_require(&a, value),
-                        TokenType::Identifier(expr) if *expr == *REQUIRE => {
-                            parse_require(&a, value)
-                        }
-
-                        TokenType::Set => parse_set(&a, value),
-                        TokenType::Identifier(expr) if *expr == *SET => parse_set(&a, value),
-
-                        TokenType::Begin => parse_begin(&a, value),
-                        TokenType::Identifier(expr) if *expr == *BEGIN => parse_begin(&a, value),
-
-                        TokenType::Lambda => parse_lambda(&a, value),
-                        TokenType::Identifier(expr)
-                            if *expr == *LAMBDA
-                                || *expr == *LAMBDA_FN
-                                || *expr == *LAMBDA_SYMBOL =>
-                        {
-                            parse_lambda(&a, value)
-                        }
-
-                        TokenType::DefineSyntax => {
-                            let syn = a.syn.clone();
-
-                            if value.len() < 3 {
-                                return Err(ParseError::SyntaxError(
-                                    format!("define-syntax expects 2 arguments - the name of the macro and the syntax-rules, found {}", value.len()), syn.span, None
-                                ));
-                            }
-
-                            // println!("{}", value.iter().map(|x| x.to_pretty(60)).join("\n\n"));
-
-                            let mut value_iter = value.into_iter();
-                            value_iter.next();
-
-                            let name = value_iter.next().unwrap();
-
-                            let syntax = value_iter.next();
-
-                            // println!("{:?}", syntax);
-
-                            let syntax_rules = if let Some(ExprKind::SyntaxRules(s)) = syntax {
-                                s
-                            } else {
-                                return Err(ParseError::SyntaxError(
-                                    "define-syntax expected a syntax-rules object".to_string(),
-                                    syn.span,
-                                    None,
-                                ));
-                            };
-
-                            Ok(ExprKind::Macro(Box::new(Macro::new(
-                                name,
-                                syntax_rules,
-                                syn,
-                            ))))
-                        }
-                        TokenType::SyntaxRules => {
-                            let syn = a.syn.clone();
-
-                            if value.len() < 3 {
-                                return Err(ParseError::SyntaxError(
-                                    format!("syntax-rules expects a list of introduced syntax, and at least one pattern-body pair, found {} arguments", value.len()), syn.span, None
-                                ));
-                            }
-
-                            let mut value_iter = value.into_iter();
-                            value_iter.next();
-
-                            let syntax_vec = if let Some(ExprKind::List(l)) = value_iter.next() {
-                                l.args
-                            } else {
-                                return Err(ParseError::SyntaxError(
-                                    "syntax-rules expects a list of new syntax forms used in the macro".to_string(), syn.span, None));
-                            };
-
-                            let mut pairs = Vec::new();
-                            let rest: Vec<_> = value_iter.collect();
-
-                            for pair in rest {
-                                if let ExprKind::List(l) = pair {
-                                    if l.args.len() != 2 {
-                                        return Err(ParseError::SyntaxError(
-                                            "syntax-rules requires only one pattern to one body"
-                                                .to_string(),
-                                            syn.span,
-                                            None,
-                                        ));
-                                    }
-
-                                    let mut pair_iter = l.args.into_iter();
-                                    let pair_object = PatternPair::new(
-                                        pair_iter.next().unwrap(),
-                                        pair_iter.next().unwrap(),
-                                    );
-                                    pairs.push(pair_object);
-                                } else {
-                                    return Err(ParseError::SyntaxError(
-                                        "syntax-rules requires pattern to expressions to be in a list".to_string(), syn.span, None
-                                    ));
-                                }
-                            }
-
-                            Ok(ExprKind::SyntaxRules(Box::new(SyntaxRules::new(
-                                syntax_vec, pairs, syn,
-                            ))))
-                        }
-                        _ => Ok(ExprKind::List(List::new(value))),
-                    }
-                }
-                _ => Ok(ExprKind::List(List::new(value))),
-            }
-        } else {
-            Ok(ExprKind::List(List::new(vec![])))
-        }
-    }
-}
-
-pub fn parse_lambda(a: &Atom, value: Vec<ExprKind>) -> Result<ExprKind, ParseError> {
-    let syn = a.syn.clone();
-    if value.len() < 3 {
-        return Err(ParseError::SyntaxError(
-            format!(
-                "lambda expected at least 2 arguments - the bindings list and one or more expressions, found {} instead",
-                value.len()
-            ),
-            syn.span, None
-        ));
-    }
-    let mut value_iter = value.into_iter();
-    value_iter.next();
-    let arguments = value_iter.next();
-    match arguments {
-        Some(ExprKind::List(l)) => {
-            let args = l.args;
-
-            for arg in &args {
-                if let ExprKind::Atom(_) = arg {
-                    continue;
-                } else {
-                    return Err(ParseError::SyntaxError(
-                        format!(
-                            "lambda function expects a list of identifiers, found: {}",
-                            List::new(args)
-                        ),
-                        syn.span,
-                        None,
-                    ));
-                }
-            }
-
-            let body_exprs: Vec<_> = value_iter.collect();
-
-            let body = if body_exprs.len() == 1 {
-                body_exprs.into_iter().next().unwrap()
-            } else {
-                ExprKind::Begin(Begin::new(
-                    body_exprs,
-                    SyntaxObject::default(TokenType::Begin),
-                ))
-            };
-
-            Ok(ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                args, body, syn,
-            ))))
-        }
-        Some(ExprKind::Atom(a)) => {
-            let body_exprs: Vec<_> = value_iter.collect();
-
-            let body = if body_exprs.len() == 1 {
-                body_exprs.into_iter().next().unwrap()
-            } else {
-                ExprKind::Begin(Begin::new(
-                    body_exprs,
-                    SyntaxObject::default(TokenType::Begin),
-                ))
-            };
-
-            // (lambda x ...) => x is a rest arg, becomes a list at run time
-            Ok(ExprKind::LambdaFunction(Box::new(
-                LambdaFunction::new_with_rest_arg(vec![ExprKind::Atom(a)], body, syn),
-            )))
-        }
-        _ => {
-            // TODO -> handle case like
-            // (lambda x 10) <- where x is immediately bound to be a rest arg
-            // This should be fairly trivial in this case since we can just put the
-            // first thing into a vec for the lambda node
-            Err(ParseError::SyntaxError(
-                format!("lambda function expected a list of identifiers, found: {arguments:?}"),
-                syn.span,
-                None,
-            ))
-        }
-    }
-}
-
-pub(crate) fn parse_set(a: &Atom, value: Vec<ExprKind>) -> Result<ExprKind, ParseError> {
-    let syn = a.syn.clone();
-    if value.len() != 3 {
-        return Err(ParseError::ArityMismatch(
-            "set! expects an identifier and an expression".to_string(),
-            syn.span,
-            None,
-        ));
-    }
-    let mut value_iter = value.into_iter();
-    value_iter.next();
-    let identifier = value_iter.next().unwrap();
-    let expression = value_iter.next().unwrap();
-    Ok(ExprKind::Set(Box::new(Set::new(
-        identifier, expression, syn,
-    ))))
-}
-
-pub(crate) fn parse_require(a: &Atom, value: Vec<ExprKind>) -> Result<ExprKind, ParseError> {
-    let syn = a.syn.clone();
-    if value.len() < 2 {
-        return Err(ParseError::ArityMismatch(
-            "require expects at least one identifier or string".to_string(),
-            syn.span,
-            None,
-        ));
-    }
-    let mut value_iter = value.into_iter();
-    value_iter.next();
-    let expressions = value_iter
-        .map(|x| {
-            match &x {
-                ExprKind::Atom(_) | ExprKind::List(_) => Ok(x),
-                _ => Err(ParseError::SyntaxError(
-                    "require expects atoms".to_string(),
-                    syn.span,
-                    None,
-                )),
-            }
-
-            // if let ExprKind::Atom(a) = x {
-            //     Ok(a)
-            // } else {
-
-            // }
-        })
-        .collect::<Result<Vec<_>, ParseError>>()?;
-    Ok(ExprKind::Require(Require::new(expressions, syn)))
-}
-
-pub(crate) fn parse_begin(a: &Atom, value: Vec<ExprKind>) -> Result<ExprKind, ParseError> {
-    let syn = a.syn.clone();
-    let mut value_iter = value.into_iter();
-    value_iter.next();
-    Ok(ExprKind::Begin(Begin::new(value_iter.collect(), syn)))
-}
-
-#[cfg(test)]
-mod display_tests {
-
-    use super::*;
-    use crate::parser::{Parser, Result};
-
-    fn parse(expr: &str) -> ExprKind {
-        let a: Result<Vec<ExprKind>> = Parser::new(expr, None).collect();
-
-        a.unwrap()[0].clone()
-    }
-
-    #[test]
-    fn display_lambda_quote() {
-        let expression = "(lambda (x) (quote x))";
-        let parsed_expr = parse(expression);
-        let expected = "(lambda (x) (quote x))";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_list() {
-        let expression = "(list 1 2 3 4)";
-        let parsed_expr = parse(expression);
-        let expected = "(list 1 2 3 4)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_lambda() {
-        let expression = "(lambda (x) (+ x 10))";
-        let parsed_expr = parse(expression);
-        let expected = "(lambda (x) (+ x 10))";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_set() {
-        let expression = "(set! x 10)";
-        let parsed_expr = parse(expression);
-        let expected = "(set! x 10)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_panic() {
-        let expression = "(panic! 12345)";
-        let parsed_expr = parse(expression);
-        let expected = "(panic! 12345)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_begin() {
-        let expression = "(begin 1 2 3 4 5)";
-        let parsed_expr = parse(expression);
-        let expected = "(begin 1 2 3 4 5)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_define_normal() {
-        let expression = "(define a 10)";
-        let parsed_expr = parse(expression);
-        let expected = "(define a 10)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_define_function() {
-        let expression = "(define (applesauce x y z) (+ x y z))";
-        let parsed_expr = parse(expression);
-        let expected = "(define applesauce (lambda (x y z) (+ x y z)))";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_let() {
-        let expression = "(let ((x 10)) (+ x 10))";
-        let parsed_expr = parse(expression);
-        let expected = "((lambda (x) (+ x 10)) 10)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_apply() {
-        let expression = "(apply + (list 1 2 3 4))";
-        let parsed_expr = parse(expression);
-        let expected = "(apply + (list 1 2 3 4))";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_transduce() {
-        let expression = "(transduce 1 2 3 4)";
-        let parsed_expr = parse(expression);
-        let expected = "(transduce 1 2 3 4)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_execute_two_args() {
-        let expression = "(execute 1 2)";
-        let parsed_expr = parse(expression);
-        let expected = "(execute 1 2)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_execute_three_args() {
-        let expression = "(execute 1 2 3)";
-        let parsed_expr = parse(expression);
-        let expected = "(execute 1 2 3)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_if() {
-        let expression = "(if 1 2 3)";
-        let parsed_expr = parse(expression);
-        let expected = "(if 1 2 3)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_quote() {
-        let expression = "'(1 2 3 4)";
-        let parsed_expr = parse(expression);
-        let expected = "(quote (1 2 3 4))";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_read() {
-        let expression = "(read '(1 2 3 4))";
-        let parsed_expr = parse(expression);
-        let expected = "(read (quote (1 2 3 4)))";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_return() {
-        let expression = "(return! 10)";
-        let parsed_expr = parse(expression);
-        let expected = "(return! 10)";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_struct() {
-        let expression = "(struct Apple (a b c))";
-        let parsed_expr = parse(expression);
-        let expected = "(struct Apple (a b c))";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-
-    #[test]
-    fn display_eval() {
-        let expression = "(eval 'a)";
-        let parsed_expr = parse(expression);
-        let expected = "(eval (quote a))";
-        assert_eq!(parsed_expr.to_string(), expected);
-    }
-}
-
-#[cfg(test)]
-mod pretty_print_tests {
-    use super::*;
-    use crate::parser::{Parser, Result};
-
-    fn parse(expr: &str) -> ExprKind {
-        let a: Result<Vec<ExprKind>> = Parser::new(expr, None).collect();
-
-        a.unwrap()[0].clone()
-    }
-
-    #[test]
-    fn pretty_set() {
-        let expression = r#"
-            (define test-function 
-                (lambda (a b c) 
-                    (begin 
-                        (set! bananas 10) 
-                        (if applesauce 100 #f)
-                        (if applesauce 100 (if applesauce 100 #f)))))"#;
-        let parsed_expr = parse(expression);
-        let _output = parsed_expr.to_pretty(45);
-
-        assert!(true)
-    }
-}
diff --git a/crates/steel-parser/src/interner.rs b/crates/steel-parser/src/interner.rs
deleted file mode 100644
index 5c8d66a9b..000000000
--- a/crates/steel-parser/src/interner.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-use lasso::Key;
-use lasso::Spur;
-use once_cell::sync::OnceCell;
-use serde::{Deserialize, Serialize};
-use std::{fmt, sync::Arc};
-
-// TODO: Serialize and Deserialize should resolve() -> Otherwise we're in for deep trouble
-// trying to serialize and deserialize this
-#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Hash)]
-#[repr(transparent)]
-pub struct InternedString(Spur);
-
-impl Serialize for InternedString {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.resolve().serialize(serializer)
-    }
-}
-
-impl<'de> Deserialize<'de> for InternedString {
-    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        let key = <&str>::deserialize(deserializer)?;
-
-        Ok(InternedString::from(key))
-    }
-}
-
-impl InternedString {
-    pub fn from_static(ident: &'static str) -> Self {
-        Self(
-            INTERNER
-                .get_or_init(|| Arc::new(ThreadedRodeo::new()))
-                .get_or_intern_static(ident),
-        )
-    }
-
-    pub fn from_string(ident: String) -> Self {
-        Self(
-            INTERNER
-                .get_or_init(|| Arc::new(ThreadedRodeo::new()))
-                .get_or_intern(ident),
-        )
-    }
-
-    pub fn new(key: usize) -> Self {
-        Self(Spur::try_from_usize(key).unwrap())
-    }
-
-    pub fn get(self) -> Spur {
-        self.0
-    }
-
-    pub fn try_get(ident: &str) -> Option<InternedString> {
-        INTERNER.get().unwrap().get(ident).map(InternedString)
-    }
-
-    #[doc(hidden)]
-    pub fn as_u32(self) -> u32 {
-        self.get().into_usize() as u32
-    }
-
-    pub fn resolve(&self) -> &str {
-        resolve(&self.0)
-    }
-}
-
-impl From<&str> for InternedString {
-    fn from(ident: &str) -> Self {
-        Self(
-            INTERNER
-                .get_or_init(|| Arc::new(ThreadedRodeo::new()))
-                .get_or_intern(ident),
-        )
-    }
-}
-
-impl From<String> for InternedString {
-    fn from(ident: String) -> Self {
-        Self::from_string(ident)
-    }
-}
-
-impl From<Spur> for InternedString {
-    fn from(spur: Spur) -> Self {
-        Self(spur)
-    }
-}
-
-impl fmt::Debug for InternedString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.get().into_usize())
-    }
-}
-
-impl fmt::Display for InternedString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.resolve())
-    }
-}
-
-// impl Serialize for InternedString {
-//     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-//     where
-//         S: Serializer,
-//     {
-//         serializer.serialize_str(self.resolve())
-//     }
-// }
-
-use lasso::ThreadedRodeo;
-
-static INTERNER: OnceCell<Arc<ThreadedRodeo>> = OnceCell::new();
-
-pub fn take_interner() -> Arc<ThreadedRodeo> {
-    Arc::clone(INTERNER.get().unwrap())
-}
-
-pub fn initialize_with(interner: Arc<ThreadedRodeo>) -> Result<(), Arc<ThreadedRodeo>> {
-    INTERNER.set(interner)
-}
-
-pub fn get_interner() -> Option<&'static Arc<ThreadedRodeo>> {
-    INTERNER.get()
-}
-
-pub fn add_interner(interner: Arc<ThreadedRodeo>) {
-    let guard = INTERNER.get().unwrap();
-
-    for key in interner.strings() {
-        guard.get_or_intern(key);
-    }
-}
-
-#[test]
-fn test_initialization() {
-    INTERNER.get_or_init(|| Arc::new(ThreadedRodeo::new()));
-    let key = INTERNER.get().unwrap().get_or_intern_static("hello world");
-
-    let resolved_string = INTERNER.get().unwrap().resolve(&key);
-
-    println!("resolved string: {resolved_string:?}");
-}
-
-fn resolve(key: &Spur) -> &str {
-    INTERNER.get().unwrap().resolve(key)
-}
diff --git a/crates/steel-parser/src/lexer.rs b/crates/steel-parser/src/lexer.rs
deleted file mode 100644
index e70dd8d37..000000000
--- a/crates/steel-parser/src/lexer.rs
+++ /dev/null
@@ -1,897 +0,0 @@
-use crate::tokens::{MaybeBigInt, Token, TokenType};
-use std::iter::Iterator;
-use std::marker::PhantomData;
-
-use super::parser::SourceId;
-use std::{iter::Peekable, str::Chars};
-
-use crate::tokens::parse_unicode_str;
-
-pub struct OwnedString;
-
-impl ToOwnedString<String> for OwnedString {
-    fn own(&self, s: &str) -> String {
-        s.to_string()
-    }
-}
-
-pub trait ToOwnedString<T> {
-    fn own(&self, s: &str) -> T;
-}
-
-pub type Span = core::ops::Range<usize>;
-
-pub struct Lexer<'a> {
-    source: &'a str,
-
-    chars: Peekable<Chars<'a>>,
-
-    token_start: usize,
-    token_end: usize,
-    // skip_comments: bool,
-    // source_id: Option<SourceId>,
-}
-
-impl<'a> Lexer<'a> {
-    pub fn new(source: &'a str) -> Self {
-        Self {
-            source,
-            chars: source.chars().peekable(),
-            token_start: 0,
-            token_end: 0,
-            // skip_comments,
-            // source_id,
-        }
-    }
-
-    fn eat(&mut self) -> Option<char> {
-        if let Some(c) = self.chars.next() {
-            self.token_end += c.len_utf8();
-
-            Some(c)
-        } else {
-            None
-        }
-    }
-
-    // Consume characters until the next non whitespace input
-    fn consume_whitespace(&mut self) {
-        while let Some(&c) = self.chars.peek() {
-            if c.is_whitespace() {
-                self.eat();
-
-                self.token_start = self.token_end;
-            } else {
-                break;
-            }
-        }
-    }
-
-    fn read_string(&mut self) -> Result<TokenType<&'a str>> {
-        // Skip the opening quote.
-        self.eat();
-
-        let mut buf = String::new();
-        while let Some(&c) = self.chars.peek() {
-            self.eat();
-            match c {
-                '"' => return Ok(TokenType::StringLiteral(buf)),
-                '\\' => match self.chars.peek() {
-                    Some('"') => {
-                        self.eat();
-                        buf.push('"');
-                    }
-
-                    Some('\\') => {
-                        self.eat();
-                        buf.push('\\')
-                    }
-
-                    Some('t') => {
-                        self.eat();
-                        buf.push('\t');
-                    }
-
-                    Some('n') => {
-                        self.eat();
-                        buf.push('\n');
-                    }
-
-                    Some('r') => {
-                        self.eat();
-                        buf.push('\r');
-                    }
-
-                    Some('0') => {
-                        self.eat();
-                        buf.push('\0');
-                    }
-
-                    _ => return Err(TokenError::InvalidEscape),
-                },
-                _ => buf.push(c),
-            }
-        }
-
-        buf.insert(0, '"');
-        Err(TokenError::IncompleteString)
-    }
-
-    fn read_hash_value(&mut self) -> Result<TokenType<&'a str>> {
-        fn parse_char(slice: &str) -> Option<char> {
-            use std::str::FromStr;
-
-            match slice {
-                "#\\SPACE" => Some(' '),
-                "#\\space" => Some(' '),
-                "#\\\\" => Some('\\'),
-                "#\\tab" => Some('\t'),
-                "#\\TAB" => Some('\t'),
-                "#\\NEWLINE" => Some('\n'),
-                "#\\newline" => Some('\n'),
-                "#\\return" => Some('\r'),
-                "#\\RETURN" => Some('\r'),
-                "#\\)" => Some(')'),
-                "#\\]" => Some(']'),
-                "#\\[" => Some('['),
-                "#\\(" => Some('('),
-                "#\\^" => Some('^'),
-
-                character if character.starts_with("#\\") => {
-                    let parsed_unicode = parse_unicode_str(character);
-
-                    if parsed_unicode.is_some() {
-                        return parsed_unicode;
-                    }
-                    char::from_str(character.trim_start_matches("#\\")).ok()
-                }
-                _ => None,
-            }
-        }
-
-        while let Some(&c) = self.chars.peek() {
-            match c {
-                '\\' => {
-                    self.eat();
-                    self.eat();
-                }
-                '(' | '[' | ')' | ']' => break,
-                c if c.is_whitespace() => break,
-                _ => {
-                    self.eat();
-                }
-            };
-        }
-
-        match self.slice() {
-            "#true" | "#t" => Ok(TokenType::BooleanLiteral(true)),
-            "#false" | "#f" => Ok(TokenType::BooleanLiteral(false)),
-
-            "#'" => Ok(TokenType::QuoteSyntax),
-            "#`" => Ok(TokenType::QuasiQuoteSyntax),
-            "#," => Ok(TokenType::UnquoteSyntax),
-            "#,@" => Ok(TokenType::UnquoteSpliceSyntax),
-
-            hex if hex.starts_with("#x") => {
-                let hex = isize::from_str_radix(hex.strip_prefix("#x").unwrap(), 16)
-                    .map_err(|_| TokenError::MalformedHexInteger)?;
-
-                Ok(TokenType::IntegerLiteral(MaybeBigInt::Small(hex)))
-            }
-
-            octal if octal.starts_with("#o") => {
-                let hex = isize::from_str_radix(octal.strip_prefix("#o").unwrap(), 8)
-                    .map_err(|_| TokenError::MalformedOctalInteger)?;
-
-                Ok(TokenType::IntegerLiteral(MaybeBigInt::Small(hex)))
-            }
-
-            binary if binary.starts_with("#b") => {
-                let hex = isize::from_str_radix(binary.strip_prefix("#b").unwrap(), 2)
-                    .map_err(|_| TokenError::MalformedBinaryInteger)?;
-
-                Ok(TokenType::IntegerLiteral(MaybeBigInt::Small(hex)))
-            }
-
-            keyword if keyword.starts_with("#:") => Ok(TokenType::Keyword(self.slice())),
-
-            character if character.starts_with("#\\") => {
-                if let Some(parsed_character) = parse_char(character) {
-                    Ok(TokenType::CharacterLiteral(parsed_character))
-                } else {
-                    Err(TokenError::InvalidCharacter)
-                }
-            }
-
-            _ => Ok(self.read_word()),
-        }
-    }
-
-    fn read_number(&mut self) -> TokenType<&'a str> {
-        while let Some(&c) = self.chars.peek() {
-            if matches!(c, '(' | '[' | ')' | ']') {
-                break;
-            }
-
-            if c.is_whitespace() {
-                break;
-            }
-
-            if c == '.' {
-                break;
-            }
-
-            if !c.is_numeric() {
-                self.eat();
-                return self.read_word();
-            }
-
-            self.eat();
-        }
-
-        if let Some(&'.') = self.chars.peek() {
-            self.eat();
-
-            while let Some(&c) = self.chars.peek() {
-                if matches!(c, '(' | '[' | ')' | ']') {
-                    break;
-                }
-                if c.is_whitespace() {
-                    break;
-                }
-
-                if !c.is_numeric() {
-                    self.eat();
-                    return self.read_word();
-                }
-
-                self.eat();
-                // num.push(c);
-            }
-
-            return TokenType::NumberLiteral(self.slice().parse().unwrap());
-        }
-
-        TokenType::IntegerLiteral(self.slice().parse().unwrap())
-    }
-
-    fn read_rest_of_line(&mut self) {
-        while let Some(c) = self.eat() {
-            if c == '\n' {
-                break;
-            }
-        }
-    }
-
-    fn read_word(&mut self) -> TokenType<&'a str> {
-        while let Some(&c) = self.chars.peek() {
-            match c {
-                '(' | '[' | ')' | ']' => break,
-                c if c.is_whitespace() => break,
-                '\'' => {
-                    break;
-                }
-                // Could be a quote within a word, we should handle escaping it accordingly
-                // (even though its a bit odd)
-                '\\' => {
-                    self.eat();
-                    self.eat();
-                }
-
-                _ => {
-                    self.eat();
-                }
-            };
-        }
-
-        match self.slice() {
-            "define" | "defn" | "#%define" => TokenType::Define,
-            "let" => TokenType::Let,
-            "%plain-let" => TokenType::TestLet,
-            "return!" => TokenType::Return,
-            "begin" => TokenType::Begin,
-            "lambda" | "fn" | "#%plain-lambda" | "λ" => TokenType::Lambda,
-            "quote" => TokenType::Quote,
-            // "unquote" => TokenType::Unquote,
-            "syntax-rules" => TokenType::SyntaxRules,
-            "define-syntax" => TokenType::DefineSyntax,
-            "..." => TokenType::Ellipses,
-            "set!" => TokenType::Set,
-            "require" => TokenType::Require,
-            "if" => TokenType::If,
-
-            identifier => TokenType::Identifier(identifier),
-        }
-    }
-}
-
-impl<'a> Lexer<'a> {
-    #[inline]
-    pub fn span(&self) -> Span {
-        self.token_start..self.token_end
-    }
-
-    #[inline]
-    pub fn slice(&self) -> &'a str {
-        self.source.get(self.span()).unwrap()
-    }
-}
-
-pub struct TokenStream<'a> {
-    lexer: Lexer<'a>,
-    skip_comments: bool,
-    source_id: Option<SourceId>,
-}
-
-impl<'a> TokenStream<'a> {
-    pub fn new(input: &'a str, skip_comments: bool, source_id: Option<SourceId>) -> Self {
-        Self {
-            lexer: Lexer::new(input),
-            skip_comments,
-            source_id, // skip_doc_comments,
-        }
-    }
-
-    pub fn into_owned<T, F: ToOwnedString<T>>(self, adapter: F) -> OwnedTokenStream<'a, T, F> {
-        OwnedTokenStream {
-            stream: self,
-            adapter,
-            _token_type: PhantomData,
-        }
-    }
-}
-
-pub struct OwnedTokenStream<'a, T, F> {
-    stream: TokenStream<'a>,
-    adapter: F,
-    _token_type: PhantomData<T>,
-}
-
-impl<'a, T, F: ToOwnedString<T>> Iterator for OwnedTokenStream<'a, T, F> {
-    type Item = Token<'a, T>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.stream.next().map(|x| Token {
-            ty: x.ty.map(|x| self.adapter.own(x)),
-            source: x.source,
-            span: x.span,
-        })
-    }
-}
-
-impl<'a, T, F: ToOwnedString<T>> OwnedTokenStream<'a, T, F> {
-    pub fn offset(&self) -> usize {
-        self.stream.lexer.span().end
-    }
-}
-impl<'a> Iterator for TokenStream<'a> {
-    type Item = Token<'a, &'a str>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.lexer.next().and_then(|token| {
-            let token = match token {
-                Ok(token) => token,
-                Err(_) => TokenType::Error,
-            };
-
-            let token = Token::new(token, self.lexer.slice(), self.lexer.span(), self.source_id);
-            match token.ty {
-                // TokenType::Space => self.next(),
-                TokenType::Comment if self.skip_comments => self.next(),
-                // TokenType::DocComment if self.skip_doc_comments => self.next(),
-                _ => Some(token),
-            }
-        })
-    }
-}
-
-pub type Result<T> = std::result::Result<T, TokenError>;
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum TokenError {
-    UnexpectedChar(char),
-    IncompleteString,
-    InvalidEscape,
-    InvalidCharacter,
-    MalformedHexInteger,
-    MalformedOctalInteger,
-    MalformedBinaryInteger,
-}
-
-impl<'a> Iterator for Lexer<'a> {
-    type Item = Result<TokenType<&'a str>>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // Crunch until the next input
-        self.consume_whitespace();
-
-        self.token_start = self.token_end;
-
-        match self.chars.peek() {
-            Some(';') => {
-                self.eat();
-                self.read_rest_of_line();
-                Some(Ok(TokenType::Comment))
-            }
-
-            Some('"') => Some(self.read_string()),
-
-            Some('(') | Some('[') | Some('{') => {
-                self.eat();
-                Some(Ok(TokenType::OpenParen))
-            }
-            Some(')') | Some(']') | Some('}') => {
-                self.eat();
-                Some(Ok(TokenType::CloseParen))
-            }
-
-            // Handle Quotes
-            Some('\'') => {
-                self.eat();
-                Some(Ok(TokenType::QuoteTick))
-            }
-
-            Some('`') => {
-                self.eat();
-                Some(Ok(TokenType::QuasiQuote))
-            }
-            Some(',') => {
-                self.eat();
-
-                if let Some('@') = self.chars.peek() {
-                    self.eat();
-
-                    Some(Ok(TokenType::UnquoteSplice))
-                } else {
-                    Some(Ok(TokenType::Unquote))
-                }
-            }
-
-            Some('+') => {
-                self.eat();
-                match self.chars.peek() {
-                    Some(&c) if c.is_numeric() => Some(Ok(self.read_number())),
-                    _ => Some(Ok(TokenType::Identifier(self.slice()))),
-                }
-            }
-            Some('-') => {
-                self.eat();
-                match self.chars.peek() {
-                    Some(&c) if c.is_numeric() => Some(Ok(self.read_number())),
-                    _ => Some(Ok(self.read_word())),
-                }
-            }
-            Some('#') => {
-                self.eat();
-                Some(self.read_hash_value())
-            }
-
-            Some(c) if !c.is_whitespace() && !c.is_numeric() || *c == '_' => {
-                Some(Ok(self.read_word()))
-            }
-            Some(c) if c.is_numeric() => Some(Ok(self.read_number())),
-            Some(_) => match self.eat() {
-                Some(e) => Some(Err(TokenError::UnexpectedChar(e))),
-                _ => None,
-            },
-            None => None,
-        }
-    }
-}
-
-#[cfg(test)]
-mod lexer_tests {
-    use super::*;
-    use crate::span::Span;
-    use crate::tokens::{MaybeBigInt, TokenType::*};
-
-    // TODO: Figure out why this just cause an infinite loop when parsing it?
-    #[test]
-    fn test_identifier_with_quote_end() {
-        let s = TokenStream::new(
-            "        (define (stream-cdr stream)
-            ((stream-cdr' stream)))
-",
-            true,
-            None,
-        );
-
-        for token in s {
-            println!("{:?}", token);
-        }
-    }
-
-    #[test]
-    fn test_bracket_characters() {
-        let s = TokenStream::new(
-            "[(equal? #\\[ (car chars)) (b (cdr chars) (+ sum 1))]",
-            true,
-            None,
-        );
-
-        for token in s {
-            println!("{:?}", token);
-        }
-    }
-
-    #[test]
-    fn test_escape_in_string() {
-        let s = TokenStream::new(r#"(display "}\n")"#, true, None);
-
-        for token in s {
-            println!("{:?}", token);
-        }
-    }
-
-    #[test]
-    fn test_quote_within_word() {
-        let mut s = TokenStream::new("'foo\\'a", true, None);
-
-        println!("{:?}", s.next());
-        println!("{:?}", s.next());
-        println!("{:?}", s.next());
-    }
-
-    #[test]
-    fn test_single_period() {
-        let mut s = TokenStream::new(".", true, None);
-
-        println!("{:?}", s.next());
-    }
-
-    #[test]
-    fn test_chars() {
-        let mut s = TokenStream::new("#\\a #\\b #\\λ", true, None);
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: CharacterLiteral('a'),
-                source: "#\\a",
-                span: Span::new(0, 3, None)
-            })
-        );
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: CharacterLiteral('b'),
-                source: "#\\b",
-                span: Span::new(4, 7, None)
-            })
-        );
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: CharacterLiteral('λ'),
-                source: "#\\λ",
-                span: Span::new(8, 12, None)
-            })
-        );
-    }
-
-    #[test]
-    fn test_unexpected_char() {
-        let mut s = TokenStream::new("($)", true, None);
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: OpenParen,
-                source: "(",
-                span: Span::new(0, 1, None)
-            })
-        );
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: Identifier("$"),
-                source: "$",
-                span: Span::new(1, 2, None)
-            })
-        );
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: CloseParen,
-                source: ")",
-                span: Span::new(2, 3, None)
-            })
-        );
-    }
-
-    #[test]
-    fn test_words() {
-        let mut s = TokenStream::new("foo FOO _123_ Nil #f #t", true, None);
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: Identifier("foo"),
-                source: "foo",
-                span: Span::new(0, 3, None)
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: Identifier("FOO"),
-                source: "FOO",
-                span: Span::new(4, 7, None)
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: Identifier("_123_"),
-                source: "_123_",
-                span: Span::new(8, 13, None)
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: Identifier("Nil"),
-                source: "Nil",
-                span: Span::new(14, 17, None)
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: BooleanLiteral(false),
-                source: "#f",
-                span: Span::new(18, 20, None)
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: BooleanLiteral(true),
-                source: "#t",
-                span: Span::new(21, 23, None)
-            })
-        );
-
-        assert_eq!(s.next(), None);
-    }
-
-    #[test]
-    fn test_number() {
-        let mut s = TokenStream::new("0 -0 -1.2 +2.3 999 1.", true, None);
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: IntegerLiteral(MaybeBigInt::Small(0)),
-                source: "0",
-                span: Span::new(0, 1, None),
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: IntegerLiteral(MaybeBigInt::Small(0)),
-                source: "-0",
-                span: Span::new(2, 4, None),
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: NumberLiteral(-1.2),
-                source: "-1.2",
-                span: Span::new(5, 9, None),
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: NumberLiteral(2.3),
-                source: "+2.3",
-                span: Span::new(10, 14, None),
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: IntegerLiteral(MaybeBigInt::Small(999)),
-                source: "999",
-                span: Span::new(15, 18, None),
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: NumberLiteral(1.0),
-                source: "1.",
-                span: Span::new(19, 21, None),
-            })
-        );
-
-        assert_eq!(s.next(), None);
-    }
-
-    #[test]
-    fn test_string() {
-        let mut s = TokenStream::new(r#" "" "Foo bar" "\"\\" "#, true, None);
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: StringLiteral("".to_owned()),
-                source: "\"\"",
-                span: Span::new(1, 3, None),
-            })
-        );
-
-        assert_eq!(
-            s.next(),
-            Some(Token {
-                ty: StringLiteral("Foo bar".to_owned()),
-                source: "\"Foo bar\"",
-                span: Span::new(4, 13, None),
-            })
-        );
-
-        // TODO come check out this test
-        // assert_eq!(
-        //     s.next(),
-        //     Some(Token {
-        //         ty: StringLiteral(r#""\"\\""#.to_owned()),
-        //         source: r#""\"\\""#,
-        //         span: Span::new(14, 20, None),
-        //     })
-        // );
-        // assert_eq!(
-        //     s.next(),
-        //     Some(Token {
-        //         ty: Error,
-        //         source: "\"\\\"",
-        //         span: Span::new(14, 17, None),
-        //     })
-        // );
-
-        // assert_eq!(s.next(), None);
-    }
-
-    #[test]
-    fn test_comment() {
-        let mut s = TokenStream::new(";!/usr/bin/gate\n   ; foo\n", true, None);
-        assert_eq!(s.next(), None);
-    }
-
-    #[test]
-    fn function_definition() {
-        let s = TokenStream::new(
-            "(define odd-rec? (lambda (x) (if (= x 0) #f (even-rec? (- x 1)))))",
-            true,
-            None,
-        );
-        let res: Vec<Token<&str>> = s.collect();
-
-        println!("{:#?}", res);
-    }
-
-    #[test]
-    fn lex_string_with_escape_chars() {
-        let s = TokenStream::new("\"\0\0\0\"", true, None);
-        let res: Vec<Token<&str>> = s.collect();
-        println!("{:#?}", res);
-    }
-
-    #[test]
-    fn scheme_statement() {
-        let s = TokenStream::new("(apples (function a b) (+ a b))", true, None);
-        let res: Vec<Token<&str>> = s.collect();
-
-        let expected: Vec<Token<&str>> = vec![
-            Token {
-                ty: OpenParen,
-                source: "(",
-                span: Span::new(0, 1, None),
-            },
-            Token {
-                ty: Identifier("apples"),
-                source: "apples",
-                span: Span::new(1, 7, None),
-            },
-            Token {
-                ty: OpenParen,
-                source: "(",
-                span: Span::new(8, 9, None),
-            },
-            Token {
-                ty: Identifier("function"),
-                source: "function",
-                span: Span::new(9, 17, None),
-            },
-            Token {
-                ty: Identifier("a"),
-                source: "a",
-                span: Span::new(18, 19, None),
-            },
-            Token {
-                ty: Identifier("b"),
-                source: "b",
-                span: Span::new(20, 21, None),
-            },
-            Token {
-                ty: CloseParen,
-                source: ")",
-                span: Span::new(21, 22, None),
-            },
-            Token {
-                ty: OpenParen,
-                source: "(",
-                span: Span::new(23, 24, None),
-            },
-            Token {
-                ty: Identifier("+"),
-                source: "+",
-                span: Span::new(24, 25, None),
-            },
-            Token {
-                ty: Identifier("a"),
-                source: "a",
-                span: Span::new(26, 27, None),
-            },
-            Token {
-                ty: Identifier("b"),
-                source: "b",
-                span: Span::new(28, 29, None),
-            },
-            Token {
-                ty: CloseParen,
-                source: ")",
-                span: Span::new(29, 30, None),
-            },
-            Token {
-                ty: CloseParen,
-                source: ")",
-                span: Span::new(30, 31, None),
-            },
-        ];
-
-        assert_eq!(res, expected);
-    }
-
-    #[test]
-    fn test_bigint() {
-        let s = TokenStream::new("9223372036854775808", true, None); // isize::MAX + 1
-        let res: Vec<Token<&str>> = s.collect();
-
-        let expected_bigint = "9223372036854775808".parse().unwrap();
-
-        let expected: Vec<Token<&str>> = vec![Token {
-            ty: IntegerLiteral(MaybeBigInt::Big(expected_bigint)),
-            source: "9223372036854775808",
-            span: Span::new(0, 19, None),
-        }];
-
-        assert_eq!(res, expected);
-    }
-
-    #[test]
-    fn negative_test_bigint() {
-        let s = TokenStream::new("-9223372036854775809", true, None); // isize::MIN - 1
-        let res: Vec<Token<&str>> = s.collect();
-
-        let expected_bigint = "-9223372036854775809".parse().unwrap();
-
-        let expected: Vec<Token<&str>> = vec![Token {
-            ty: IntegerLiteral(MaybeBigInt::Big(expected_bigint)),
-            source: "-9223372036854775809",
-            span: Span::new(0, 20, None),
-        }];
-
-        assert_eq!(res, expected);
-    }
-}
diff --git a/crates/steel-parser/src/lib.rs b/crates/steel-parser/src/lib.rs
deleted file mode 100644
index ded4b447c..000000000
--- a/crates/steel-parser/src/lib.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub mod ast;
-pub mod interner;
-pub mod lexer;
-pub mod parser;
-pub mod span;
-pub mod tokens;
diff --git a/crates/steel-parser/src/parser.rs b/crates/steel-parser/src/parser.rs
deleted file mode 100644
index c5cfec724..000000000
--- a/crates/steel-parser/src/parser.rs
+++ /dev/null
@@ -1,2427 +0,0 @@
-use std::{
-    path::PathBuf,
-    rc::Rc,
-    result,
-    sync::atomic::{AtomicUsize, Ordering},
-};
-
-use serde::{Deserialize, Serialize};
-
-use crate::{
-    ast::{
-        self, parse_begin, parse_define, parse_if, parse_lambda, parse_let, parse_new_let,
-        parse_require, parse_set, parse_single_argument, Atom, ExprKind, List, Macro, PatternPair,
-        SyntaxRules, BEGIN, DEFINE, IF, LAMBDA, LAMBDA_FN, LAMBDA_SYMBOL, LET, PLAIN_LET,
-        QUASIQUOTE, QUOTE, RAW_UNQUOTE, RAW_UNQUOTE_SPLICING, REQUIRE, RETURN, SET, UNQUOTE,
-        UNQUOTE_SPLICING,
-    },
-    interner::InternedString,
-    lexer::{OwnedTokenStream, ToOwnedString, TokenStream},
-    span::Span,
-    tokens::{Token, TokenType},
-};
-
-#[derive(
-    Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default, Debug, Ord, PartialOrd,
-)]
-#[repr(C)]
-pub struct SourceId(pub usize);
-
-// TODO: Fix the visibility here
-pub static SYNTAX_OBJECT_ID: AtomicUsize = AtomicUsize::new(0);
-
-#[derive(
-    Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default, Debug, Ord, PartialOrd,
-)]
-pub struct SyntaxObjectId(pub usize);
-
-impl SyntaxObjectId {
-    #[inline]
-    pub fn fresh() -> Self {
-        SyntaxObjectId(SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed))
-    }
-}
-
-impl From<SyntaxObjectId> for usize {
-    fn from(value: SyntaxObjectId) -> Self {
-        value.0
-    }
-}
-
-impl std::fmt::Display for SyntaxObjectId {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{self:?}")
-    }
-}
-
-#[derive(
-    Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default, Debug, Ord, PartialOrd,
-)]
-pub struct ListId(usize);
-
-#[derive(
-    Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, Default, Debug, Ord, PartialOrd,
-)]
-pub struct FunctionId(usize);
-
-/// A syntax object that can hold anything as the syntax
-/// In this case, we're using the token type emitted by logos
-///
-/// This should open the door to interning our strings to make
-/// parsing (and optimizations later) faster
-#[derive(Serialize, Deserialize)]
-pub struct RawSyntaxObject<T> {
-    pub ty: T,
-    pub span: Span,
-    pub syntax_object_id: SyntaxObjectId,
-}
-
-impl<T: Clone> Clone for RawSyntaxObject<T> {
-    fn clone(&self) -> Self {
-        Self {
-            ty: self.ty.clone(),
-            span: self.span,
-            syntax_object_id: SyntaxObjectId(SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed)),
-        }
-    }
-}
-
-impl<T: std::fmt::Debug> std::fmt::Debug for RawSyntaxObject<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("RawSyntaxObject")
-            .field("ty", &self.ty)
-            .field("span", &self.span)
-            .finish()
-    }
-}
-
-// Implementing hash here just on the token type - we dont want the span included
-// For determining the hash here
-impl<T: std::hash::Hash> std::hash::Hash for RawSyntaxObject<T> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.ty.hash(state);
-        self.span.hash(state);
-    }
-}
-
-pub type SyntaxObject = RawSyntaxObject<TokenType<InternedString>>;
-
-impl PartialEq for SyntaxObject {
-    fn eq(&self, other: &Self) -> bool {
-        self.ty == other.ty
-    }
-}
-
-impl SyntaxObject {
-    pub fn new(ty: TokenType<InternedString>, span: Span) -> Self {
-        SyntaxObject {
-            ty,
-            span,
-            // source: None,
-            syntax_object_id: SyntaxObjectId(SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed)),
-        }
-    }
-
-    pub fn default(ty: TokenType<InternedString>) -> Self {
-        SyntaxObject {
-            ty,
-            span: Span::new(0, 0, None),
-            // source: None,
-            syntax_object_id: SyntaxObjectId(SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed)),
-        }
-    }
-
-    pub fn set_span(&mut self, span: Span) {
-        self.span = span
-    }
-
-    pub fn from_token_with_source(
-        val: &Token<'_, InternedString>,
-        _source: &Option<Rc<PathBuf>>,
-    ) -> Self {
-        SyntaxObject {
-            ty: val.ty.clone(),
-            span: val.span,
-            // source: source.as_ref().map(Rc::clone),
-            syntax_object_id: SyntaxObjectId(SYNTAX_OBJECT_ID.fetch_add(1, Ordering::Relaxed)),
-        }
-    }
-}
-
-impl From<&Token<'_, InternedString>> for SyntaxObject {
-    fn from(val: &Token<'_, InternedString>) -> SyntaxObject {
-        SyntaxObject::new(val.ty.clone(), val.span)
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum ParseError {
-    Unexpected(TokenType<String>, Option<Rc<PathBuf>>),
-    UnexpectedEOF(Option<Rc<PathBuf>>),
-    UnexpectedChar(char, Span, Option<Rc<PathBuf>>),
-    IncompleteString(String, Span, Option<Rc<PathBuf>>),
-    SyntaxError(String, Span, Option<Rc<PathBuf>>),
-    ArityMismatch(String, Span, Option<Rc<PathBuf>>),
-}
-
-impl std::fmt::Display for ParseError {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ParseError::Unexpected(l, _) => write!(f, "Parse: Unexpected token: {:?}", l),
-            ParseError::UnexpectedEOF(_) => write!(f, "Parse: Unexpected EOF"),
-            ParseError::UnexpectedChar(l, _, _) => {
-                write!(f, "Parse: Unexpected character: {:?}", l)
-            }
-            ParseError::IncompleteString(l, _, _) => write!(f, "Parse: Incomplete String: {}", l),
-            ParseError::SyntaxError(l, _, _) => write!(f, "Parse: Syntax Error: {}", l),
-            ParseError::ArityMismatch(l, _, _) => write!(f, "Parse: Arity mismatch: {}", l),
-        }
-    }
-}
-
-impl std::error::Error for ParseError {}
-
-impl ParseError {
-    pub fn span(&self) -> Option<Span> {
-        match self {
-            // ParseError::TokenError(_) => None,
-            ParseError::Unexpected(_, _) => None,
-            ParseError::UnexpectedEOF(_) => None,
-            ParseError::UnexpectedChar(_, s, _) => Some(*s),
-            ParseError::IncompleteString(_, s, _) => Some(*s),
-            ParseError::SyntaxError(_, s, _) => Some(*s),
-            ParseError::ArityMismatch(_, s, _) => Some(*s),
-        }
-    }
-
-    pub fn set_source(self, source: Option<Rc<PathBuf>>) -> Self {
-        use ParseError::*;
-        match self {
-            ParseError::Unexpected(l, _) => Unexpected(l, source),
-            ParseError::UnexpectedEOF(_) => UnexpectedEOF(source),
-            ParseError::UnexpectedChar(l, s, _) => UnexpectedChar(l, s, source),
-            ParseError::IncompleteString(l, s, _) => IncompleteString(l, s, source),
-            ParseError::SyntaxError(l, s, _) => SyntaxError(l, s, source),
-            ParseError::ArityMismatch(l, s, _) => ArityMismatch(l, s, source),
-        }
-    }
-}
-
-pub struct InternString;
-
-impl ToOwnedString<InternedString> for InternString {
-    fn own(&self, s: &str) -> InternedString {
-        s.into()
-    }
-}
-
-// #[derive(Debug)]
-pub struct Parser<'a> {
-    tokenizer: OwnedTokenStream<'a, InternedString, InternString>,
-    quote_stack: Vec<usize>,
-    quasiquote_depth: isize,
-    quote_context: bool,
-    shorthand_quote_stack: Vec<usize>,
-    source_name: Option<Rc<PathBuf>>,
-    context: Vec<ParsingContext>,
-    comment_buffer: Vec<&'a str>,
-    collecting_comments: bool,
-    keep_lists: bool,
-}
-
-#[derive(Debug, Copy, Clone, PartialEq)]
-enum ParsingContext {
-    // Inside of a quote. Expressions should be parsed without being coerced into a typed variant of the AST
-    Quote(usize),
-    // Shortened version of a quote
-    QuoteTick(usize),
-    // Inside of an unquote - expressions should actually be parsed as usual
-    Unquote(usize),
-    // Shortened version of unquote
-    UnquoteTick(usize),
-    // Treat this like a normal quote
-    Quasiquote(usize),
-    // Shortened version of quasiquote
-    QuasiquoteTick(usize),
-    // expressions should parsed as normal
-    UnquoteSplicing(usize),
-    // Shorted version of Unquote Splicing
-    UnquoteSplicingTick(usize),
-}
-
-impl<'a> Parser<'a> {
-    pub fn parse(expr: &str) -> Result<Vec<ExprKind>> {
-        Parser::new(expr, None).collect()
-    }
-
-    pub fn parse_without_lowering(expr: &str) -> Result<Vec<ExprKind>> {
-        Parser::new(expr, None).without_lowering().collect()
-    }
-
-    pub fn offset(&self) -> usize {
-        self.tokenizer.offset()
-    }
-}
-
-pub type Result<T> = result::Result<T, ParseError>;
-
-fn tokentype_error_to_parse_error(t: &Token<'_, InternedString>) -> ParseError {
-    if let TokenType::Error = t.ty {
-        println!("Found an error: {}", t.typ());
-
-        if t.source.starts_with('\"') {
-            ParseError::IncompleteString(t.source.to_string(), t.span, None)
-        } else {
-            ParseError::UnexpectedChar(t.source.chars().next().unwrap(), t.span, None)
-        }
-    } else {
-        ParseError::UnexpectedEOF(None)
-    }
-}
-
-impl<'a> Parser<'a> {
-    pub fn new(input: &'a str, source_id: Option<SourceId>) -> Self {
-        Parser {
-            tokenizer: TokenStream::new(input, false, source_id).into_owned(InternString),
-            quote_stack: Vec::new(),
-            quasiquote_depth: 0,
-            quote_context: false,
-            shorthand_quote_stack: Vec::new(),
-            source_name: None,
-            context: Vec::new(),
-            comment_buffer: Vec::new(),
-            collecting_comments: false,
-            keep_lists: false,
-        }
-    }
-
-    pub fn without_lowering(mut self) -> Self {
-        self.keep_lists = true;
-        self
-    }
-
-    pub fn new_flat(input: &'a str, source_id: Option<SourceId>) -> Self {
-        Parser {
-            tokenizer: TokenStream::new(input, false, source_id).into_owned(InternString),
-            quote_stack: Vec::new(),
-            quasiquote_depth: 0,
-            quote_context: false,
-            shorthand_quote_stack: Vec::new(),
-            source_name: None,
-            context: Vec::new(),
-            comment_buffer: Vec::new(),
-            collecting_comments: false,
-            keep_lists: true,
-        }
-    }
-
-    pub fn new_from_source(
-        input: &'a str,
-        source_name: PathBuf,
-        source_id: Option<SourceId>,
-    ) -> Self {
-        Parser {
-            tokenizer: TokenStream::new(input, false, source_id).into_owned(InternString),
-            quote_stack: Vec::new(),
-            quasiquote_depth: 0,
-            quote_context: false,
-            shorthand_quote_stack: Vec::new(),
-            source_name: Some(Rc::from(source_name)),
-            context: Vec::new(),
-            comment_buffer: Vec::new(),
-            collecting_comments: false,
-            keep_lists: false,
-        }
-    }
-
-    // Attach comments!
-    pub fn doc_comment_parser(input: &'a str, source_id: Option<SourceId>) -> Self {
-        Parser {
-            tokenizer: TokenStream::new(input, false, source_id).into_owned(InternString),
-            quote_stack: Vec::new(),
-            quasiquote_depth: 0,
-            quote_context: false,
-            shorthand_quote_stack: Vec::new(),
-            source_name: None,
-            context: Vec::new(),
-            comment_buffer: Vec::new(),
-            collecting_comments: false,
-            keep_lists: false,
-        }
-    }
-
-    fn construct_quote(&mut self, val: ExprKind, span: Span) -> ExprKind {
-        ExprKind::Quote(Box::new(ast::Quote::new(
-            val,
-            SyntaxObject::new(TokenType::Quote, span),
-        )))
-    }
-
-    fn _expand_reader_macro(
-        &mut self,
-        token: TokenType<InternedString>,
-        val: ExprKind,
-        span: Span,
-    ) -> ExprKind {
-        let q = ExprKind::Atom(Atom::new(SyntaxObject::new(token, span)));
-
-        ExprKind::List(List::new(vec![q, val]))
-    }
-
-    fn construct_quote_vec(&mut self, val: ExprKind, span: Span) -> Vec<ExprKind> {
-        // println!("Inside construct quote vec with: {:?}", val);
-
-        let q = {
-            let rc_val = TokenType::Quote;
-            ExprKind::Atom(Atom::new(SyntaxObject::new(rc_val, span)))
-            // let val = ExprKind::Atom(Atom::new(SyntaxObject::new(rc_val, span)));
-            // // self.intern.insert("quote".to_string(), rc_val);
-            // val
-        };
-
-        vec![q, val]
-    }
-
-    // Reader macro for `
-    fn construct_quasiquote(&mut self, val: ExprKind, span: Span) -> ExprKind {
-        let q = {
-            let rc_val = TokenType::Identifier(*QUASIQUOTE);
-            ExprKind::Atom(Atom::new(SyntaxObject::new(rc_val, span)))
-        };
-
-        ExprKind::List(List::new(vec![q, val]))
-    }
-
-    // Reader macro for ,
-    fn construct_unquote(&mut self, val: ExprKind, span: Span) -> ExprKind {
-        let q = {
-            let rc_val = TokenType::Identifier(*UNQUOTE);
-            ExprKind::Atom(Atom::new(SyntaxObject::new(rc_val, span)))
-        };
-
-        ExprKind::List(List::new(vec![q, val]))
-    }
-
-    fn construct_raw_unquote(&mut self, val: ExprKind, span: Span) -> ExprKind {
-        let q = {
-            // let rc_val = TokenType::Identifier(*UNQUOTE);
-            let rc_val = TokenType::Identifier(*RAW_UNQUOTE);
-            ExprKind::Atom(Atom::new(SyntaxObject::new(rc_val, span)))
-        };
-
-        ExprKind::List(List::new(vec![q, val]))
-    }
-    // Reader macro for ,@
-    fn construct_unquote_splicing(&mut self, val: ExprKind, span: Span) -> ExprKind {
-        let q = {
-            let rc_val = TokenType::Identifier(*UNQUOTE_SPLICING);
-            ExprKind::Atom(Atom::new(SyntaxObject::new(rc_val, span)))
-        };
-
-        ExprKind::List(List::new(vec![q, val]))
-    }
-
-    // Reader macro for ,@
-    fn construct_raw_unquote_splicing(&mut self, val: ExprKind, span: Span) -> ExprKind {
-        let q = {
-            let rc_val = TokenType::Identifier(*RAW_UNQUOTE_SPLICING);
-            ExprKind::Atom(Atom::new(SyntaxObject::new(rc_val, span)))
-        };
-
-        ExprKind::List(List::new(vec![q, val]))
-    }
-
-    fn increment_quasiquote_context_if_not_in_quote_context(&mut self) {
-        // println!("INCREMENTING");
-        if !self.quote_context {
-            self.quasiquote_depth += 1;
-        }
-    }
-
-    fn decrement_quasiquote_context_if_not_in_quote_context(&mut self) {
-        // println!("DECREMENTING");
-        if !self.quote_context {
-            self.quasiquote_depth -= 1;
-        }
-    }
-
-    fn maybe_lower(&self, expr: Vec<ExprKind>) -> Result<ExprKind> {
-        if self.keep_lists {
-            Ok(ExprKind::List(List::new(expr)))
-        } else {
-            ExprKind::try_from(expr)
-        }
-    }
-
-    fn read_from_tokens(&mut self) -> Result<ExprKind> {
-        let mut stack: Vec<Vec<ExprKind>> = Vec::new();
-        let mut current_frame: Vec<ExprKind> = Vec::new();
-
-        self.quote_stack = Vec::new();
-
-        // println!("READING FROM TOKENS");
-        // self.quasiquote_depth = 0;
-
-        loop {
-            match self.tokenizer.next() {
-                Some(token) => {
-                    match token.ty {
-                        TokenType::Comment => {
-                            // println!("Found a comment!");
-                            // Internal comments, we're gonna skip for now
-                            continue;
-                        }
-                        TokenType::Error => return Err(tokentype_error_to_parse_error(&token)), // TODO
-                        TokenType::QuoteTick => {
-                            // quote_count += 1;
-                            // self.quote_stack.push(current_frame.len());
-                            self.shorthand_quote_stack.push(stack.len());
-
-                            let last_context = self.quote_context;
-
-                            if self.quasiquote_depth == 0 {
-                                self.quote_context = true;
-                            }
-
-                            // println!("Entering context: Quote Tick in read from tokens");
-
-                            self.context.push(ParsingContext::QuoteTick(stack.len()));
-
-                            let quote_inner = self
-                                .next()
-                                .unwrap_or(Err(ParseError::UnexpectedEOF(self.source_name.clone())))
-                                .map(|x| {
-                                    // if self.quasiquote_depth == 0 {
-                                    self.construct_quote(x, token.span)
-                                    // } else {
-                                    // self.construct_fake_quote(x, token.span)
-                                    // }
-                                });
-                            // self.quote_stack.pop();
-                            self.shorthand_quote_stack.pop();
-
-                            self.quote_context = last_context;
-
-                            // println!(
-                            //     "Exiting Context: {:?} in read from tokens",
-                            //     self.context.pop()
-                            // );
-
-                            // self.context.pop();
-
-                            let popped_value = self.context.pop();
-
-                            if let Some(popped) = popped_value {
-                                // dbg!(&popped);
-                                debug_assert!(matches!(popped, ParsingContext::QuoteTick(_)))
-                            }
-
-                            current_frame.push(quote_inner?);
-                        }
-                        TokenType::Unquote => {
-                            // println!("Entering context: Unquote");
-
-                            // This could underflow and panic - if its negative then we have a problem. Maybe just use an isize and let it underflow?
-                            self.decrement_quasiquote_context_if_not_in_quote_context();
-
-                            self.context.push(ParsingContext::UnquoteTick(stack.len()));
-
-                            let quote_inner = self
-                                .next()
-                                .unwrap_or(Err(ParseError::UnexpectedEOF(self.source_name.clone())))
-                                .map(|x| {
-                                    // dbg!(self.quasiquote_depth);
-                                    // dbg!(self.quote_context);
-                                    if self.quasiquote_depth == 0 && !self.quote_context {
-                                        self.construct_raw_unquote(x, token.span)
-                                    } else {
-                                        self.construct_unquote(x, token.span)
-                                    }
-                                });
-
-                            let popped_value = self.context.pop();
-
-                            self.increment_quasiquote_context_if_not_in_quote_context();
-
-                            if let Some(popped) = popped_value {
-                                debug_assert!(matches!(popped, ParsingContext::UnquoteTick(_)))
-                            }
-                            // println!("Exiting Context: {:?}", self.context.pop());
-                            current_frame.push(quote_inner?);
-                        }
-                        TokenType::QuasiQuote => {
-                            // println!("Entering context: Quasiquote");
-
-                            self.increment_quasiquote_context_if_not_in_quote_context();
-
-                            self.context
-                                .push(ParsingContext::QuasiquoteTick(stack.len()));
-
-                            let quote_inner = self
-                                .next()
-                                .unwrap_or(Err(ParseError::UnexpectedEOF(self.source_name.clone())))
-                                .map(|x| self.construct_quasiquote(x, token.span));
-
-                            // self.context.pop();
-                            // println!(
-                            //     ">>>>>>>>>>>>>>>>>>> Exiting Context: {:?}",
-                            //     self.context.pop()
-                            // );
-
-                            let popped_value = self.context.pop();
-
-                            self.decrement_quasiquote_context_if_not_in_quote_context();
-
-                            if let Some(popped) = popped_value {
-                                // println!("Popped: {:?}", popped);
-                                debug_assert!(matches!(popped, ParsingContext::QuasiquoteTick(_)))
-                            }
-
-                            current_frame.push(quote_inner?);
-                        }
-                        TokenType::UnquoteSplice => {
-                            // println!("Entering context: UnquoteSplicing");
-
-                            self.decrement_quasiquote_context_if_not_in_quote_context();
-
-                            self.context
-                                .push(ParsingContext::UnquoteSplicingTick(stack.len()));
-
-                            let quote_inner = self
-                                .next()
-                                .unwrap_or(Err(ParseError::UnexpectedEOF(self.source_name.clone())))
-                                .map(|x| {
-                                    if self.quasiquote_depth == 0 && !self.quote_context {
-                                        self.construct_raw_unquote_splicing(x, token.span)
-                                    } else {
-                                        self.construct_unquote_splicing(x, token.span)
-                                    }
-                                });
-
-                            // self.context.pop();
-
-                            let popped_value = self.context.pop();
-
-                            self.increment_quasiquote_context_if_not_in_quote_context();
-
-                            if let Some(popped) = popped_value {
-                                debug_assert!(matches!(
-                                    popped,
-                                    ParsingContext::UnquoteSplicingTick(_)
-                                ))
-                            }
-
-                            // println!("Exiting Context: {:?}", self.context.pop());
-                            current_frame.push(quote_inner?);
-                        }
-                        TokenType::OpenParen => {
-                            stack.push(current_frame);
-                            current_frame = Vec::new();
-                        }
-                        TokenType::CloseParen => {
-                            // This is the match that we'll want to move inside the below stack.pop() match statement
-                            // As we close the current context, we check what our current state is -
-
-                            if let Some(mut prev_frame) = stack.pop() {
-                                match prev_frame.first_mut().and_then(|x| x.atom_identifier_mut()) {
-                                    Some(ident) if *ident == *UNQUOTE => {
-                                        // self.increment_quasiquote_context_if_not_in_quote_context();
-                                        if self.quasiquote_depth == 0 && !self.quote_context {
-                                            *ident = *RAW_UNQUOTE;
-                                        }
-                                        self.increment_quasiquote_context_if_not_in_quote_context();
-
-                                        // println!("Exiting unquote");
-                                    }
-                                    Some(ident) if *ident == *QUASIQUOTE => {
-                                        self.decrement_quasiquote_context_if_not_in_quote_context();
-
-                                        // println!("Exiting quasiquote");
-                                    }
-                                    Some(ident) if *ident == *UNQUOTE_SPLICING => {
-                                        // self.increment_quasiquote_context_if_not_in_quote_context();
-
-                                        if self.quasiquote_depth == 0 && !self.quote_context {
-                                            *ident = *RAW_UNQUOTE_SPLICING;
-                                        }
-                                        self.increment_quasiquote_context_if_not_in_quote_context();
-
-                                        // println!("Exiting unquote");
-                                    }
-                                    _ => {}
-                                }
-
-                                match self.context.last().cloned() {
-                                    // TODO: Change this -> This should really be just Some(ParsingContext::Quote)
-                                    // If we have _anything_ then we should check if we need to parse it differently. If we're at the last_quote_index,
-                                    // then we can pop it off inside there.
-                                    Some(ParsingContext::Quote(last_quote_index))
-                                    | Some(ParsingContext::Quasiquote(last_quote_index)) => {
-                                        if stack.len() <= last_quote_index {
-                                            self.context.pop();
-                                        }
-
-                                        match current_frame.first() {
-                                            Some(ExprKind::Atom(Atom {
-                                                syn:
-                                                    SyntaxObject {
-                                                        ty: TokenType::Quote,
-                                                        ..
-                                                    },
-                                            })) => match self.context.last() {
-                                                Some(
-                                                    ParsingContext::Quasiquote(_)
-                                                    | ParsingContext::QuasiquoteTick(_)
-                                                    | ParsingContext::Quote(_)
-                                                    | ParsingContext::QuoteTick(_),
-                                                ) => prev_frame
-                                                    .push(ExprKind::List(List::new(current_frame))),
-                                                _ => {
-                                                    prev_frame.push(
-                                                        self.maybe_lower(current_frame).map_err(
-                                                            |x| {
-                                                                x.set_source(
-                                                                    self.source_name.clone(),
-                                                                )
-                                                            },
-                                                        )?,
-                                                    );
-                                                }
-                                            },
-                                            _ => {
-                                                // println!("Converting to list");
-                                                // println!("Context here: {:?}", self.context);
-                                                prev_frame
-                                                    .push(ExprKind::List(List::new(current_frame)))
-                                            }
-                                        }
-                                    }
-
-                                    Some(ParsingContext::QuoteTick(_))
-                                    | Some(ParsingContext::QuasiquoteTick(_)) => {
-                                        match current_frame.first() {
-                                            Some(ExprKind::Atom(Atom {
-                                                syn:
-                                                    SyntaxObject {
-                                                        ty: TokenType::Quote,
-                                                        ..
-                                                    },
-                                            })) => {
-                                                // println!("Converting to quote inside quote tick");
-                                                prev_frame.push(
-                                                    self.maybe_lower(current_frame).map_err(
-                                                        |x| x.set_source(self.source_name.clone()),
-                                                    )?,
-                                                );
-                                            }
-                                            _ => {
-                                                // if let Some(ParsingContext::QuasiquoteTick(_)) =
-                                                //     self.context.last()
-                                                // {
-                                                //     self.decrement_quasiquote_context_if_not_in_quote_context();
-                                                // }
-
-                                                // println!("Converting to list inside quote tick");
-                                                prev_frame
-                                                    .push(ExprKind::List(List::new(current_frame)))
-                                            }
-                                        }
-                                    }
-
-                                    // If we're in the short hand reader world, just ignore popping off the stack
-                                    // but still treat it as a normal expression
-                                    Some(ParsingContext::UnquoteTick(_))
-                                    | Some(ParsingContext::UnquoteSplicingTick(_)) => {
-                                        // self.quasiquote_depth += 1;
-
-                                        // self.increment_quasiquote_context_if_not_in_quote_context();
-
-                                        // println!(
-                                        //     "UQ/UQS: Stack length: {:?}, last_quote_index: {:?}",
-                                        //     stack.len(),
-                                        //     last_quote_index
-                                        // );
-
-                                        // if stack.len() <= *last_quote_index {
-                                        //     // println!("Exiting Context: {:?}", self.context.pop());
-                                        //     self.context.pop();
-                                        // }
-
-                                        prev_frame.push(
-                                            self.maybe_lower(current_frame).map_err(|x| {
-                                                x.set_source(self.source_name.clone())
-                                            })?,
-                                        );
-                                    }
-
-                                    Some(ParsingContext::Unquote(last_quote_index))
-                                    | Some(ParsingContext::UnquoteSplicing(last_quote_index)) => {
-                                        // self.quasiquote_depth += 1;
-
-                                        // self.increment_quasiquote_context_if_not_in_quote_context();
-
-                                        // println!(
-                                        //     "UQ/UQS: Stack length: {:?}, last_quote_index: {:?}",
-                                        //     stack.len(),
-                                        //     last_quote_index
-                                        // );
-
-                                        if stack.len() <= last_quote_index {
-                                            // println!("{} - {}", stack.len(), last_quote_index);
-                                            // println!("Exiting Context: {:?}", self.context.pop());
-                                            self.context.pop();
-                                        }
-
-                                        prev_frame.push(
-                                            self.maybe_lower(current_frame).map_err(|x| {
-                                                x.set_source(self.source_name.clone())
-                                            })?,
-                                        );
-                                    }
-
-                                    // Else case, just go ahead and assume it is a normal frame
-                                    _ => prev_frame.push(
-                                        self.maybe_lower(current_frame)
-                                            .map_err(|x| x.set_source(self.source_name.clone()))?,
-                                    ),
-                                }
-
-                                // Reinitialize current frame here
-                                current_frame = prev_frame;
-                            } else {
-                                // println!("Else case: {:?}", current_frame);
-                                // println!("Context: {:?}", self.context);
-
-                                // dbg!(&self.quote_stack);
-                                // dbg!(&self.context);
-                                // dbg!(&self.shorthand_quote_stack);
-                                match self.context.last() {
-                                    Some(ParsingContext::QuoteTick(_))
-                                    | Some(ParsingContext::QuasiquoteTick(_)) => {
-                                        // | Some(ParsingContext::Quote(d)) && d > 0 => {
-
-                                        return Ok(ExprKind::List(List::new(current_frame)));
-                                    }
-                                    Some(ParsingContext::Quote(x)) if *x > 0 => {
-                                        self.context.pop();
-
-                                        return Ok(ExprKind::List(List::new(current_frame)));
-                                    }
-                                    Some(ParsingContext::Quote(0)) => {
-                                        self.context.pop();
-
-                                        return self
-                                            .maybe_lower(current_frame)
-                                            .map_err(|x| x.set_source(self.source_name.clone()));
-                                    }
-                                    _ => {
-                                        // dbg!(self.quasiquote_depth);
-                                        // println!("=> {}", List::new(current_frame.clone()));
-                                        // println!("----------------------------------------");
-
-                                        if self.quasiquote_depth > 0 {
-                                            // TODO/HACK - @Matt
-                                            // If we're in a define syntax situation, go ahead and just return a normal one
-                                            if current_frame
-                                                .first()
-                                                .map(|x| x.define_syntax_ident())
-                                                .unwrap_or_default()
-                                            {
-                                                return self.maybe_lower(current_frame).map_err(
-                                                    |x| x.set_source(self.source_name.clone()),
-                                                );
-                                            }
-
-                                            // println!("Should still be quoted here");
-
-                                            return Ok(ExprKind::List(List::new(current_frame)));
-                                        }
-
-                                        return self
-                                            .maybe_lower(current_frame)
-                                            .map_err(|x| x.set_source(self.source_name.clone()));
-                                    }
-                                }
-                            }
-                        }
-
-                        _ => {
-                            if let TokenType::Quote = &token.ty {
-                                // self.quote_stack.push(current_frame.len());
-                                self.quote_stack.push(stack.len());
-                            }
-
-                            // dbg!(&self.context);
-
-                            // Mark what context we're inside with the context stack:
-                            // This only works when its the first argument - check the function call in open paren?
-                            if current_frame.is_empty() {
-                                match &token.ty {
-                                    TokenType::Quote => {
-                                        if self.context == &[ParsingContext::QuoteTick(0)] {
-                                            self.context.push(ParsingContext::Quote(1))
-                                        } else {
-                                            self.context.push(ParsingContext::Quote(stack.len()))
-                                        }
-
-                                        // self.context.push(ParsingContext::Quote(stack.len()))
-                                    }
-                                    TokenType::Identifier(ident) if *ident == *UNQUOTE => {
-                                        // println!("Entering unquote");
-
-                                        self.context.push(ParsingContext::Unquote(stack.len()));
-                                        self.decrement_quasiquote_context_if_not_in_quote_context();
-                                    }
-                                    TokenType::Identifier(ident) if *ident == *QUASIQUOTE => {
-                                        // println!("Entering quasiquote");
-
-                                        self.context.push(ParsingContext::Quasiquote(stack.len()));
-                                        self.increment_quasiquote_context_if_not_in_quote_context();
-                                    }
-                                    TokenType::Identifier(ident) if *ident == *UNQUOTE_SPLICING => {
-                                        self.context
-                                            .push(ParsingContext::UnquoteSplicing(stack.len()));
-                                        self.decrement_quasiquote_context_if_not_in_quote_context();
-                                    }
-                                    _ => {}
-                                }
-
-                                // println!("Context on application: {:?}", self.context);
-                            }
-
-                            // println!("{}", token);
-
-                            current_frame.push(ExprKind::Atom(Atom::new(
-                                SyntaxObject::from_token_with_source(
-                                    &token,
-                                    &self.source_name.clone(),
-                                ),
-                            )))
-                        }
-                    }
-                }
-
-                None => return Err(ParseError::UnexpectedEOF(self.source_name.clone())),
-            }
-        }
-    }
-}
-
-fn wrap_in_doc_function(expr: ExprKind, comment: String) -> ExprKind {
-    // println!("Found comment : {} for expr {}", comment, expr);
-
-    ExprKind::List(List::new(vec![
-        ExprKind::ident("@doc"),
-        ExprKind::string_lit(comment),
-        expr,
-    ]))
-}
-
-impl<'a> Parser<'a> {
-    fn get_next_and_maybe_wrap_in_doc(&mut self) -> Option<Result<ExprKind>> {
-        let mut next;
-
-        loop {
-            next = self.tokenizer.next();
-
-            if let Some(res) = next {
-                match res.ty {
-                    TokenType::Comment => {
-                        if self.comment_buffer.is_empty() && !self.collecting_comments {
-                            if res.source().trim_start_matches(';').starts_with("@doc") {
-                                self.collecting_comments = true;
-
-                                continue;
-                            }
-                        }
-
-                        if self.collecting_comments {
-                            let doc_line = res.source().trim_start_matches(';');
-
-                            // If we hit another comment, clear it
-                            if doc_line.starts_with("@doc") {
-                                // println!("Clearing buffer");
-
-                                self.comment_buffer.clear();
-                                continue;
-                            }
-
-                            // println!("Collecting line: {}", doc_line);
-
-                            self.comment_buffer.push(doc_line.trim_start());
-                        }
-
-                        continue;
-                    }
-
-                    TokenType::QuoteTick => {
-                        // See if this does the job
-                        self.shorthand_quote_stack.push(0);
-
-                        let last = self.quote_context;
-
-                        if self.quasiquote_depth == 0 {
-                            self.quote_context = true;
-                        }
-
-                        // self.quote_context = true;
-
-                        // println!("Entering Context: Quote Tick");
-                        self.context.push(ParsingContext::QuoteTick(0));
-
-                        let value = self
-                            .next()
-                            .unwrap_or(Err(ParseError::UnexpectedEOF(self.source_name.clone())))
-                            .map(|x| self.construct_quote_vec(x, res.span));
-
-                        self.shorthand_quote_stack.pop();
-
-                        let popped_value = self.context.pop();
-
-                        if let Some(popped) = popped_value {
-                            // dbg!(&popped);
-                            debug_assert!(matches!(popped, ParsingContext::QuoteTick(_)))
-                        }
-
-                        self.quote_context = last;
-
-                        // println!("Exiting context: {:?}", self.context.pop());
-                        // println!("Result: {:?}", value);
-
-                        // println!("{}", List::new(value.clone().unwrap()));
-
-                        return Some(match value {
-                            Ok(v) => {
-                                // Ok(ExprKind::List(List::new(v)))
-
-                                self.maybe_lower(v)
-                            }
-                            Err(e) => Err(e),
-                        });
-                    }
-
-                    TokenType::Unquote => {
-                        // println!("Entering Context: Unquote");
-                        self.context.push(ParsingContext::UnquoteTick(0));
-
-                        self.decrement_quasiquote_context_if_not_in_quote_context();
-
-                        let value = self
-                            .next()
-                            .unwrap_or(Err(ParseError::UnexpectedEOF(self.source_name.clone())))
-                            .map(|x| {
-                                // dbg!(&self.quasiquote_depth);
-                                if self.quasiquote_depth == 0 && !self.quote_context {
-                                    self.construct_raw_unquote(x, res.span)
-                                } else {
-                                    self.construct_unquote(x, res.span)
-                                }
-                            });
-
-                        let popped_value = self.context.pop();
-
-                        self.increment_quasiquote_context_if_not_in_quote_context();
-
-                        if let Some(popped) = popped_value {
-                            debug_assert!(matches!(popped, ParsingContext::UnquoteTick(_)))
-                        }
-                        // println!("Exiting context: {:?}", self.context.pop());
-
-                        return Some(value);
-                    }
-
-                    TokenType::UnquoteSplice => {
-                        // println!("Entering Context: Unquotesplicing");
-                        self.context.push(ParsingContext::UnquoteSplicingTick(0));
-
-                        self.decrement_quasiquote_context_if_not_in_quote_context();
-
-                        let value = self
-                            .next()
-                            .unwrap_or(Err(ParseError::UnexpectedEOF(self.source_name.clone())))
-                            .map(|x| {
-                                if self.quasiquote_depth == 0 && !self.quote_context {
-                                    self.construct_raw_unquote_splicing(x, res.span)
-                                } else {
-                                    self.construct_unquote_splicing(x, res.span)
-                                }
-                            });
-
-                        let popped_value = self.context.pop();
-
-                        self.increment_quasiquote_context_if_not_in_quote_context();
-
-                        if let Some(popped) = popped_value {
-                            debug_assert!(matches!(popped, ParsingContext::UnquoteSplicingTick(_)))
-                        }
-
-                        // println!("Exiting context: {:?}", self.context.pop());
-
-                        return Some(value);
-                    }
-
-                    TokenType::QuasiQuote => {
-                        // println!("Entering Context: Quasiquote - top level");
-                        self.context.push(ParsingContext::QuasiquoteTick(0));
-
-                        self.increment_quasiquote_context_if_not_in_quote_context();
-
-                        let value = self
-                            .next()
-                            .unwrap_or(Err(ParseError::UnexpectedEOF(self.source_name.clone())))
-                            .map(|x| self.construct_quasiquote(x, res.span));
-
-                        // println!("{:?}", self.context.pop());
-
-                        // println!("Top level Context: {:?}", self.context);
-
-                        let popped_value = self.context.pop();
-
-                        if let Some(popped) = popped_value {
-                            debug_assert!(matches!(popped, ParsingContext::QuasiquoteTick(_)))
-                        }
-
-                        self.decrement_quasiquote_context_if_not_in_quote_context();
-
-                        // println!("Exiting context: {:?}", self.context.pop());
-
-                        return Some(value);
-                    }
-
-                    TokenType::OpenParen => {
-                        let value = self.read_from_tokens();
-
-                        // self.quote_stack.clear();
-                        // self.context.clear();
-
-                        return Some(value);
-                    }
-                    TokenType::CloseParen => {
-                        return Some(Err(ParseError::Unexpected(
-                            TokenType::CloseParen,
-                            self.source_name.clone(),
-                        )))
-                    }
-                    TokenType::Error => return Some(Err(tokentype_error_to_parse_error(&res))),
-                    _ => return Some(Ok(ExprKind::Atom(Atom::new(SyntaxObject::from(&res))))),
-                };
-            } else {
-                // We're done consuming input
-                return None;
-            }
-        }
-    }
-}
-
-impl<'a> Iterator for Parser<'a> {
-    type Item = Result<ExprKind>;
-
-    // TODO -> put the
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.quote_stack.is_empty()
-            && self.shorthand_quote_stack.is_empty()
-            && self.context.is_empty()
-        {
-            self.quasiquote_depth = 0;
-            self.comment_buffer.clear();
-        }
-
-        self.get_next_and_maybe_wrap_in_doc().map(|res| {
-            if self.comment_buffer.is_empty() || !self.context.is_empty() {
-                res
-            } else {
-                // Reset the comment collection until next @doc statement
-                self.collecting_comments = false;
-                res.map(|x| {
-                    // println!("Wrapping in doc: {}", x);
-                    let result = wrap_in_doc_function(
-                        x,
-                        self.comment_buffer.drain(..).collect::<Vec<_>>().join("\n"),
-                    );
-
-                    result
-                })
-            }
-        })
-    }
-}
-
-// Lower the syntax rules down from the list representation
-pub fn lower_syntax_rules(expr: ExprKind) -> Result<SyntaxRules> {
-    let mut value_iter = expr.into_list().into_iter();
-    let syn = value_iter
-        .next()
-        .unwrap()
-        .into_atom_syntax_object()
-        .unwrap();
-
-    let syntax_vec = if let Some(ExprKind::List(l)) = value_iter.next() {
-        l.args
-    } else {
-        return Err(ParseError::SyntaxError(
-            "syntax-rules expects a list of new syntax forms used in the macro".to_string(),
-            syn.span,
-            None,
-        ));
-    };
-
-    let mut pairs = Vec::new();
-    let rest: Vec<_> = value_iter.collect();
-
-    for pair in rest {
-        if let ExprKind::List(l) = pair {
-            if l.args.len() != 2 {
-                return Err(ParseError::SyntaxError(
-                    "syntax-rules requires only one pattern to one body".to_string(),
-                    syn.span,
-                    None,
-                ));
-            }
-
-            let mut pair_iter = l.args.into_iter();
-            let pair_object =
-                PatternPair::new(pair_iter.next().unwrap(), pair_iter.next().unwrap());
-            pairs.push(pair_object);
-        } else {
-            return Err(ParseError::SyntaxError(
-                "syntax-rules requires pattern to expressions to be in a list".to_string(),
-                syn.span,
-                None,
-            ));
-        }
-    }
-
-    Ok(SyntaxRules::new(syntax_vec, pairs, syn))
-}
-
-// Lower define-syntax down from the list representation
-pub fn lower_macro_and_require_definitions(expr: ExprKind) -> Result<ExprKind> {
-    let as_list = expr.list();
-
-    // If this qualifies as
-    if as_list.map(List::is_define_syntax).unwrap_or_default()
-        && as_list
-            .unwrap()
-            .get(2)
-            .and_then(ExprKind::list)
-            .map(List::is_syntax_rules)
-            .unwrap_or_default()
-    {
-        let mut value_iter = expr.into_list().into_iter();
-
-        let define_syntax = value_iter.next().unwrap();
-
-        let name = value_iter.next().unwrap();
-        let syntax = lower_syntax_rules(value_iter.next().unwrap())?;
-
-        return Ok(ExprKind::Macro(Box::new(Macro::new(
-            name,
-            Box::new(syntax),
-            define_syntax.into_atom_syntax_object().unwrap(),
-        ))));
-    }
-
-    if as_list.map(List::is_require).unwrap_or_default() {
-        let mut raw = expr.into_list().args;
-
-        let syn = raw.remove(0).into_atom_syntax_object().unwrap();
-
-        if raw.is_empty() {
-            return Err(ParseError::ArityMismatch(
-                "require expects at least one identifier or string".to_string(),
-                syn.span,
-                None,
-            ));
-        }
-
-        return Ok(ExprKind::Require(ast::Require::new(raw, syn)));
-    }
-
-    Ok(expr)
-}
-
-struct ASTLowerPass {
-    quote_depth: usize,
-}
-
-impl ASTLowerPass {
-    // TODO: Make this mutable references, otherwise we'll be re-boxing everything for now reason
-    fn lower(&mut self, expr: ExprKind) -> Result<ExprKind> {
-        match expr {
-            ExprKind::List(mut value) => {
-                if value.is_quote() {
-                    // println!("Found quote: {:?}", value);
-                    self.quote_depth += 1;
-                }
-
-                // Visit the children first, on the way back up, assign into the
-                // correct AST node
-                value.args = value
-                    .args
-                    .into_iter()
-                    .map(|x| self.lower(x))
-                    .collect::<Result<_>>()?;
-
-                if value.is_quote() {
-                    self.quote_depth -= 1;
-                }
-
-                if let Some(f) = value.first().cloned() {
-                    // println!("Value: {}", f);
-
-                    match f {
-                        ExprKind::Atom(a) if self.quote_depth == 0 && value.is_quote() => {
-                            match &a.syn.ty {
-                                TokenType::Quote => parse_single_argument(
-                                    value.into_iter(),
-                                    a.syn.clone(),
-                                    "quote",
-                                    |expr, syn| ast::Quote::new(expr, syn).into(),
-                                ),
-                                _ => unreachable!(),
-                            }
-                        }
-                        ExprKind::Atom(a) if self.quote_depth == 0 => {
-                            match &a.syn.ty {
-                                TokenType::If => parse_if(value.into_iter(), a.syn.clone()),
-                                TokenType::Identifier(expr) if *expr == *IF => {
-                                    parse_if(value.into_iter(), a.syn.clone())
-                                }
-
-                                TokenType::Define => parse_define(value.into_iter(), a.syn.clone()),
-                                TokenType::Identifier(expr) if *expr == *DEFINE => {
-                                    parse_define(value.into_iter(), a.syn.clone())
-                                }
-
-                                TokenType::Let => parse_let(value.into_iter(), a.syn.clone()),
-                                TokenType::Identifier(expr) if *expr == *LET => {
-                                    parse_let(value.into_iter(), a.syn.clone())
-                                }
-
-                                // TODO: Deprecate
-                                TokenType::TestLet => {
-                                    parse_new_let(value.into_iter(), a.syn.clone())
-                                }
-                                TokenType::Identifier(expr) if *expr == *PLAIN_LET => {
-                                    parse_new_let(value.into_iter(), a.syn.clone())
-                                }
-
-                                TokenType::Quote => parse_single_argument(
-                                    value.into_iter(),
-                                    a.syn.clone(),
-                                    "quote",
-                                    |expr, syn| ast::Quote::new(expr, syn).into(),
-                                ),
-                                TokenType::Identifier(expr) if *expr == *QUOTE => {
-                                    parse_single_argument(
-                                        value.into_iter(),
-                                        a.syn.clone(),
-                                        "quote",
-                                        |expr, syn| ast::Quote::new(expr, syn).into(),
-                                    )
-                                }
-
-                                TokenType::Return => parse_single_argument(
-                                    value.into_iter(),
-                                    a.syn.clone(),
-                                    "return!",
-                                    |expr, syn| ast::Return::new(expr, syn).into(),
-                                ),
-                                TokenType::Identifier(expr) if *expr == *RETURN => {
-                                    parse_single_argument(
-                                        value.into_iter(),
-                                        a.syn.clone(),
-                                        "return!",
-                                        |expr, syn| ast::Return::new(expr, syn).into(),
-                                    )
-                                }
-
-                                TokenType::Require => parse_require(&a, value.args),
-                                TokenType::Identifier(expr) if *expr == *REQUIRE => {
-                                    parse_require(&a, value.args)
-                                }
-
-                                TokenType::Set => parse_set(&a, value.args),
-                                TokenType::Identifier(expr) if *expr == *SET => {
-                                    parse_set(&a, value.args)
-                                }
-
-                                TokenType::Begin => parse_begin(&a, value.args),
-                                TokenType::Identifier(expr) if *expr == *BEGIN => {
-                                    parse_begin(&a, value.args)
-                                }
-
-                                TokenType::Lambda => parse_lambda(&a, value.args),
-                                TokenType::Identifier(expr)
-                                    if *expr == *LAMBDA
-                                        || *expr == *LAMBDA_FN
-                                        || *expr == *LAMBDA_SYMBOL =>
-                                {
-                                    parse_lambda(&a, value.args)
-                                }
-
-                                _ => Ok(ExprKind::List(value)),
-                            }
-                        }
-                        _ => Ok(ExprKind::List(value)),
-                    }
-                } else {
-                    Ok(ExprKind::List(List::new(vec![])))
-                }
-            }
-            ExprKind::Atom(_) => Ok(expr),
-            ExprKind::If(iff) => Ok(ExprKind::If(Box::new(ast::If::new(
-                self.lower(iff.test_expr)?,
-                self.lower(iff.then_expr)?,
-                self.lower(iff.else_expr)?,
-                iff.location,
-            )))),
-            ExprKind::Let(l) => Ok(ExprKind::Let(Box::new(ast::Let::new(
-                l.bindings
-                    .into_iter()
-                    .map(|(a, b)| Ok((self.lower(a)?, self.lower(b)?)))
-                    .collect::<Result<_>>()?,
-                self.lower(l.body_expr)?,
-                l.location,
-            )))),
-            ExprKind::Define(d) => Ok(ExprKind::Define(Box::new(ast::Define::new(
-                self.lower(d.name)?,
-                self.lower(d.body)?,
-                d.location,
-            )))),
-            ExprKind::LambdaFunction(f) => Ok(ExprKind::LambdaFunction(Box::new(
-                ast::LambdaFunction::new_maybe_rest(
-                    f.args
-                        .into_iter()
-                        .map(|x| self.lower(x))
-                        .collect::<Result<_>>()?,
-                    self.lower(f.body)?,
-                    f.location,
-                    f.rest,
-                ),
-            ))),
-            ExprKind::Begin(b) => Ok(ExprKind::Begin(ast::Begin::new(
-                b.exprs
-                    .into_iter()
-                    .map(|x| self.lower(x))
-                    .collect::<Result<_>>()?,
-                b.location,
-            ))),
-            ExprKind::Return(r) => Ok(ExprKind::Return(Box::new(ast::Return::new(
-                self.lower(r.expr)?,
-                r.location,
-            )))),
-            ExprKind::Quote(_) => Ok(expr),
-            ExprKind::Macro(_) => Ok(expr),
-            ExprKind::SyntaxRules(_) => Ok(expr),
-            ExprKind::Set(s) => Ok(ExprKind::Set(Box::new(ast::Set::new(
-                self.lower(s.variable)?,
-                self.lower(s.expr)?,
-                s.location,
-            )))),
-            ExprKind::Require(_) => Ok(expr), // _ => Ok(expr),
-        }
-    }
-}
-
-// TODO: Lower the rest of the AST post expansion, such that
-pub fn lower_entire_ast(expr: ExprKind) -> Result<ExprKind> {
-    ASTLowerPass { quote_depth: 0 }.lower(expr)
-}
-
-#[cfg(test)]
-mod parser_tests {
-    // use super::TokenType::*;
-    use super::*;
-    use crate::parser::ast::{Begin, Define, If, LambdaFunction, Quote, Return};
-    use crate::{parser::ast::ExprKind, tokens::MaybeBigInt};
-
-    fn atom(ident: &str) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::Identifier(
-            ident.into(),
-        ))))
-    }
-
-    fn int(num: isize) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::IntegerLiteral(
-            MaybeBigInt::Small(num),
-        ))))
-    }
-
-    fn character(c: char) -> ExprKind {
-        ExprKind::Atom(Atom::new(SyntaxObject::default(
-            TokenType::CharacterLiteral(c),
-        )))
-    }
-
-    #[test]
-    fn check_quote_parsing() {
-        println!("{:?}", Parser::parse("'(a b 'c)"));
-    }
-
-    fn parses(s: &str) {
-        let a: Result<Vec<_>> = Parser::new(s, None).collect();
-        a.unwrap();
-    }
-
-    fn assert_parse(s: &str, result: &[ExprKind]) {
-        let a: Result<Vec<ExprKind>> = Parser::new(s, None).collect();
-        let a = a.unwrap();
-        assert_eq!(a.as_slice(), result);
-    }
-
-    fn assert_parse_err(s: &str, err: ParseError) {
-        let a: Result<Vec<ExprKind>> = Parser::new(s, None).collect();
-        assert_eq!(a, Err(err));
-    }
-
-    fn assert_parse_is_err(s: &str) {
-        let a: Result<Vec<ExprKind>> = Parser::new(s, None).collect();
-        assert!(a.is_err());
-    }
-
-    #[test]
-    fn check_resulting_parsing() {
-        let expr = r#"`(a `(b ,(+ 1 2) ,(foo ,(+ 1 3) d) e) f)"#;
-
-        let a: Result<Vec<ExprKind>> = Parser::new(expr, None).collect();
-        let a = a.unwrap();
-
-        println!("{}", a[0]);
-    }
-
-    #[test]
-    fn check_double_unquote_parsing() {
-        let expr = r#"(let ([name1 'x] [name2 'y]) `(a `(b ,,name1 ,',name2 d) e))"#;
-
-        let a: Result<Vec<ExprKind>> = Parser::new(expr, None).collect();
-        let a = a.unwrap();
-
-        println!("{}", a[0]);
-    }
-
-    #[test]
-    fn check_parser_with_doc_comments() {
-        let expr = r#"
-        ;;@doc
-        ;; This is a fancy cool comment, that I want to attach to a top level definition!
-        ;; This is the second line of the comment, I want this attached as well!
-        ;; Macro for creating a new struct, in the form of:
-        ;; `(struct <struct-name> (fields ...) options ...)`
-        ;; The options can consist of the following:
-        ;;
-        ;; Single variable options (those which their presence indicates #true)
-        ;; - #:mutable
-        ;; - #:transparent
-        ;;
-        ;; Other options must be presented as key value pairs, and will get stored
-        ;; in the struct instance. They will also be bound to the variable
-        ;; ___<struct-name>-options___ in the same lexical environment where the
-        ;; struct was defined. For example:
-        ;;
-        ;; (Applesauce (a b c) #:mutable #:transparent #:unrecognized-option 1234)
-        ;;
-        ;; Will result in the value `___Applesauce-options___` like so:
-        ;; (hash #:mutable #true #:transparent #true #:unrecognized-option 1234)
-        ;;
-        ;; By default, structs are immutable, which means setter functions will not
-        ;; be generated. Also by default, structs are not transparent, which means
-        ;; printing them will result in an opaque struct that does not list the fields
-        (define foo 12345)
-        "#;
-
-        let parser = Parser::doc_comment_parser(expr, None);
-
-        let result: Result<Vec<_>> = parser.collect();
-
-        println!("{:?}", result.unwrap());
-    }
-
-    #[test]
-    fn parses_make_struct() {
-        parses("(define make-struct (lambda (struct-name fields) (map (lambda (field) (list (quote define) (concat-symbols struct-name field) (quote (lambda (this) (vector-ref this 0))))) fields)))")
-    }
-
-    #[test]
-    fn parses_quasiquote() {
-        parses(r#"(quasiquote ((unquote x) xs ...)) "#);
-    }
-
-    #[test]
-    fn parse_syntax_rules() {
-        parses(
-            r#"
-            (syntax-rules (unquote unquote-splicing)
-              ((quasiquote ((unquote x) xs ...))          (cons x (quasiquote (xs ...))))
-              ((quasiquote ((unquote-splicing x)))        (append (list x) '()))
-              ((quasiquote ((unquote-splicing x) xs ...)) (append x (quasiquote (xs ...))))
-              ((quasiquote (unquote x))                 x)
-              ((quasiquote (x))                          '(x))
-              ((quasiquote (x xs ...))                   (cons (quasiquote x) (quasiquote (xs ...))))
-              ((quasiquote x)                           'x))
-            "#,
-        );
-    }
-
-    #[test]
-    fn parse_define_syntax() {
-        parses(
-            r#"
-        (define-syntax quasiquote
-            (syntax-rules (unquote unquote-splicing)
-              ((quasiquote ((unquote x) xs ...))          (cons x (quasiquote (xs ...))))
-              ((quasiquote ((unquote-splicing x)))        (append (list x) '()))
-              ((quasiquote ((unquote-splicing x) xs ...)) (append x (quasiquote (xs ...))))
-              ((quasiquote (unquote x))                 x)
-              ((quasiquote (x))                          '(x))
-              ((quasiquote (x xs ...))                   (cons (quasiquote x) (quasiquote (xs ...))))
-              ((quasiquote x)                           'x)))
-        "#,
-        );
-    }
-
-    #[test]
-    fn parse_quote() {
-        // parses("(displayln (match (quote (lambda y z)) '(x y z)))")
-        parses("(displayln (match '(lambda y z) '(x y z)))")
-    }
-
-    #[test]
-    fn parse_unicode() {
-        assert_parse("#\\¡", &[character('¡')]);
-        assert_parse("#\\u{b}", &[character('\u{b}')]);
-    }
-
-    #[test]
-    fn parse_more_unicode() {
-        assert_parse("#\\u{a0}", &[character('\u{a0}')]);
-    }
-
-    #[test]
-    fn parse_strange_characters() {
-        assert_parse("#\\^", &[character('^')]);
-    }
-
-    #[test]
-    fn parse_character_sequence() {
-        assert_parse(
-            "#\\¡ #\\SPACE #\\g",
-            &[character('¡'), character(' '), character('g')],
-        )
-    }
-
-    #[test]
-    fn parse_character_sequence_inside_if() {
-        assert_parse(
-            "(if #\\¡ #\\SPACE #\\g)",
-            &[ExprKind::If(Box::new(If::new(
-                character('¡'),
-                character(' '),
-                character('g'),
-                SyntaxObject::default(TokenType::If),
-            )))],
-        )
-    }
-
-    #[test]
-    fn parse_close_paren_character() {
-        assert_parse("#\\)", &[character(')')]);
-        assert_parse("#\\]", &[character(']')])
-    }
-
-    #[test]
-    fn parse_open_paren_character() {
-        assert_parse("#\\(", &[character('(')])
-    }
-
-    #[test]
-    fn test_error() {
-        assert_parse_err("(", ParseError::UnexpectedEOF(None));
-        assert_parse_err("(abc", ParseError::UnexpectedEOF(None));
-        assert_parse_err("(ab 1 2", ParseError::UnexpectedEOF(None));
-        assert_parse_err("((((ab 1 2) (", ParseError::UnexpectedEOF(None));
-        assert_parse_err("())", ParseError::Unexpected(TokenType::CloseParen, None));
-        assert_parse_err("() ((((", ParseError::UnexpectedEOF(None));
-        assert_parse_err("')", ParseError::Unexpected(TokenType::CloseParen, None));
-        assert_parse_err("(')", ParseError::Unexpected(TokenType::CloseParen, None));
-        assert_parse_err("('", ParseError::UnexpectedEOF(None));
-    }
-
-    #[test]
-    fn quote_multiple_args_should_err() {
-        assert_parse_is_err("(quote a b c)");
-    }
-
-    #[test]
-    fn test_let_should_err() {
-        assert_parse_is_err("(let)");
-        assert_parse_is_err("(let (a) 10)");
-    }
-
-    #[test]
-    fn test_if_should_err() {
-        assert_parse_is_err("(if)");
-        assert_parse_is_err("(if 1)");
-        // assert_parse_is_err("(if 1 2)");
-        assert_parse_is_err("(if 1 2 3 4)");
-    }
-
-    #[test]
-    fn test_define_should_err() {
-        assert_parse_is_err("(define)");
-        assert_parse_is_err("(define blagh)");
-        assert_parse_is_err("(define test 1 2)");
-        assert_parse_is_err("(define () test");
-    }
-
-    #[test]
-    fn test_lambda_should_err() {
-        assert_parse_is_err("(lambda)");
-        assert_parse_is_err("(lambda (x))");
-    }
-
-    #[test]
-    fn test_empty() {
-        assert_parse("", &[]);
-        assert_parse("()", &[ExprKind::List(List::new(vec![]))]);
-    }
-
-    #[test]
-    fn test_empty_quote_inside_if() {
-        assert_parse(
-            "(if #\\¡ (quote ()) #\\g)",
-            &[ExprKind::If(Box::new(If::new(
-                character('¡'),
-                ExprKind::Quote(
-                    Quote::new(
-                        List::new(vec![]).into(),
-                        SyntaxObject::default(TokenType::Quote),
-                    )
-                    .into(),
-                ),
-                character('g'),
-                SyntaxObject::default(TokenType::If),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_empty_quote() {
-        assert_parse(
-            "'()",
-            &[ExprKind::Quote(
-                Quote::new(
-                    List::new(vec![]).into(),
-                    SyntaxObject::default(TokenType::Quote),
-                )
-                .into(),
-            )],
-        )
-    }
-
-    #[test]
-    fn test_empty_quote_nested() {
-        assert_parse(
-            "(list '())",
-            &[ExprKind::List(List::new(vec![
-                atom("list"),
-                ExprKind::Quote(
-                    Quote::new(
-                        List::new(vec![]).into(),
-                        SyntaxObject::default(TokenType::Quote),
-                    )
-                    .into(),
-                ),
-            ]))],
-        )
-    }
-
-    #[test]
-    fn test_multi_parse_simple() {
-        assert_parse("a b +", &[atom("a"), atom("b"), atom("+")]);
-    }
-
-    #[test]
-    fn test_multi_parse_complicated() {
-        assert_parse(
-            "a b (funcall  1 (+ 2 3.5))",
-            &[
-                atom("a"),
-                atom("b"),
-                ExprKind::List(List::new(vec![
-                    atom("funcall"),
-                    int(1),
-                    ExprKind::List(List::new(vec![
-                        atom("+"),
-                        int(2),
-                        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::NumberLiteral(
-                            3.5,
-                        )))),
-                    ])),
-                ])),
-            ],
-        )
-    }
-    #[test]
-    fn test_parse_simple() {
-        assert_parse(
-            "(+ 1 2 3) (- 4 3)",
-            &[
-                ExprKind::List(List::new(vec![atom("+"), int(1), int(2), int(3)])),
-                ExprKind::List(List::new(vec![atom("-"), int(4), int(3)])),
-            ],
-        );
-    }
-
-    #[test]
-    fn test_parse_nested() {
-        assert_parse(
-            "(+ 1 (foo (bar 2 3)))",
-            &[ExprKind::List(List::new(vec![
-                atom("+"),
-                int(1),
-                ExprKind::List(List::new(vec![
-                    atom("foo"),
-                    ExprKind::List(List::new(vec![atom("bar"), int(2), int(3)])),
-                ])),
-            ]))],
-        );
-        assert_parse(
-            "(+ 1 (+ 2 3) (foo (bar 2 3)))",
-            &[ExprKind::List(List::new(vec![
-                atom("+"),
-                int(1),
-                ExprKind::List(List::new(vec![atom("+"), int(2), int(3)])),
-                ExprKind::List(List::new(vec![
-                    atom("foo"),
-                    ExprKind::List(List::new(vec![atom("bar"), int(2), int(3)])),
-                ])),
-            ]))],
-        );
-    }
-
-    #[test]
-    fn test_if() {
-        assert_parse(
-            "(+ 1 (if 2 3 4) (foo (+ (bar 1 1) 3) 5))",
-            &[ExprKind::List(List::new(vec![
-                atom("+"),
-                int(1),
-                ExprKind::If(Box::new(If::new(
-                    int(2),
-                    int(3),
-                    int(4),
-                    SyntaxObject::default(TokenType::If),
-                ))),
-                ExprKind::List(List::new(vec![
-                    atom("foo"),
-                    ExprKind::List(List::new(vec![
-                        atom("+"),
-                        ExprKind::List(List::new(vec![atom("bar"), int(1), int(1)])),
-                        int(3),
-                    ])),
-                    int(5),
-                ])),
-            ]))],
-        );
-    }
-
-    #[test]
-    fn test_quote() {
-        assert_parse(
-            "(quote (if 1 2))",
-            &[ExprKind::Quote(Box::new(Quote::new(
-                ExprKind::List(List::new(vec![
-                    ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::If))),
-                    int(1),
-                    int(2),
-                ])),
-                SyntaxObject::default(TokenType::Quote),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_quote_shorthand() {
-        assert_parse(
-            "'(if 1 2)",
-            &[ExprKind::Quote(Box::new(Quote::new(
-                ExprKind::List(List::new(vec![
-                    ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::If))),
-                    int(1),
-                    int(2),
-                ])),
-                SyntaxObject::default(TokenType::Quote),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_quote_nested() {
-        assert_parse(
-            "(quote (if (if 1 2) 3))",
-            &[ExprKind::Quote(Box::new(Quote::new(
-                ExprKind::List(List::new(vec![
-                    ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::If))),
-                    ExprKind::List(List::new(vec![
-                        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::If))),
-                        int(1),
-                        int(2),
-                    ])),
-                    int(3),
-                ])),
-                SyntaxObject::default(TokenType::Quote),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_quote_shorthand_nested() {
-        assert_parse(
-            "'(if (if 1 2) 3)",
-            &[ExprKind::Quote(Box::new(Quote::new(
-                ExprKind::List(List::new(vec![
-                    ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::If))),
-                    ExprKind::List(List::new(vec![
-                        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::If))),
-                        int(1),
-                        int(2),
-                    ])),
-                    int(3),
-                ])),
-                SyntaxObject::default(TokenType::Quote),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_quote_shorthand_multiple_exprs() {
-        assert_parse(
-            "'(if (if 1 2) 3) (+ 1 (if 2 3 4) (foo (+ (bar 1 1) 3) 5))",
-            &[
-                ExprKind::Quote(Box::new(Quote::new(
-                    ExprKind::List(List::new(vec![
-                        ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::If))),
-                        ExprKind::List(List::new(vec![
-                            ExprKind::Atom(Atom::new(SyntaxObject::default(TokenType::If))),
-                            int(1),
-                            int(2),
-                        ])),
-                        int(3),
-                    ])),
-                    SyntaxObject::default(TokenType::Quote),
-                ))),
-                ExprKind::List(List::new(vec![
-                    atom("+"),
-                    int(1),
-                    ExprKind::If(Box::new(If::new(
-                        int(2),
-                        int(3),
-                        int(4),
-                        SyntaxObject::default(TokenType::If),
-                    ))),
-                    ExprKind::List(List::new(vec![
-                        atom("foo"),
-                        ExprKind::List(List::new(vec![
-                            atom("+"),
-                            ExprKind::List(List::new(vec![atom("bar"), int(1), int(1)])),
-                            int(3),
-                        ])),
-                        int(5),
-                    ])),
-                ])),
-            ],
-        )
-    }
-
-    #[test]
-    fn test_quote_inner() {
-        assert_parse(
-            "'(applesauce 'one)",
-            &[ExprKind::Quote(Box::new(Quote::new(
-                ExprKind::List(List::new(vec![
-                    atom("applesauce"),
-                    ExprKind::Quote(Box::new(Quote::new(
-                        atom("one"),
-                        SyntaxObject::default(TokenType::Quote),
-                    ))),
-                ])),
-                SyntaxObject::default(TokenType::Quote),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_quote_inner_without_shorthand() {
-        assert_parse(
-            "(quote (applesauce 'one))",
-            &[ExprKind::Quote(Box::new(Quote::new(
-                ExprKind::List(List::new(vec![
-                    atom("applesauce"),
-                    ExprKind::Quote(Box::new(Quote::new(
-                        atom("one"),
-                        SyntaxObject::default(TokenType::Quote),
-                    ))),
-                ])),
-                SyntaxObject::default(TokenType::Quote),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_quasiquote_shorthand() {
-        assert_parse(
-            "`(+ 1 2)",
-            &[ExprKind::List(List::new(vec![
-                atom("quasiquote"),
-                ExprKind::List(List::new(vec![atom("+"), int(1), int(2)])),
-            ]))],
-        )
-    }
-
-    #[test]
-    fn test_quasiquote_normal() {
-        assert_parse(
-            "(quasiquote (+ 1 2))",
-            &[ExprKind::List(List::new(vec![
-                atom("quasiquote"),
-                ExprKind::List(List::new(vec![atom("+"), int(1), int(2)])),
-            ]))],
-        )
-    }
-
-    #[test]
-    fn test_unquote_shorthand() {
-        assert_parse(
-            ",(+ 1 2)",
-            &[ExprKind::List(List::new(vec![
-                atom("unquote"),
-                ExprKind::List(List::new(vec![atom("+"), int(1), int(2)])),
-            ]))],
-        )
-    }
-
-    #[test]
-    fn test_unquote_normal() {
-        assert_parse(
-            "(unquote (+ 1 2))",
-            &[ExprKind::List(List::new(vec![
-                atom("unquote"),
-                ExprKind::List(List::new(vec![atom("+"), int(1), int(2)])),
-            ]))],
-        )
-    }
-
-    #[test]
-    fn test_unquote_splicing_shorthand() {
-        assert_parse(
-            ",@(+ 1 2)",
-            &[ExprKind::List(List::new(vec![
-                atom("unquote-splicing"),
-                ExprKind::List(List::new(vec![atom("+"), int(1), int(2)])),
-            ]))],
-        )
-    }
-
-    #[test]
-    fn test_unquote_splicing_normal() {
-        assert_parse(
-            "(unquote-splicing (+ 1 2))",
-            &[ExprKind::List(List::new(vec![
-                atom("unquote-splicing"),
-                ExprKind::List(List::new(vec![atom("+"), int(1), int(2)])),
-            ]))],
-        )
-    }
-
-    #[test]
-    fn test_define_simple() {
-        assert_parse(
-            "(define a 10)",
-            &[ExprKind::Define(Box::new(Define::new(
-                atom("a"),
-                int(10),
-                SyntaxObject::default(TokenType::Define),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_define_func_simple() {
-        assert_parse(
-            "(define (foo x) (+ x 10))",
-            &[ExprKind::Define(Box::new(Define::new(
-                atom("foo"),
-                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                    vec![atom("x")],
-                    ExprKind::List(List::new(vec![atom("+"), atom("x"), int(10)])),
-                    SyntaxObject::default(TokenType::Lambda),
-                ))),
-                SyntaxObject::default(TokenType::Define),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_define_func_multiple_args() {
-        assert_parse(
-            "(define (foo x y z) (+ x 10))",
-            &[ExprKind::Define(Box::new(Define::new(
-                atom("foo"),
-                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                    vec![atom("x"), atom("y"), atom("z")],
-                    ExprKind::List(List::new(vec![atom("+"), atom("x"), int(10)])),
-                    SyntaxObject::default(TokenType::Lambda),
-                ))),
-                SyntaxObject::default(TokenType::Define),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_define_func_multiple_args_multiple_body_exprs() {
-        assert_parse(
-            "(define (foo x y z) (+ x 10) (+ y 20) (+ z 30))",
-            &[ExprKind::Define(Box::new(Define::new(
-                atom("foo"),
-                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                    vec![atom("x"), atom("y"), atom("z")],
-                    ExprKind::Begin(Begin::new(
-                        vec![
-                            ExprKind::List(List::new(vec![atom("+"), atom("x"), int(10)])),
-                            ExprKind::List(List::new(vec![atom("+"), atom("y"), int(20)])),
-                            ExprKind::List(List::new(vec![atom("+"), atom("z"), int(30)])),
-                        ],
-                        SyntaxObject::default(TokenType::Begin),
-                    )),
-                    SyntaxObject::default(TokenType::Lambda),
-                ))),
-                SyntaxObject::default(TokenType::Define),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_recursive_function() {
-        assert_parse(
-            "(define (test) (define (foo) (bar)) (define (bar) (foo)))",
-            &[ExprKind::Define(Box::new(Define::new(
-                atom("test"),
-                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                    vec![],
-                    ExprKind::Begin(Begin::new(
-                        vec![
-                            ExprKind::Define(Box::new(Define::new(
-                                atom("foo"),
-                                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                                    vec![],
-                                    ExprKind::List(List::new(vec![atom("bar")])),
-                                    SyntaxObject::default(TokenType::Lambda),
-                                ))),
-                                SyntaxObject::default(TokenType::Define),
-                            ))),
-                            ExprKind::Define(Box::new(Define::new(
-                                atom("bar"),
-                                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                                    vec![],
-                                    ExprKind::List(List::new(vec![atom("foo")])),
-                                    SyntaxObject::default(TokenType::Lambda),
-                                ))),
-                                SyntaxObject::default(TokenType::Define),
-                            ))),
-                        ],
-                        SyntaxObject::default(TokenType::Begin),
-                    )),
-                    SyntaxObject::default(TokenType::Lambda),
-                ))),
-                SyntaxObject::default(TokenType::Define),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_return_normal() {
-        assert_parse(
-            "(return! 10)",
-            &[ExprKind::Return(Box::new(Return::new(
-                int(10),
-                SyntaxObject::default(TokenType::Return),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_begin() {
-        assert_parse(
-            "(begin 1 2 3)",
-            &[ExprKind::Begin(Begin::new(
-                vec![int(1), int(2), int(3)],
-                SyntaxObject::default(TokenType::Begin),
-            ))],
-        )
-    }
-
-    #[test]
-    fn test_lambda_function() {
-        assert_parse(
-            "(lambda (x) 10)",
-            &[ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                vec![atom("x")],
-                int(10),
-                SyntaxObject::default(TokenType::Lambda),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_lambda_matches_let() {
-        assert_parse(
-            "((lambda (a) (+ a 20)) 10)",
-            &[ExprKind::List(List::new(vec![
-                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                    vec![atom("a")],
-                    ExprKind::List(List::new(vec![atom("+"), atom("a"), int(20)])),
-                    SyntaxObject::default(TokenType::Lambda),
-                ))),
-                int(10),
-            ]))],
-        );
-    }
-
-    #[test]
-    fn test_let() {
-        assert_parse(
-            "(let ([a 10]) (+ a 20))",
-            &[ExprKind::List(List::new(vec![
-                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                    vec![atom("a")],
-                    ExprKind::List(List::new(vec![atom("+"), atom("a"), int(20)])),
-                    SyntaxObject::default(TokenType::Lambda),
-                ))),
-                int(10),
-            ]))],
-        )
-    }
-
-    #[test]
-    fn test_quote_with_inner_nested() {
-        assert_parse(
-            "'(#f '())",
-            &[ExprKind::Quote(
-                Quote::new(
-                    ExprKind::List(List::new(vec![
-                        ExprKind::Atom(Atom::new(SyntaxObject::default(
-                            TokenType::BooleanLiteral(false),
-                        ))),
-                        ExprKind::Quote(
-                            Quote::new(
-                                List::new(vec![]).into(),
-                                SyntaxObject::default(TokenType::Quote),
-                            )
-                            .into(),
-                        ),
-                    ])),
-                    SyntaxObject::default(TokenType::Quote),
-                )
-                .into(),
-            )],
-        )
-    }
-
-    #[test]
-    fn test_quote_with_inner_nested_sub_expr() {
-        assert_parse(
-            "(if (null? contents)
-                '(#f '())
-                (list (car contents) (cdr contents)))",
-            &[ExprKind::If(Box::new(If::new(
-                ExprKind::List(List::new(vec![atom("null?"), atom("contents")])),
-                ExprKind::Quote(
-                    Quote::new(
-                        ExprKind::List(List::new(vec![
-                            ExprKind::Atom(Atom::new(SyntaxObject::default(
-                                TokenType::BooleanLiteral(false),
-                            ))),
-                            ExprKind::Quote(
-                                Quote::new(
-                                    List::new(vec![]).into(),
-                                    SyntaxObject::default(TokenType::Quote),
-                                )
-                                .into(),
-                            ),
-                        ])),
-                        SyntaxObject::default(TokenType::Quote),
-                    )
-                    .into(),
-                ),
-                ExprKind::List(List::new(vec![
-                    atom("list"),
-                    ExprKind::List(List::new(vec![atom("car"), atom("contents")])),
-                    ExprKind::List(List::new(vec![atom("cdr"), atom("contents")])),
-                ])),
-                SyntaxObject::default(TokenType::If),
-            )))],
-        );
-    }
-
-    #[test]
-    fn test_quote_normal_with_inner_nested_sub_expr() {
-        assert_parse(
-            "(if (null? contents)
-                (quote (#f '()))
-                (list (car contents) (cdr contents)))",
-            &[ExprKind::If(Box::new(If::new(
-                ExprKind::List(List::new(vec![atom("null?"), atom("contents")])),
-                ExprKind::Quote(
-                    Quote::new(
-                        ExprKind::List(List::new(vec![
-                            ExprKind::Atom(Atom::new(SyntaxObject::default(
-                                TokenType::BooleanLiteral(false),
-                            ))),
-                            ExprKind::Quote(
-                                Quote::new(
-                                    List::new(vec![]).into(),
-                                    SyntaxObject::default(TokenType::Quote),
-                                )
-                                .into(),
-                            ),
-                        ])),
-                        SyntaxObject::default(TokenType::Quote),
-                    )
-                    .into(),
-                ),
-                ExprKind::List(List::new(vec![
-                    atom("list"),
-                    ExprKind::List(List::new(vec![atom("car"), atom("contents")])),
-                    ExprKind::List(List::new(vec![atom("cdr"), atom("contents")])),
-                ])),
-                SyntaxObject::default(TokenType::If),
-            )))],
-        );
-    }
-
-    #[test]
-    fn test_quote_with_inner_sub_expr_even_more_nested() {
-        assert_parse(
-            "(list 
-                (if (null? contents)
-                '(#f '())
-                (list (car contents) (cdr contents))))",
-            &[ExprKind::List(List::new(vec![
-                atom("list"),
-                ExprKind::If(Box::new(If::new(
-                    ExprKind::List(List::new(vec![atom("null?"), atom("contents")])),
-                    ExprKind::Quote(
-                        Quote::new(
-                            ExprKind::List(List::new(vec![
-                                ExprKind::Atom(Atom::new(SyntaxObject::default(
-                                    TokenType::BooleanLiteral(false),
-                                ))),
-                                ExprKind::Quote(
-                                    Quote::new(
-                                        List::new(vec![]).into(),
-                                        SyntaxObject::default(TokenType::Quote),
-                                    )
-                                    .into(),
-                                ),
-                            ])),
-                            SyntaxObject::default(TokenType::Quote),
-                        )
-                        .into(),
-                    ),
-                    ExprKind::List(List::new(vec![
-                        atom("list"),
-                        ExprKind::List(List::new(vec![atom("car"), atom("contents")])),
-                        ExprKind::List(List::new(vec![atom("cdr"), atom("contents")])),
-                    ])),
-                    SyntaxObject::default(TokenType::If),
-                ))),
-            ]))],
-        );
-    }
-
-    #[test]
-    fn test_define_with_datum_syntax_name() {
-        assert_parse(
-            "(define (datum->syntax var) (car ret-value))",
-            &[ExprKind::Define(Box::new(Define::new(
-                ExprKind::List(List::new(vec![atom("datum->syntax"), atom("var")])),
-                ExprKind::List(List::new(vec![atom("car"), atom("ret-value")])),
-                SyntaxObject::default(TokenType::Define),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_define_with_datum_syntax_function_name() {
-        assert_parse(
-            "(define ((datum->syntax var) arg) 10)",
-            &[ExprKind::Define(Box::new(Define::new(
-                ExprKind::List(List::new(vec![atom("datum->syntax"), atom("var")])),
-                ExprKind::LambdaFunction(Box::new(LambdaFunction::new(
-                    vec![atom("arg")],
-                    int(10),
-                    SyntaxObject::default(TokenType::Lambda),
-                ))),
-                SyntaxObject::default(TokenType::Define),
-            )))],
-        )
-    }
-
-    #[test]
-    fn test_parse_without_lowering_ast() {
-        let a: Result<Vec<ExprKind>> =
-            Parser::new_flat("(define (quote a) 10) (require foo bar)", None)
-                .map(|x| x.and_then(lower_macro_and_require_definitions))
-                .collect();
-
-        let a = a.unwrap();
-
-        println!("{:#?}", a);
-    }
-
-    #[test]
-    fn test_delayed_lowering() {
-        let a: Result<Vec<ExprKind>> = Parser::new_flat(
-            r#"
-            ;; (define foo (quote a)) (require foo bar)
-                
-               ;;  (define (foo) (if 10 20 30))
-
-               ;; (define (foo) (quote (define 10 20)))
-
-               ;; (define foo '())
-
-            (define-syntax
-   with-handler
-   (syntax-rules
-      ()
-      ((with-handler handler expr)
-         (reset
-            (call-with-exception-handler
-               (λ (err)
-                 (begin (handler err) (shift k (k void))))
-               (λ ()
-                 expr))))
-      ((with-handler handler expr ...)
-         (reset
-            (call-with-exception-handler
-               (λ (err)
-                 (begin (handler err) (shift k (k void))))
-               (λ ()
-                 (begin expr ...)))))))
-                
-                
-                
-                "#,
-            None,
-        )
-        .map(|x| x.and_then(lower_macro_and_require_definitions))
-        .map(|x| x.and_then(lower_entire_ast))
-        .collect();
-
-        let a = a.unwrap();
-
-        println!("{:#?}", a);
-    }
-}
diff --git a/crates/steel-parser/src/span.rs b/crates/steel-parser/src/span.rs
deleted file mode 100644
index a9b596083..000000000
--- a/crates/steel-parser/src/span.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-use core::ops::Range;
-use serde::{Deserialize, Serialize};
-use std::fmt;
-
-// use crate::{list, rvals::FromSteelVal, rvals::IntoSteelVal};
-
-// use crate::rvals::SteelVal;
-
-use super::parser::SourceId;
-
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize, Default)]
-#[repr(C)]
-pub struct Span {
-    pub start: usize,
-    pub end: usize,
-    pub source_id: Option<SourceId>,
-}
-
-// impl IntoSteelVal for Span {
-//     fn into_steelval(self) -> crate::rvals::Result<crate::SteelVal> {
-//         Ok(list![self.start, self.end, self.source_id])
-//     }
-// }
-
-// impl FromSteelVal for Span {
-//     fn from_steelval(val: &crate::SteelVal) -> crate::rvals::Result<Self> {
-//         if let SteelVal::ListV(l) = val {
-//             if l.len() != 3 {
-//                 stop!(ConversionError => "cannot convert to a span object: {}", val);
-//             }
-
-//             Ok(Span {
-//                 start: usize::from_steelval(l.get(0).unwrap())?,
-//                 end: usize::from_steelval(l.get(1).unwrap())?,
-//                 source_id: l
-//                     .get(2)
-//                     .map(Option::<usize>::from_steelval)
-//                     .map(|x| x.transpose())
-//                     .flatten()
-//                     .transpose()?
-//                     .map(SourceId),
-//             })
-//         } else {
-//             stop!(ConversionError => "cannot convert to a span object: {}", val)
-//         }
-//     }
-// }
-
-impl Span {
-    #[inline]
-    pub const fn new(start: usize, end: usize, source_id: Option<SourceId>) -> Self {
-        Self {
-            start,
-            end,
-            source_id,
-        }
-    }
-
-    #[inline]
-    pub const fn double(span: usize, source_id: Option<SourceId>) -> Self {
-        Self {
-            start: span,
-            end: span,
-            source_id,
-        }
-    }
-
-    #[inline]
-    pub const fn start(&self) -> usize {
-        self.start
-    }
-
-    #[inline]
-    pub const fn end(&self) -> usize {
-        self.end
-    }
-
-    #[inline]
-    pub const fn range(&self) -> Range<usize> {
-        self.start..self.end
-    }
-
-    #[inline]
-    pub const fn source_id(&self) -> Option<SourceId> {
-        self.source_id
-    }
-
-    #[inline]
-    pub const fn merge(start: Self, end: Self) -> Span {
-        // TODO: If this doesn't seem to make sense with macros, we can revisit
-        Self::new(start.start, end.end, start.source_id)
-    }
-
-    #[inline]
-    pub const fn width(&self) -> usize {
-        self.end - self.start
-    }
-
-    pub fn coalesce_span(spans: &[Span]) -> Span {
-        let span = spans.get(0);
-        if let Some(span) = span {
-            let mut span = *span;
-            for s in spans {
-                if s.start() < span.start() {
-                    span = Span::new(s.start(), span.end(), s.source_id);
-                }
-                if s.end() > span.end() {
-                    span = Span::new(span.start(), s.end(), s.source_id);
-                }
-            }
-            span
-        } else {
-            Span::new(0, 0, None)
-        }
-    }
-}
-
-impl fmt::Debug for Span {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}..{}", self.start, self.end)
-    }
-}
-
-impl From<Span> for Range<usize> {
-    fn from(span: Span) -> Self {
-        span.start..span.end
-    }
-}
-
-impl From<Span> for (usize, usize) {
-    fn from(span: Span) -> Self {
-        (span.start, span.end)
-    }
-}
-
-impl From<Span> for [usize; 2] {
-    fn from(span: Span) -> Self {
-        [span.start, span.end]
-    }
-}
diff --git a/crates/steel-parser/src/tokens.rs b/crates/steel-parser/src/tokens.rs
deleted file mode 100644
index 544b357d5..000000000
--- a/crates/steel-parser/src/tokens.rs
+++ /dev/null
@@ -1,387 +0,0 @@
-use core::ops;
-use std::fmt;
-use TokenType::*;
-
-// use logos::{Lexer, Logos};
-
-use crate::span::Span;
-
-use serde::{Deserialize, Serialize};
-use std::str::FromStr;
-
-use std::convert::TryFrom;
-use std::num::ParseIntError;
-
-use crate::parser::SourceId;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum DecodeHexError {
-    OddLength,
-    ParseInt(ParseIntError),
-}
-
-impl From<ParseIntError> for DecodeHexError {
-    fn from(e: ParseIntError) -> Self {
-        DecodeHexError::ParseInt(e)
-    }
-}
-
-impl fmt::Display for DecodeHexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            DecodeHexError::OddLength => "input string has an odd number of bytes".fmt(f),
-            DecodeHexError::ParseInt(e) => e.fmt(f),
-        }
-    }
-}
-
-impl std::error::Error for DecodeHexError {}
-
-pub fn decode_hex(s: &str) -> Result<Vec<u8>, DecodeHexError> {
-    if s.len() % 2 != 0 {
-        Err(DecodeHexError::OddLength)
-    } else {
-        (0..s.len())
-            .step_by(2)
-            .map(|i| u8::from_str_radix(&s[i..i + 2], 16).map_err(|e| e.into()))
-            .collect()
-    }
-}
-
-pub fn parse_unicode_str(slice: &str) -> Option<char> {
-    if slice.starts_with("#\\u") && slice.contains('{') && slice.contains('}') {
-        let rest = slice
-            .trim_start_matches("#\\u")
-            .trim_start_matches('{')
-            .trim_end_matches('}')
-            .to_lowercase();
-
-        let rest = match rest.len() {
-            0 => panic!("length of 0"),
-            1 => "000".to_string() + &rest,
-            2 => "00".to_string() + &rest,
-            3 => "0".to_string() + &rest,
-            _ => return None,
-        };
-
-        let decoded: u8 = decode_hex(&rest).ok()?.into_iter().sum();
-        let uinitial: u32 = decoded.into();
-        let result = char::try_from(uinitial).ok();
-
-        // println!("{result:?}");
-        result
-    } else if slice.starts_with("#\\u") {
-        let rest = slice.trim_start_matches("#\\u").to_lowercase();
-
-        let rest = match rest.len() {
-            1 => "000".to_string() + &rest,
-            2 => "00".to_string() + &rest,
-            3 => "0".to_string() + &rest,
-            4 => rest,
-            _ => return None,
-        };
-
-        let decoded: u8 = decode_hex(&rest).ok()?.into_iter().sum();
-
-        let uinitial: u32 = decoded.into();
-
-        let result = char::try_from(uinitial).ok();
-
-        result
-    } else {
-        None
-    }
-}
-
-// TODO the character parsing is not quite right
-// need to make sure that we can handle cases like "#\SPACE" or "#\a" but not "#\applesauce"
-#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
-pub enum TokenType<S> {
-    OpenParen,
-    CloseParen,
-    QuoteTick,
-    QuasiQuote,
-    Unquote,
-    UnquoteSplice,
-    QuoteSyntax,
-    QuasiQuoteSyntax,
-    UnquoteSyntax,
-    UnquoteSpliceSyntax,
-    If,
-    Define,
-    Let,
-    TestLet,
-    Return,
-    Begin,
-    Lambda,
-    Quote,
-    SyntaxRules,
-    DefineSyntax,
-    Ellipses,
-    Set,
-    Require,
-    CharacterLiteral(char),
-    Comment,
-    BooleanLiteral(bool),
-    Identifier(S),
-    Keyword(S),
-    NumberLiteral(f64),
-    IntegerLiteral(MaybeBigInt),
-    StringLiteral(String),
-    Error,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub enum MaybeBigInt {
-    Small(isize),
-    Big(num_bigint::BigInt),
-}
-
-impl FromStr for MaybeBigInt {
-    type Err = <num_bigint::BigInt as FromStr>::Err;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        s.parse::<isize>()
-            .map(MaybeBigInt::Small)
-            .or_else(|_| s.parse::<num_bigint::BigInt>().map(MaybeBigInt::Big))
-    }
-}
-
-impl std::fmt::Display for MaybeBigInt {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            Self::Small(s) => write!(f, "{s}"),
-            Self::Big(b) => write!(f, "{b}"),
-        }
-    }
-}
-
-#[test]
-fn check_token_size() {
-    println!("{}", std::mem::size_of::<TokenType<&str>>());
-}
-
-impl<'a> TokenType<&'a str> {
-    pub fn to_owned<T: From<&'a str>>(self) -> TokenType<T> {
-        match self {
-            TokenType::Identifier(i) => TokenType::Identifier(i.into()),
-            TokenType::Keyword(i) => TokenType::Keyword(i.into()),
-            OpenParen => OpenParen,
-            CloseParen => CloseParen,
-            CharacterLiteral(x) => CharacterLiteral(x),
-            BooleanLiteral(x) => BooleanLiteral(x),
-            NumberLiteral(x) => NumberLiteral(x),
-            IntegerLiteral(x) => IntegerLiteral(x),
-            StringLiteral(x) => StringLiteral(x),
-            QuoteTick => QuoteTick,
-            Unquote => Unquote,
-            QuasiQuote => QuasiQuote,
-            UnquoteSplice => UnquoteSplice,
-            Error => Error,
-            Comment => Comment,
-            If => If,
-            Define => Define,
-            Let => Let,
-            TestLet => TestLet,
-            Return => Return,
-            Begin => Begin,
-            Lambda => Lambda,
-            Quote => Quote,
-            DefineSyntax => DefineSyntax,
-            SyntaxRules => SyntaxRules,
-            Ellipses => Ellipses,
-            Set => Set,
-            Require => Require,
-            QuasiQuoteSyntax => QuasiQuoteSyntax,
-            UnquoteSyntax => UnquoteSyntax,
-            QuoteSyntax => QuoteSyntax,
-            UnquoteSpliceSyntax => UnquoteSpliceSyntax,
-        }
-    }
-
-    pub fn map<T>(self, mut func: impl FnMut(&'a str) -> T) -> TokenType<T> {
-        match self {
-            TokenType::Identifier(i) => TokenType::Identifier(func(i)),
-            TokenType::Keyword(i) => TokenType::Keyword(func(i)),
-            OpenParen => OpenParen,
-            CloseParen => CloseParen,
-            CharacterLiteral(x) => CharacterLiteral(x),
-            BooleanLiteral(x) => BooleanLiteral(x),
-
-            NumberLiteral(x) => NumberLiteral(x),
-            IntegerLiteral(x) => IntegerLiteral(x),
-            StringLiteral(x) => StringLiteral(x),
-            QuoteTick => QuoteTick,
-            Unquote => Unquote,
-            QuasiQuote => QuasiQuote,
-            UnquoteSplice => UnquoteSplice,
-            Error => Error,
-            Comment => Comment,
-            If => If,
-            Define => Define,
-            Let => Let,
-            TestLet => TestLet,
-            Return => Return,
-            Begin => Begin,
-            Lambda => Lambda,
-            Quote => Quote,
-            DefineSyntax => DefineSyntax,
-            SyntaxRules => SyntaxRules,
-            Ellipses => Ellipses,
-            Set => Set,
-            Require => Require,
-            QuasiQuoteSyntax => QuasiQuoteSyntax,
-            UnquoteSyntax => UnquoteSyntax,
-            QuoteSyntax => QuoteSyntax,
-            UnquoteSpliceSyntax => UnquoteSpliceSyntax,
-        }
-    }
-}
-
-fn character_special_display(c: char, f: &mut fmt::Formatter) -> fmt::Result {
-    match c {
-        ' ' => write!(f, "#\\SPACE"),
-        '\t' => write!(f, "#\\TAB"),
-        '\n' => write!(f, "#\\NEWLINE"),
-        '\r' => write!(f, "#\\RETURN"),
-        c if c.is_control() || c.is_whitespace() => {
-            write!(f, "#\\{}", c.escape_unicode())
-        }
-        // '\"' => write!(f, "#\\DOUBLE-QUOTE"),
-        // '\'' => write!(f, "#\\QUOTE"),
-        // '\\' => write!(f, "#\\BACKSLASH"),
-        _ => write!(f, "#\\{c}"),
-    }
-}
-
-impl<T: fmt::Display> fmt::Display for TokenType<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self {
-            OpenParen => write!(f, "("),
-            CloseParen => write!(f, "("),
-            CharacterLiteral(x) => character_special_display(*x, f),
-            BooleanLiteral(x) => write!(f, "#{x}"),
-            Identifier(x) => write!(f, "{x}"),
-            NumberLiteral(x) => write!(f, "{x:?}"),
-            IntegerLiteral(x) => write!(f, "{x}"),
-            StringLiteral(x) => write!(f, "\"{x}\""),
-            // BigIntegerLiteral(x) => write!(f, "{x}"),
-            Keyword(x) => write!(f, "{x}"),
-            QuoteTick => write!(f, "'"),
-            Unquote => write!(f, ","),
-            QuasiQuote => write!(f, "`"),
-            UnquoteSplice => write!(f, ",@"),
-            QuoteSyntax => write!(f, "#'"),
-            QuasiQuoteSyntax => write!(f, "#`"),
-            UnquoteSyntax => write!(f, "#,"),
-            UnquoteSpliceSyntax => write!(f, "#,@"),
-            Error => write!(f, "error"),
-            Comment => write!(f, ""),
-            If => write!(f, "if"),
-            Define => write!(f, "define"),
-            Let => write!(f, "let"),
-            TestLet => write!(f, "%plain-let"),
-            Return => write!(f, "return!"),
-            Begin => write!(f, "begin"),
-            Lambda => write!(f, "lambda"),
-            Quote => write!(f, "quote"),
-            DefineSyntax => write!(f, "define-syntax"),
-            SyntaxRules => write!(f, "syntax-rules"),
-            Ellipses => write!(f, "..."),
-            Set => write!(f, "set!"),
-            Require => write!(f, "require"),
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq)]
-pub struct Token<'a, T> {
-    pub ty: TokenType<T>,
-    pub source: &'a str,
-    pub span: Span,
-}
-
-impl<'a, T> Token<'a, T> {
-    pub const fn new(
-        ty: TokenType<T>,
-        source: &'a str,
-        range: ops::Range<usize>,
-        source_id: Option<SourceId>,
-    ) -> Self {
-        Self {
-            ty,
-            source,
-            span: Span::new(range.start, range.end, source_id),
-        }
-    }
-
-    pub fn typ(&self) -> &TokenType<T> {
-        &self.ty
-    }
-
-    pub const fn span(&self) -> Span {
-        self.span
-    }
-
-    pub const fn range(&self) -> ops::Range<usize> {
-        self.span.start()..self.span.end()
-    }
-
-    pub const fn source(&self) -> &'a str {
-        self.source
-    }
-}
-
-impl<T> From<Token<'_, T>> for Span {
-    fn from(token: Token<'_, T>) -> Self {
-        token.span()
-    }
-}
-
-impl<T> From<&Token<'_, T>> for Span {
-    fn from(token: &Token<'_, T>) -> Self {
-        token.span()
-    }
-}
-
-impl<T> From<Token<'_, T>> for ops::Range<usize> {
-    fn from(token: Token<'_, T>) -> Self {
-        token.span().into()
-    }
-}
-
-impl<T> From<&Token<'_, T>> for ops::Range<usize> {
-    fn from(token: &Token<'_, T>) -> Self {
-        token.span().into()
-    }
-}
-
-impl<T> From<Token<'_, T>> for (usize, usize) {
-    fn from(token: Token<'_, T>) -> Self {
-        token.span().into()
-    }
-}
-
-impl<T> From<&Token<'_, T>> for (usize, usize) {
-    fn from(token: &Token<'_, T>) -> Self {
-        token.span().into()
-    }
-}
-
-impl<T> From<Token<'_, T>> for [usize; 2] {
-    fn from(token: Token<'_, T>) -> Self {
-        token.span().into()
-    }
-}
-
-impl<T> From<&Token<'_, T>> for [usize; 2] {
-    fn from(token: &Token<'_, T>) -> Self {
-        token.span().into()
-    }
-}
-
-impl<T> fmt::Display for Token<'_, T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{} @ {:?}", self.source, self.span)
-    }
-}
diff --git a/crates/steel-pty/Cargo.toml b/crates/steel-pty/Cargo.toml
deleted file mode 100644
index b1e0f95c2..000000000
--- a/crates/steel-pty/Cargo.toml
+++ /dev/null
@@ -1,23 +0,0 @@
-[package]
-name = "steel-pty"
-version = "0.1.0"
-edition = "2021"
-
-
-[lib]
-name = "steel_pty"
-crate-type = ["cdylib"]
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-portable-pty = "0.8.1"
-steel-core = { workspace = true }
-abi_stable = "0.11.1"
-strip-ansi-escapes = "0.1.1"
-futures = "0.3.26"
-tokio = { version = "1.29.1", features = ["sync"]}
-# ansitok = "0.2.0"
-# ansi-parser = "0.8.0"
-termwiz = "0.20.0"
-log = "0.4.17"
\ No newline at end of file
diff --git a/crates/steel-pty/src/lib.rs b/crates/steel-pty/src/lib.rs
deleted file mode 100644
index 2c480eed2..000000000
--- a/crates/steel-pty/src/lib.rs
+++ /dev/null
@@ -1,471 +0,0 @@
-//! This is a conceptually simple example that spawns the `whoami` program
-//! to print your username.  It is made more complex because there are multiple
-//! pipes involved and it is easy to get blocked/deadlocked if care and attention
-//! is not paid to those pipes!
-use abi_stable::std_types::{
-    RBoxError,
-    RResult::{self},
-    RVec,
-};
-// use ansi_parser::AnsiParser;
-// use ansitok::{parse_ansi, AnsiIterator, Element};
-use portable_pty::{Child, CommandBuilder, NativePtySystem, PtyPair, PtySize, PtySystem};
-use std::{
-    io::Read,
-    sync::{
-        mpsc::{channel, Sender},
-        Arc,
-    },
-};
-use steel::{
-    declare_module,
-    rvals::Custom,
-    steel_vm::ffi::{FFIModule, FFIValue, FfiFuture, FfiFutureExt, RegisterFFIFn},
-};
-use termwiz::escape::{parser::Parser, Action};
-
-use tokio::sync::mpsc;
-
-// struct AnsiTokenizer {
-//     input: &'static str,
-//     tokenizer: AnsiIterator<'static>,
-// }
-
-// impl AnsiTokenizer {
-//     pub fn new(seed: String) -> Self {
-
-//     }
-// }
-
-struct PtyProcess {
-    cancellation_token_sender: Sender<()>,
-    command_sender: Sender<String>,
-    // output_receiver: Receiver<String>,
-    async_receiver: Arc<Mutex<mpsc::UnboundedReceiver<String>>>,
-    pty_system: PtyPair,
-    child: Box<dyn Child + Send + Sync>,
-    // tokenizer
-}
-
-use futures::{lock::Mutex, FutureExt, StreamExt};
-
-// impl FromSteelVal for Element
-
-struct AnsiEscapeParser(termwiz::escape::parser::Parser);
-
-struct TermAction(Action);
-
-pub fn action_to_ffi_value(action: Action) -> FFIValue {
-    // todo!()
-
-    log::info!("action: {:?}", &action);
-
-    match action {
-        Action::Print(c) => FFIValue::CharV { c },
-        Action::PrintString(s) => FFIValue::StringV(s.into()),
-        Action::Control(c) => match c {
-            // termwiz::escape::ControlCode::Null => todo!(),
-            // termwiz::escape::ControlCode::StartOfHeading => todo!(),
-            // termwiz::escape::ControlCode::StartOfText => todo!(),
-            // termwiz::escape::ControlCode::EndOfText => todo!(),
-            // termwiz::escape::ControlCode::EndOfTransmission => todo!(),
-            // termwiz::escape::ControlCode::Enquiry => todo!(),
-            // termwiz::escape::ControlCode::Acknowledge => todo!(),
-            // termwiz::escape::ControlCode::Bell => todo!(),
-            // termwiz::escape::ControlCode::Backspace => todo!(),
-            // termwiz::escape::ControlCode::HorizontalTab => todo!(),
-            termwiz::escape::ControlCode::LineFeed => FFIValue::CharV { c: '\n' },
-            // termwiz::escape::ControlCode::VerticalTab => todo!(),
-            // termwiz::escape::ControlCode::FormFeed => todo!(),
-            termwiz::escape::ControlCode::CarriageReturn => FFIValue::CharV { c: '\r' },
-            // termwiz::escape::ControlCode::ShiftOut => todo!(),
-            // termwiz::escape::ControlCode::ShiftIn => todo!(),
-            // termwiz::escape::ControlCode::DataLinkEscape => todo!(),
-            // termwiz::escape::ControlCode::DeviceControlOne => todo!(),
-            // termwiz::escape::ControlCode::DeviceControlTwo => todo!(),
-            // termwiz::escape::ControlCode::DeviceControlThree => todo!(),
-            // termwiz::escape::ControlCode::DeviceControlFour => todo!(),
-            // termwiz::escape::ControlCode::NegativeAcknowledge => todo!(),
-            // termwiz::escape::ControlCode::SynchronousIdle => todo!(),
-            // termwiz::escape::ControlCode::EndOfTransmissionBlock => todo!(),
-            // termwiz::escape::ControlCode::Cancel => todo!(),
-            // termwiz::escape::ControlCode::EndOfMedium => todo!(),
-            // termwiz::escape::ControlCode::Substitute => todo!(),
-            // termwiz::escape::ControlCode::Escape => todo!(),
-            // termwiz::escape::ControlCode::FileSeparator => todo!(),
-            // termwiz::escape::ControlCode::GroupSeparator => todo!(),
-            // termwiz::escape::ControlCode::RecordSeparator => todo!(),
-            // termwiz::escape::ControlCode::UnitSeparator => todo!(),
-            // termwiz::escape::ControlCode::BPH => todo!(),
-            // termwiz::escape::ControlCode::NBH => todo!(),
-            // termwiz::escape::ControlCode::IND => todo!(),
-            // termwiz::escape::ControlCode::NEL => todo!(),
-            // termwiz::escape::ControlCode::SSA => todo!(),
-            // termwiz::escape::ControlCode::ESA => todo!(),
-            // termwiz::escape::ControlCode::HTS => todo!(),
-            // termwiz::escape::ControlCode::HTJ => todo!(),
-            // termwiz::escape::ControlCode::VTS => todo!(),
-            // termwiz::escape::ControlCode::PLD => todo!(),
-            // termwiz::escape::ControlCode::PLU => todo!(),
-            // termwiz::escape::ControlCode::RI => todo!(),
-            // termwiz::escape::ControlCode::SS2 => todo!(),
-            // termwiz::escape::ControlCode::SS3 => todo!(),
-            // termwiz::escape::ControlCode::DCS => todo!(),
-            // termwiz::escape::ControlCode::PU1 => todo!(),
-            // termwiz::escape::ControlCode::PU2 => todo!(),
-            // termwiz::escape::ControlCode::STS => todo!(),
-            // termwiz::escape::ControlCode::CCH => todo!(),
-            // termwiz::escape::ControlCode::MW => todo!(),
-            // termwiz::escape::ControlCode::SPA => todo!(),
-            // termwiz::escape::ControlCode::EPA => todo!(),
-            // termwiz::escape::ControlCode::SOS => todo!(),
-            // termwiz::escape::ControlCode::SCI => todo!(),
-            // termwiz::escape::ControlCode::CSI => todo!(),
-            // termwiz::escape::ControlCode::ST => todo!(),
-            // termwiz::escape::ControlCode::OSC => todo!(),
-            // termwiz::escape::ControlCode::PM => todo!(),
-            // termwiz::escape::ControlCode::APC => todo!(),
-            _ => FFIValue::Void,
-        },
-        // Action::DeviceControl(_) => todo!(),
-        // Action::OperatingSystemCommand(_) => todo!(),
-        Action::CSI(csi) => match csi {
-            // termwiz::escape::CSI::Sgr(_) => todo!(),
-            termwiz::escape::CSI::Cursor(c) => match c {
-                // termwiz::escape::csi::Cursor::BackwardTabulation(_) => todo!(),
-                // termwiz::escape::csi::Cursor::TabulationClear(_) => todo!(),
-                // termwiz::escape::csi::Cursor::CharacterAbsolute(_) => todo!(),
-                // termwiz::escape::csi::Cursor::CharacterPositionAbsolute(_) => todo!(),
-                // termwiz::escape::csi::Cursor::CharacterPositionBackward(_) => todo!(),
-                // termwiz::escape::csi::Cursor::CharacterPositionForward(_) => todo!(),
-                // termwiz::escape::csi::Cursor::CharacterAndLinePosition { line, col } => todo!(),
-                // termwiz::escape::csi::Cursor::LinePositionAbsolute(_) => todo!(),
-                // termwiz::escape::csi::Cursor::LinePositionBackward(_) => todo!(),
-                // termwiz::escape::csi::Cursor::LinePositionForward(_) => todo!(),
-                // termwiz::escape::csi::Cursor::ForwardTabulation(_) => todo!(),
-                // termwiz::escape::csi::Cursor::NextLine(_) => todo!(),
-                // termwiz::escape::csi::Cursor::PrecedingLine(_) => todo!(),
-                // termwiz::escape::csi::Cursor::ActivePositionReport { line, col } => todo!(),
-                // termwiz::escape::csi::Cursor::RequestActivePositionReport => todo!(),
-                // termwiz::escape::csi::Cursor::SaveCursor => todo!(),
-                // termwiz::escape::csi::Cursor::RestoreCursor => todo!(),
-                // termwiz::escape::csi::Cursor::TabulationControl(_) => todo!(),
-                // termwiz::escape::csi::Cursor::Left(_) => todo!(),
-                // termwiz::escape::csi::Cursor::Down(_) => todo!(),
-                // termwiz::escape::csi::Cursor::Right(_) => todo!(),
-                // termwiz::escape::csi::Cursor::Position { line, col } => todo!(),
-                // termwiz::escape::csi::Cursor::Up(_) => todo!(),
-                // termwiz::escape::csi::Cursor::LineTabulation(_) => todo!(),
-                // termwiz::escape::csi::Cursor::SetTopAndBottomMargins { top, bottom } => todo!(),
-                // termwiz::escape::csi::Cursor::SetLeftAndRightMargins { left, right } => todo!(),
-                // termwiz::escape::csi::Cursor::CursorStyle(_) => todo!(),
-                _ => FFIValue::IntV(3),
-            },
-            termwiz::escape::CSI::Edit(e) => match e {
-                // termwiz::escape::csi::Edit::DeleteCharacter(_) => todo!(),
-                // termwiz::escape::csi::Edit::DeleteLine(_) => todo!(),
-                // termwiz::escape::csi::Edit::EraseCharacter(_) => todo!(),
-                termwiz::escape::csi::Edit::EraseInLine(e) => match e {
-                    termwiz::escape::csi::EraseInLine::EraseToEndOfLine => FFIValue::IntV(0),
-                    termwiz::escape::csi::EraseInLine::EraseToStartOfLine => FFIValue::IntV(1),
-                    termwiz::escape::csi::EraseInLine::EraseLine => FFIValue::IntV(2),
-                },
-                // termwiz::escape::csi::Edit::InsertCharacter(_) => todo!(),
-                // termwiz::escape::csi::Edit::InsertLine(_) => todo!(),
-                // termwiz::escape::csi::Edit::ScrollDown(_) => todo!(),
-                // termwiz::escape::csi::Edit::ScrollUp(_) => todo!(),
-                // termwiz::escape::csi::Edit::EraseInDisplay(_) => todo!(),
-                // termwiz::escape::csi::Edit::Repeat(_) => todo!(),
-                _ => FFIValue::Void,
-            },
-            // termwiz::escape::CSI::Mode(_) => todo!(),
-            // termwiz::escape::CSI::Device(_) => todo!(),
-            // termwiz::escape::CSI::Mouse(_) => todo!(),
-            // termwiz::escape::CSI::Window(_) => todo!(),
-            // termwiz::escape::CSI::Keyboard(_) => todo!(),
-            // termwiz::escape::CSI::SelectCharacterPath(_, _) => todo!(),
-            // termwiz::escape::CSI::Unspecified(_) => todo!(),
-            _ => FFIValue::Void,
-        },
-        Action::Esc(esc) => match esc {
-            termwiz::escape::Esc::Unspecified {
-                intermediate: _,
-                control: _,
-            } => FFIValue::Void,
-            termwiz::escape::Esc::Code(c) => match c {
-                // termwiz::escape::EscCode::FullReset => todo!(),
-                // termwiz::escape::EscCode::Index => todo!(),
-                termwiz::escape::EscCode::NextLine => FFIValue::CharV { c: '\n' },
-                // termwiz::escape::EscCode::CursorPositionLowerLeft => todo!(),
-                // termwiz::escape::EscCode::HorizontalTabSet => todo!(),
-                // termwiz::escape::EscCode::ReverseIndex => todo!(),
-                // termwiz::escape::EscCode::SingleShiftG2 => todo!(),
-                // termwiz::escape::EscCode::SingleShiftG3 => todo!(),
-                // termwiz::escape::EscCode::StartOfGuardedArea => todo!(),
-                // termwiz::escape::EscCode::EndOfGuardedArea => todo!(),
-                // termwiz::escape::EscCode::StartOfString => todo!(),
-                // termwiz::escape::EscCode::ReturnTerminalId => todo!(),
-                // termwiz::escape::EscCode::StringTerminator => todo!(),
-                // termwiz::escape::EscCode::PrivacyMessage => todo!(),
-                // termwiz::escape::EscCode::ApplicationProgramCommand => todo!(),
-                // termwiz::escape::EscCode::TmuxTitle => todo!(),
-                // termwiz::escape::EscCode::DecBackIndex => todo!(),
-                // termwiz::escape::EscCode::DecSaveCursorPosition => todo!(),
-                // termwiz::escape::EscCode::DecRestoreCursorPosition => todo!(),
-                // termwiz::escape::EscCode::DecApplicationKeyPad => todo!(),
-                // termwiz::escape::EscCode::DecNormalKeyPad => todo!(),
-                // termwiz::escape::EscCode::DecLineDrawingG0 => todo!(),
-                // termwiz::escape::EscCode::UkCharacterSetG0 => todo!(),
-                // termwiz::escape::EscCode::AsciiCharacterSetG0 => todo!(),
-                // termwiz::escape::EscCode::DecLineDrawingG1 => todo!(),
-                // termwiz::escape::EscCode::UkCharacterSetG1 => todo!(),
-                // termwiz::escape::EscCode::AsciiCharacterSetG1 => todo!(),
-                // termwiz::escape::EscCode::DecScreenAlignmentDisplay => todo!(),
-                // termwiz::escape::EscCode::DecDoubleHeightTopHalfLine => todo!(),
-                // termwiz::escape::EscCode::DecDoubleHeightBottomHalfLine => todo!(),
-                // termwiz::escape::EscCode::DecSingleWidthLine => todo!(),
-                // termwiz::escape::EscCode::DecDoubleWidthLine => todo!(),
-                // termwiz::escape::EscCode::ApplicationModeArrowUpPress => todo!(),
-                // termwiz::escape::EscCode::ApplicationModeArrowDownPress => todo!(),
-                // termwiz::escape::EscCode::ApplicationModeArrowRightPress => todo!(),
-                // termwiz::escape::EscCode::ApplicationModeArrowLeftPress => todo!(),
-                // termwiz::escape::EscCode::ApplicationModeHomePress => todo!(),
-                // termwiz::escape::EscCode::ApplicationModeEndPress => todo!(),
-                // termwiz::escape::EscCode::F1Press => todo!(),
-                // termwiz::escape::EscCode::F2Press => todo!(),
-                // termwiz::escape::EscCode::F3Press => todo!(),
-                // termwiz::escape::EscCode::F4Press => todo!(),
-                _ => FFIValue::Void,
-            },
-        },
-        // Action::Sixel(_) => todo!(),
-        // Action::XtGetTcap(_) => todo!(),
-        // Action::KittyImage(_) => todo!(),
-        _ => FFIValue::Void,
-    }
-}
-
-impl AnsiEscapeParser {
-    pub fn new() -> Self {
-        Self(Parser::new())
-    }
-
-    pub fn tokenize_ansi(&mut self, text: String) -> RVec<FFIValue> {
-        let mut result = RVec::new();
-
-        self.0.parse(text.as_bytes(), |action| {
-            result.push(action_to_ffi_value(action))
-        });
-
-        result
-    }
-}
-
-impl Custom for AnsiEscapeParser {}
-
-impl PtyProcess {
-    pub fn kill(&mut self) {
-        self.child.kill().ok();
-        self.cancellation_token_sender.send(()).ok();
-    }
-
-    pub fn send_command(&mut self, command: String) {
-        self.command_sender.send(command).unwrap();
-    }
-
-    pub fn async_try_read_line(&mut self) -> FfiFuture<RResult<FFIValue, RBoxError>> {
-        let ar = Arc::clone(&self.async_receiver);
-
-        async move {
-            ar.lock()
-                .await
-                .recv()
-                .map(|x| {
-                    if let Some(message) = x {
-                        RResult::ROk(FFIValue::StringV(message.into()))
-                    } else {
-                        RResult::ROk(FFIValue::BoolV(false))
-                    }
-                })
-                .await
-        }
-        .into_ffi()
-    }
-}
-
-impl Custom for PtyProcess {}
-
-impl Drop for PtyProcess {
-    fn drop(self: &mut PtyProcess) {}
-}
-
-declare_module!(create_module);
-
-fn create_module() -> FFIModule {
-    let mut module = FFIModule::new("steel/pty-process");
-
-    module
-        .register_fn("create-native-pty-system!", create_native_pty_system)
-        .register_fn("kill-pty-process!", PtyProcess::kill)
-        .register_fn("pty-process-send-command", PtyProcess::send_command)
-        // .register_fn("pty-process-try-read-line", PtyProcess::try_read_line)
-        .register_fn("async-try-read-line", PtyProcess::async_try_read_line)
-        .register_fn("make-ansi-tokenizer", AnsiEscapeParser::new)
-        .register_fn("tokenize-line", AnsiEscapeParser::tokenize_ansi);
-
-    module
-}
-
-fn create_native_pty_system() -> PtyProcess {
-    let pty_system = NativePtySystem::default();
-
-    let pair = pty_system
-        .openpty(PtySize {
-            rows: 24,
-            cols: 80,
-            pixel_width: 0,
-            pixel_height: 0,
-        })
-        .unwrap();
-
-    let cmd = CommandBuilder::new("/bin/bash");
-    let child = pair.slave.spawn_command(cmd).unwrap();
-
-    // Release any handles owned by the slave: we don't need it now
-    // that we've spawned the child.
-    // drop(pair.slave);
-
-    // Read the output in another thread.
-    // This is important because it is easy to encounter a situation
-    // where read/write buffers fill and block either your process
-    // or the spawned process.
-    // let (tx, rx) = channel();
-    let (async_sender, async_receiver) = mpsc::unbounded_channel();
-
-    let (cancellation_token_sender, cancellation_token_receiver) = channel::<()>();
-
-    // let stay_alive = tx.clone();
-
-    let mut reader = pair.master.try_clone_reader().unwrap();
-    let mut writer = pair.master.take_writer().unwrap();
-
-    std::thread::spawn(move || {
-        // Consume the output from the child
-
-        // let mut bufreader = BufReader::new(reader);
-
-        let mut read_buffer = [0; 65536];
-
-        loop {
-            // let mut s = String::new();
-
-            // bufreader.read_line(&mut s).unwrap();
-
-            if let Ok(size) = reader.read(&mut read_buffer) {
-                if size != 0 {
-                    // if let Ok(escaped) = strip_ansi_escapes::strip(&read_buffer[..size]) {
-                    // if let Ok(back) = String::from_utf8_lossy(&read_buffer[..size]) {
-                    let r = async_sender.send(String::from_utf8_lossy(&read_buffer[..size]).into());
-
-                    r.ok(); // TODO: Figure out how to propagate the errors back
-                            // }
-                            // }
-                }
-            }
-
-            if cancellation_token_receiver.try_recv().is_ok() {
-                break;
-            }
-        }
-    });
-
-    let (command_sender, command_receiver) = channel::<String>();
-
-    {
-        // Obtain the writer.
-        // When the writer is dropped, EOF will be sent to
-        // the program that was spawned.
-        // It is important to take the writer even if you don't
-        // send anything to its stdin so that EOF can be
-        // generated, otherwise you risk deadlocking yourself.
-        // let mut writer = pair.master.take_writer().unwrap();
-
-        if cfg!(target_os = "macos") {
-            // macOS quirk: the child and reader must be started and
-            // allowed a brief grace period to run before we allow
-            // the writer to drop. Otherwise, the data we send to
-            // the kernel to trigger EOF is interleaved with the
-            // data read by the reader! WTF!?
-            // This appears to be a race condition for very short
-            // lived processes on macOS.
-            // I'd love to find a more deterministic solution to
-            // this than sleeping.
-            std::thread::sleep(std::time::Duration::from_millis(20));
-        }
-
-        // This example doesn't need to write anything, but if you
-        // want to send data to the child, you'd set `to_write` to
-        // that data and do it like this:
-        // let to_write = "ls -l";
-        // if !to_write.is_empty() {
-        // To avoid deadlock, wrt. reading and waiting, we send
-        // data to the stdin of the child in a different thread.
-        std::thread::spawn(move || loop {
-            while let Ok(command) = command_receiver.recv() {
-                writer.write_all(command.as_bytes()).unwrap();
-            }
-        });
-        // }
-    }
-
-    // command_sender.send("ls -l\r".to_string()).unwrap();
-    // std::thread::sleep(std::time::Duration::from_millis(20));
-
-    // command_sender.send("ls -l\r".to_string()).unwrap();
-    // std::thread::sleep(std::time::Duration::from_millis(20));
-    // Wait for the child to complete
-    // println!("child status: {:?}", child.wait().unwrap());
-
-    // THIS IS HOW YOU KILL IT
-    // child.kill().unwrap();
-    // cancellation_token_sender.send(()).unwrap();
-
-    // child.wa
-
-    // Take care to drop the master after our processes are
-    // done, as some platforms get unhappy if it is dropped
-    // sooner than that.
-    // drop(pair.master);
-
-    PtyProcess {
-        cancellation_token_sender,
-        command_sender,
-        // output_receiver: rx,
-        async_receiver: Arc::new(Mutex::new(async_receiver)),
-        pty_system: pair,
-        child,
-    }
-
-    // Now wait for the xxxxxx to be read by our reader thread
-    // let output = rx.recv().unwrap();
-
-    // for line in rx {
-    //     print!("{}", line);
-    // }
-
-    // We print with escapes escaped because the windows conpty
-    // implementation synthesizes title change escape sequences
-    // in the output stream and it can be confusing to see those
-    // printed out raw in another terminal.
-    // print!("output: ");
-    // TODO: Include this back when rendering to the built in terminal
-    // for c in output.escape_debug() {
-    //     print!("{}", c);
-    // }
-
-    // print!("{}", output);
-
-    // for c in output {
-    // print!("{}", c);
-    // }
-}
diff --git a/crates/steel-pty/src/main.rs b/crates/steel-pty/src/main.rs
deleted file mode 100644
index c2d8026bd..000000000
--- a/crates/steel-pty/src/main.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-//! This is a conceptually simple example that spawns the `whoami` program
-//! to print your username.  It is made more complex because there are multiple
-//! pipes involved and it is easy to get blocked/deadlocked if care and attention
-//! is not paid to those pipes!
-use portable_pty::{CommandBuilder, NativePtySystem, PtySize, PtySystem};
-use std::{io::Read, sync::mpsc::channel};
-
-fn main() {
-    let pty_system = NativePtySystem::default();
-
-    let pair = pty_system
-        .openpty(PtySize {
-            rows: 24,
-            cols: 80,
-            pixel_width: 0,
-            pixel_height: 0,
-        })
-        .unwrap();
-
-    let cmd = CommandBuilder::new("/bin/bash");
-    let mut child = pair.slave.spawn_command(cmd).unwrap();
-
-    // Release any handles owned by the slave: we don't need it now
-    // that we've spawned the child.
-    drop(pair.slave);
-
-    // Read the output in another thread.
-    // This is important because it is easy to encounter a situation
-    // where read/write buffers fill and block either your process
-    // or the spawned process.
-    let (tx, rx) = channel();
-
-    let (cancellation_token_sender, cancellation_token_receiver) = channel::<()>();
-
-    // let stay_alive = tx.clone();
-
-    let mut reader = pair.master.try_clone_reader().unwrap();
-    let mut writer = pair.master.take_writer().unwrap();
-
-    std::thread::spawn(move || {
-        // Consume the output from the child
-
-        // let mut bufreader = BufReader::new(reader);
-
-        let mut read_buffer = [0; 65536];
-
-        loop {
-            // let mut read_buffer = [0; 65536];
-
-            // let mut s = String::new();
-            // bufreader.read_line(&mut s).unwrap();
-
-            let size = reader.read(&mut read_buffer).unwrap();
-
-            // reader.read_to_string(&mut s).unwrap();
-
-            if size != 0 {
-                let s = String::from_utf8_lossy(&read_buffer[..size]).to_string();
-
-                let r = tx.send(s);
-
-                r.unwrap();
-            }
-
-            if cancellation_token_receiver.try_recv().is_ok() {
-                break;
-            }
-        }
-    });
-
-    let (command_sender, command_receiver) = channel::<String>();
-
-    {
-        // Obtain the writer.
-        // When the writer is dropped, EOF will be sent to
-        // the program that was spawned.
-        // It is important to take the writer even if you don't
-        // send anything to its stdin so that EOF can be
-        // generated, otherwise you risk deadlocking yourself.
-        // let mut writer = pair.master.take_writer().unwrap();
-
-        if cfg!(target_os = "macos") {
-            // macOS quirk: the child and reader must be started and
-            // allowed a brief grace period to run before we allow
-            // the writer to drop. Otherwise, the data we send to
-            // the kernel to trigger EOF is interleaved with the
-            // data read by the reader! WTF!?
-            // This appears to be a race condition for very short
-            // lived processes on macOS.
-            // I'd love to find a more deterministic solution to
-            // this than sleeping.
-            std::thread::sleep(std::time::Duration::from_millis(20));
-        }
-
-        // This example doesn't need to write anything, but if you
-        // want to send data to the child, you'd set `to_write` to
-        // that data and do it like this:
-        // let to_write = "ls -l";
-        // if !to_write.is_empty() {
-        // To avoid deadlock, wrt. reading and waiting, we send
-        // data to the stdin of the child in a different thread.
-        std::thread::spawn(move || loop {
-            while let Ok(command) = command_receiver.recv() {
-                writer.write_all(command.as_bytes()).unwrap();
-            }
-        });
-        // }
-    }
-
-    command_sender.send("ls -l\r".to_string()).unwrap();
-    std::thread::sleep(std::time::Duration::from_millis(20));
-
-    command_sender.send("ls -l\r".to_string()).unwrap();
-    std::thread::sleep(std::time::Duration::from_millis(20));
-    // Wait for the child to complete
-    // println!("child status: {:?}", child.wait().unwrap());
-
-    child.kill().unwrap();
-    cancellation_token_sender.send(()).unwrap();
-
-    // child.wa
-
-    // Take care to drop the master after our processes are
-    // done, as some platforms get unhappy if it is dropped
-    // sooner than that.
-    drop(pair.master);
-
-    // Now wait for the output to be read by our reader thread
-    // let output = rx.recv().unwrap();
-
-    for line in rx {
-        print!("{}", line);
-    }
-
-    // We print with escapes escaped because the windows conpty
-    // implementation synthesizes title change escape sequences
-    // in the output stream and it can be confusing to see those
-    // printed out raw in another terminal.
-    // print!("output: ");
-    // TODO: Include this back when rendering to the built in terminal
-    // for c in output.escape_debug() {
-    //     print!("{}", c);
-    // }
-
-    // print!("{}", output);
-
-    // for c in output {
-    // print!("{}", c);
-    // }
-}
diff --git a/crates/steel-repl/Cargo.toml b/crates/steel-repl/Cargo.toml
deleted file mode 100644
index a96cb7667..000000000
--- a/crates/steel-repl/Cargo.toml
+++ /dev/null
@@ -1,17 +0,0 @@
-[package]
-name = "steel-repl"
-version.workspace = true
-authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
-edition = "2021"
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/mattwparas/steel"
-description = "REPL library for steel"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-rustyline = "10.1.1"
-rustyline-derive = "0.7.0"
-colored = "2.0.0"
-steel-core = { workspace = true }
-steel-parser = { path = "../steel-parser", version = "0.4.0"}
diff --git a/crates/steel-repl/src/highlight.rs b/crates/steel-repl/src/highlight.rs
deleted file mode 100644
index 2b3359dff..000000000
--- a/crates/steel-repl/src/highlight.rs
+++ /dev/null
@@ -1,384 +0,0 @@
-extern crate rustyline;
-use colored::*;
-
-use std::{cell::RefCell, rc::Rc};
-
-use rustyline::highlight::Highlighter;
-use rustyline::validate::{
-    MatchingBracketValidator, ValidationContext, ValidationResult, Validator,
-};
-
-use rustyline::{hint::Hinter, Context};
-use rustyline_derive::Helper;
-
-use steel_parser::lexer::TokenStream;
-
-use rustyline::completion::Completer;
-use rustyline::completion::Pair;
-
-use std::borrow::Cow;
-
-use steel::steel_vm::engine::Engine;
-
-impl Completer for RustylineHelper {
-    type Candidate = Pair;
-}
-
-#[derive(Helper)]
-pub struct RustylineHelper {
-    // highlighter: MatchingBracketHighlighter,
-    validator: MatchingBracketValidator,
-    engine: Rc<RefCell<Engine>>,
-    bracket: std::cell::Cell<Option<(u8, usize)>>, // keywords: HashSet<&'static str>,
-}
-
-impl RustylineHelper {
-    pub fn new(validator: MatchingBracketValidator, engine: Rc<RefCell<Engine>>) -> Self {
-        Self {
-            validator,
-            engine,
-            bracket: std::cell::Cell::new(None),
-        }
-    }
-}
-
-impl Validator for RustylineHelper {
-    fn validate(&self, ctx: &mut ValidationContext) -> rustyline::Result<ValidationResult> {
-        self.validator.validate(ctx)
-    }
-
-    fn validate_while_typing(&self) -> bool {
-        self.validator.validate_while_typing()
-    }
-}
-
-impl Hinter for RustylineHelper {
-    type Hint = String;
-    fn hint(&self, _line: &str, _pos: usize, _context: &Context) -> Option<String> {
-        None
-    }
-}
-
-impl Highlighter for RustylineHelper {
-    fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
-        use steel_parser::tokens::TokenType;
-
-        use Cow::*;
-
-        // let line
-
-        // Borrowed(line)
-
-        // let matching_parens = self.highlighter.highlight(line, pos);
-
-        // let tokenizer = steel::parser
-
-        let mut line_to_highlight = line.to_owned();
-
-        let token_stream = TokenStream::new(line, true, None);
-
-        let mut ranges_to_replace: Vec<(std::ops::Range<usize>, String)> = Vec::new();
-
-        for token in token_stream {
-            // todo!()
-
-            // if token.span().end() > pos {
-            //     return self.highlighter.highlight(line, pos);
-            // }
-
-            match token.typ() {
-                // steel::parser::tokens::TokenType::OpenParen => todo!(),
-                // steel::parser::tokens::TokenType::CloseParen => todo!(),
-                // steel::parser::tokens::TokenType::QuoteTick => todo!(),
-                // steel::parser::tokens::TokenType::QuasiQuote => todo!(),
-                // steel::parser::tokens::TokenType::Unquote => todo!(),
-                // steel::parser::tokens::TokenType::UnquoteSplice => todo!(),
-                // steel::parser::tokens::TokenType::If => todo!(),
-                // steel::parser::tokens::TokenType::Define => todo!(),
-                // steel::parser::tokens::TokenType::Let => todo!(),
-                // steel::parser::tokens::TokenType::TestLet => todo!(),
-                // steel::parser::tokens::TokenType::Return => todo!(),
-                // steel::parser::tokens::TokenType::Begin => todo!(),
-                TokenType::Lambda
-                | TokenType::If
-                | TokenType::Define
-                | TokenType::Let
-                | TokenType::Require => {
-                    let highlighted = format!("{}", token.source().bright_purple());
-
-                    ranges_to_replace.push((token.span().range(), highlighted));
-
-                    // line_to_highlight.replace_range(token.span().range(), &highlighted);
-                }
-                // steel::parser::tokens::TokenType::Quote => todo!(),
-                // steel::parser::tokens::TokenType::SyntaxRules => todo!(),
-                // steel::parser::tokens::TokenType::DefineSyntax => todo!(),
-                // steel::parser::tokens::TokenType::Ellipses => todo!(),
-                // steel::parser::tokens::TokenType::Set => todo!(),
-                // steel::parser::tokens::TokenType::Require => todo!(),
-                // steel::parser::tokens::TokenType::CharacterLiteral(_) => todo!(),
-                // steel::parser::tokens::TokenType::Comment => todo!(),
-                TokenType::BooleanLiteral(_) => {
-                    let highlighted = format!("{}", token.source().bright_magenta());
-                    ranges_to_replace.push((token.span().range(), highlighted));
-                }
-                TokenType::Identifier(ident) => {
-                    // If its a free identifier, nix it?
-                    if self.engine.borrow().global_exists(ident) {
-                        // println!("before length: {}", token.source().as_bytes().len());
-                        let highlighted = format!("{}", token.source().bright_blue());
-                        // println!("After length: {}", highlighted.as_bytes().len());
-
-                        // println!("paren pos: {:?}", self.bracket.get());
-
-                        ranges_to_replace.push((token.span().range(), highlighted));
-                    }
-
-                    // else if self.engine.borrow().in_scope_macros().contains_key(*ident) {
-                    //     let highlighted = format!("{}", token.source().bright_cyan());
-                    //     ranges_to_replace.push((token.span().range(), highlighted));
-                    // }
-                }
-                // steel::parser::tokens::TokenType::Keyword(_) => todo!(),
-                TokenType::NumberLiteral(_) | TokenType::IntegerLiteral(_) => {
-                    // println!("Found something to replace! @ {:?}", token.span().range());
-
-                    let highlighted = format!("{}", token.source().bright_yellow());
-                    ranges_to_replace.push((token.span().range(), highlighted));
-
-                    // line_to_highlight.replace_range(token.span().range(), &highlighted);
-                }
-                TokenType::StringLiteral(_) => {
-                    let highlighted = format!("{}", token.source().bright_green());
-                    ranges_to_replace.push((token.span().range(), highlighted));
-                }
-                // steel::parser::tokens::TokenType::Error => todo!(),
-                _ => {}
-            }
-        }
-
-        let mut offset = 0;
-
-        for (range, highlighted) in ranges_to_replace.into_iter().rev() {
-            // self.bracket.set(check_bracket(&line_to_highlight, pos));
-
-            // println!("pos: {}")
-
-            let old_length = line_to_highlight.as_bytes().len();
-
-            // self.bracket.set(check_bracket(&line_to_highlight, start));
-
-            let start = range.start;
-
-            line_to_highlight.replace_range(range, &highlighted);
-
-            let new_length = line_to_highlight.as_bytes().len();
-
-            // TODO just store the updated location back in
-            if let Some((_bracket, pos)) = self.bracket.get() {
-                if start <= pos {
-                    offset += new_length - old_length;
-                }
-            }
-        }
-
-        // Cow::Owned(
-        //     self.highlighter
-        //         .highlight(&line_to_highlight, pos)
-        //         .to_string(),
-        // )
-
-        // if line.len() <= 1 {
-        //     return Borrowed(line);
-        // }
-        // highlight matching brace/bracket/parenthesis if it exists
-        if let Some((bracket, mut pos)) = self.bracket.get() {
-            if pos > 1 {
-                // println!("position!: {}", pos);
-                pos += offset;
-            }
-
-            // This seems its finding the matching bracket within the escaped sequences - this will need
-            // to _not_ check escaped
-            if let Some((matching, idx)) = find_matching_bracket(&line_to_highlight, pos, bracket) {
-                // let mut copy = line.to_owned();
-                line_to_highlight
-                    .replace_range(idx..=idx, &format!("\x1b[1;34m{}\x1b[0m", matching as char));
-                return Owned(line_to_highlight);
-            }
-        }
-
-        Cow::Owned(line_to_highlight)
-    }
-    // fn highlight_prompt<'b, 's: 'b, 'p: 'b>(
-    //     &'s self,
-    //     prompt: &'p str,
-    //     default: bool,
-    // ) -> Cow<'b, str> {}
-
-    // fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {}
-
-    // fn highlight_candidate<'c>(
-    //     &self,
-    //     candidate: &'c str,
-    //     completion: CompletionType,
-    // ) -> Cow<'c, str> {
-    //     self.highlighter.highlight_candidate(candidate, completion)
-    // }
-
-    // fn highlight_char(&self, line: &str, pos: usize) -> bool {
-    //     self.highlighter.highlight_char(line, pos)
-    // }
-
-    fn highlight_char(&self, line: &str, mut pos: usize) -> bool {
-        // will highlight matching brace/bracket/parenthesis if it exists
-        self.bracket.set(check_bracket(line, pos));
-        if self.bracket.get().is_some() {
-            return true;
-        }
-
-        if line.is_empty() {
-            return false;
-        }
-
-        if pos >= line.len() {
-            pos = line.len() - 1; // before cursor
-            let b = line.as_bytes()[pos]; // previous byte
-            match b {
-                b'"' | b' ' => true,
-                x if x.is_ascii_digit() => true,
-                _ => false,
-            }
-        } else {
-            self.bracket.get().is_some()
-        }
-    }
-}
-
-// impl Highlighter for MatchingBracketHighlighter {
-//     fn highlight<'l>(&self, line: &'l str, _pos: usize) -> Cow<'l, str> {
-//         use Cow::*;
-
-//         if line.len() <= 1 {
-//             return Borrowed(line);
-//         }
-//         // highlight matching brace/bracket/parenthesis if it exists
-//         if let Some((bracket, pos)) = self.bracket.get() {
-//             if let Some((matching, idx)) = find_matching_bracket(line, pos, bracket) {
-//                 let mut copy = line.to_owned();
-//                 copy.replace_range(idx..=idx, &format!("\x1b[1;34m{}\x1b[0m", matching as char));
-//                 return Owned(copy);
-//             }
-//         }
-//         Borrowed(line)
-//     }
-
-//     // fn highlight_char(&self, line: &str, pos: usize) -> bool {
-//     //     // will highlight matching brace/bracket/parenthesis if it exists
-//     //     self.bracket.set(check_bracket(line, pos));
-//     //     self.bracket.get().is_some()
-//     // }
-// }
-
-fn find_matching_bracket(line: &str, pos: usize, bracket: u8) -> Option<(u8, usize)> {
-    let matching = matching_bracket(bracket);
-    let mut idx;
-    let mut unmatched = 1;
-    if is_open_bracket(bracket) {
-        // forward search
-        idx = pos + 1;
-        let bytes = &line.as_bytes()[idx..];
-        for b in bytes {
-            if *b == matching {
-                unmatched -= 1;
-                if unmatched == 0 {
-                    debug_assert_eq!(matching, line.as_bytes()[idx]);
-                    return Some((matching, idx));
-                }
-            } else if *b == bracket {
-                unmatched += 1;
-            }
-            idx += 1;
-        }
-        debug_assert_eq!(idx, line.len());
-    } else {
-        // backward search
-        idx = pos;
-        let bytes = &line.as_bytes()[..idx];
-        for b in bytes.iter().rev() {
-            if *b == matching {
-                // if idx > 3 {
-                //     println!("{:?}", &line.as_bytes().get(idx));
-                //     println!("{:?}", b"\x1b");
-                // }
-
-                unmatched -= 1;
-                if unmatched == 0 {
-                    debug_assert_eq!(matching, line.as_bytes()[idx - 1]);
-                    return Some((matching, idx - 1));
-                }
-            } else if *b == bracket {
-                unmatched += 1;
-            }
-            idx -= 1;
-        }
-        debug_assert_eq!(idx, 0);
-    }
-    None
-}
-
-// check under or before the cursor
-fn check_bracket(line: &str, pos: usize) -> Option<(u8, usize)> {
-    if line.is_empty() {
-        return None;
-    }
-    let mut pos = pos;
-    if pos >= line.len() {
-        pos = line.len() - 1; // before cursor
-        let b = line.as_bytes()[pos]; // previous byte
-        if is_close_bracket(b) {
-            Some((b, pos))
-        } else {
-            None
-        }
-    } else {
-        let mut under_cursor = true;
-        loop {
-            let b = line.as_bytes()[pos];
-            if is_close_bracket(b) {
-                return if pos == 0 { None } else { Some((b, pos)) };
-            } else if is_open_bracket(b) {
-                return if pos + 1 == line.len() {
-                    None
-                } else {
-                    Some((b, pos))
-                };
-            } else if under_cursor && pos > 0 {
-                under_cursor = false;
-                pos -= 1; // or before cursor
-            } else {
-                return None;
-            }
-        }
-    }
-}
-
-const fn matching_bracket(bracket: u8) -> u8 {
-    match bracket {
-        b'{' => b'}',
-        b'}' => b'{',
-        // b'[' => b']',
-        // b']' => b'[',
-        b'(' => b')',
-        b')' => b'(',
-        b => b,
-    }
-}
-fn is_open_bracket(bracket: u8) -> bool {
-    // matches!(bracket, b'{' | b'[' | b'(')
-    matches!(bracket, b'{' | b'(')
-}
-fn is_close_bracket(bracket: u8) -> bool {
-    // matches!(bracket, b'}' | b']' | b')')
-    matches!(bracket, b'}' | b')')
-}
diff --git a/crates/steel-repl/src/lib.rs b/crates/steel-repl/src/lib.rs
deleted file mode 100644
index 3646314d3..000000000
--- a/crates/steel-repl/src/lib.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-#[macro_use]
-pub mod repl;
-pub mod highlight;
diff --git a/crates/steel-repl/src/repl.rs b/crates/steel-repl/src/repl.rs
deleted file mode 100644
index d929086c0..000000000
--- a/crates/steel-repl/src/repl.rs
+++ /dev/null
@@ -1,205 +0,0 @@
-extern crate rustyline;
-use colored::*;
-
-use std::{cell::RefCell, rc::Rc, sync::mpsc::channel};
-
-use rustyline::error::ReadlineError;
-
-use rustyline::validate::MatchingBracketValidator;
-use rustyline::Editor;
-
-use std::path::{Path, PathBuf};
-use steel::{rvals::SteelVal, steel_vm::register_fn::RegisterFn};
-
-use steel::steel_vm::engine::Engine;
-
-use std::io::Read;
-
-use std::time::Instant;
-
-use crate::highlight::RustylineHelper;
-
-fn display_help() {
-    println!(
-        "
-        :time       -- toggles the timing of expressions
-        :? | :help  -- displays help dialog
-        :quit       -- exits the REPL
-        :pwd        -- displays the current working directory
-        "
-    );
-}
-
-fn finish_load_or_interrupt(vm: &mut Engine, exprs: String, path: PathBuf) {
-    // let file_name = path.to_str().unwrap().to_string();
-
-    let res = vm.compile_and_run_raw_program_with_path(exprs.as_str(), path);
-
-    match res {
-        Ok(r) => r.into_iter().for_each(|x| match x {
-            SteelVal::Void => {}
-            SteelVal::StringV(s) => {
-                println!("{} {:?}", "=>".bright_blue().bold(), s);
-            }
-            _ => {
-                print!("{} ", "=>".bright_blue().bold());
-                vm.call_function_by_name_with_args("displayln", vec![x])
-                    .unwrap();
-            }
-        }),
-        Err(e) => {
-            vm.raise_error(e);
-        }
-    }
-}
-
-fn finish_or_interrupt(vm: &mut Engine, line: String, print_time: bool) {
-    let now = Instant::now();
-
-    let res = vm.compile_and_run_raw_program(&line);
-
-    match res {
-        Ok(r) => r.into_iter().for_each(|x| match x {
-            SteelVal::Void => {}
-            SteelVal::StringV(s) => {
-                println!("{} {:?}", "=>".bright_blue().bold(), s);
-            }
-            _ => {
-                print!("{} ", "=>".bright_blue().bold());
-                vm.call_function_by_name_with_args("displayln", vec![x])
-                    .unwrap();
-            }
-        }),
-        Err(e) => {
-            vm.raise_error(e);
-        }
-    }
-
-    if print_time {
-        println!("Time taken: {:?}", now.elapsed());
-    }
-}
-
-/// Entire point for the repl
-/// Automatically adds the prelude and contracts for the core library
-pub fn repl_base(mut vm: Engine) -> std::io::Result<()> {
-    println!(
-        "{}",
-        r#"
-     _____ __            __
-    / ___// /____  ___  / /          Version 0.5.0
-    \__ \/ __/ _ \/ _ \/ /           https://github.com/mattwparas/steel
-   ___/ / /_/  __/  __/ /            :? for help
-  /____/\__/\___/\___/_/ 
-    "#
-        .bright_yellow()
-        .bold()
-    );
-    let mut prompt = format!("{}", "λ > ".bright_green().bold().italic());
-
-    let mut rl = Editor::<RustylineHelper>::new().expect("Unable to instantiate the repl!");
-
-    let current_dir = std::env::current_dir()?;
-
-    let mut print_time = false;
-
-    let (tx, rx) = channel();
-    let tx = std::sync::Mutex::new(tx);
-
-    let cancellation_function = move || {
-        tx.lock().unwrap().send(()).unwrap();
-    };
-
-    vm.register_fn("quit", cancellation_function);
-
-    let engine = Rc::new(RefCell::new(vm));
-    rl.set_helper(Some(RustylineHelper::new(
-        MatchingBracketValidator::default(),
-        engine.clone(),
-    )));
-
-    // ctrlc::set_handler(move || tx.send(()).expect("Could not send signal on channel."))
-    // .expect("Error setting Ctrl-C handler");
-
-    // vm.on_progress(move |x| {
-    //     if x % 1000 == 0 {
-    //         match rx.try_recv() {
-    //             Ok(_) => return false,
-    //             _ => {}
-    //         }
-    //     }
-    //     true
-    // });
-
-    while rx.try_recv().is_err() {
-        let readline = rl.readline(&prompt);
-
-        match readline {
-            Ok(line) => {
-                rl.add_history_entry(line.as_str());
-                match line.as_str() {
-                    ":quit" => return Ok(()),
-                    // ":reset" => interpreter.reset(),
-                    ":time" => {
-                        print_time = !print_time;
-                        println!(
-                            "{} {}",
-                            "Expression timer set to:".bright_purple(),
-                            print_time.to_string().bright_green()
-                        );
-                    }
-                    ":pwd" => println!("{current_dir:#?}"),
-                    // ":env" => vm.print_bindings(),
-                    ":?" | ":help" => display_help(),
-                    line if line.contains(":load") => {
-                        let line = line.trim_start_matches(":load").trim();
-
-                        // Update the prompt to now include the new context
-                        prompt = format!(
-                            "{}",
-                            format!("λ ({line}) > ").bright_green().bold().italic(),
-                        );
-
-                        let path = Path::new(line);
-
-                        let file = std::fs::File::open(path);
-
-                        if let Err(e) = file {
-                            eprintln!("{e}");
-                            continue;
-                        }
-
-                        let mut file = file?;
-
-                        let mut exprs = String::new();
-                        file.read_to_string(&mut exprs)?;
-
-                        finish_load_or_interrupt(
-                            &mut engine.borrow_mut(),
-                            exprs,
-                            path.to_path_buf(),
-                        );
-                    }
-                    _ => {
-                        // TODO also include this for loading files
-                        finish_or_interrupt(&mut engine.borrow_mut(), line, print_time);
-                    }
-                }
-            }
-            Err(ReadlineError::Interrupted) => {
-                println!("CTRL-C");
-                break;
-            }
-            Err(ReadlineError::Eof) => {
-                println!("CTRL-D");
-                break;
-            }
-            Err(err) => {
-                println!("Error: {err:?}");
-                break;
-            }
-        }
-    }
-
-    Ok(())
-}
diff --git a/crates/steel-sys-info/Cargo.toml b/crates/steel-sys-info/Cargo.toml
deleted file mode 100644
index ce83f2427..000000000
--- a/crates/steel-sys-info/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "steel-sys-info"
-version.workspace = true
-edition = "2021"
-
-
-[lib]
-name = "steel_sys_info"
-crate-type = ["cdylib"]
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-steel-core = { workspace = true }
-abi_stable = "0.11.1"
-sys-info = "0.9.1"
\ No newline at end of file
diff --git a/crates/steel-sys-info/src/lib.rs b/crates/steel-sys-info/src/lib.rs
deleted file mode 100644
index 3421b431c..000000000
--- a/crates/steel-sys-info/src/lib.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-// Using ABI Stable types is very important
-use steel::{
-    declare_module,
-    rvals::Custom,
-    steel_vm::ffi::{FFIModule, RegisterFFIFn},
-};
-
-struct MemoryInfo {
-    info: sys_info::MemInfo,
-}
-
-impl MemoryInfo {
-    fn total(&self) -> isize {
-        self.info.total as isize
-    }
-
-    fn avail(&self) -> isize {
-        self.info.avail as isize
-    }
-
-    fn free(&self) -> isize {
-        self.info.free as isize
-    }
-
-    fn buffers(&self) -> isize {
-        self.info.buffers as isize
-    }
-
-    fn cached(&self) -> isize {
-        self.info.cached as isize
-    }
-
-    fn swap_total(&self) -> isize {
-        self.info.swap_total as isize
-    }
-
-    fn swap_free(&self) -> isize {
-        self.info.swap_free as isize
-    }
-}
-
-impl Custom for MemoryInfo {}
-
-declare_module!(create_module);
-
-fn create_module() -> FFIModule {
-    let mut module = FFIModule::new("steel/sys-info");
-
-    module.register_fn("mem-info", || MemoryInfo {
-        info: sys_info::mem_info().unwrap(),
-    });
-
-    module
-        .register_fn("MemoryInfo-total", MemoryInfo::total)
-        .register_fn("MemoryInfo-avail", MemoryInfo::avail)
-        .register_fn("MemoryInfo-free", MemoryInfo::free)
-        .register_fn("MemoryInfo-buffers", MemoryInfo::buffers)
-        .register_fn("MemoryInfo-cached", MemoryInfo::cached)
-        .register_fn("MemoryInfo-swap-total", MemoryInfo::swap_total)
-        .register_fn("MemoryInfo-swap-free", MemoryInfo::swap_free);
-
-    module
-}
diff --git a/crates/steel-sys-info/sys-info.scm b/crates/steel-sys-info/sys-info.scm
deleted file mode 100644
index 6a87c6bfe..000000000
--- a/crates/steel-sys-info/sys-info.scm
+++ /dev/null
@@ -1,16 +0,0 @@
-(#%require-dylib "libsteel_sys_info"
-                 (only-in mem-info
-                          MemoryInfo-total
-                          MemoryInfo-avail
-                          MemoryInfo-free
-                          MemoryInfo-buffers
-                          MemoryInfo-cached
-                          MemoryInfo-swap-total
-                          MemoryInfo-swap-free))
-
-(define (current-memory-usage #:memory-info (memory-info (mem-info)))
-  (- (MemoryInfo-total memory-info) (MemoryInfo-free memory-info) (MemoryInfo-cached memory-info)))
-
-;; TODO: Clean up error message if the hash is missing keys?
-(define (memory-usage-as-percentage #:memory-info (memory-info (mem-info)))
-  (/ (current-memory-usage #:memory-info memory-info) (MemoryInfo-total memory-info)))
diff --git a/crates/steel-toml/Cargo.toml b/crates/steel-toml/Cargo.toml
deleted file mode 100644
index c52c563a5..000000000
--- a/crates/steel-toml/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "steel-toml"
-version.workspace = true
-edition = "2021"
-
-[lib]
-name = "steel_toml"
-crate-type = ["cdylib"]
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-steel-core = { workspace = true }
-toml = "0.7.1"
-abi_stable = "0.11.1"
diff --git a/crates/steel-toml/src/lib.rs b/crates/steel-toml/src/lib.rs
deleted file mode 100644
index 34ff05cf1..000000000
--- a/crates/steel-toml/src/lib.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use abi_stable::std_types::RVec;
-
-use toml::Value;
-
-use steel::declare_module;
-use steel::steel_vm::ffi::{FFIModule, FFIValue, RegisterFFIFn};
-
-struct SteelTomlValue(Value);
-
-impl SteelTomlValue {
-    fn as_ffi_value(&self) -> FFIValue {
-        as_ffi_value(&self.0)
-    }
-}
-
-impl steel::rvals::Custom for SteelTomlValue {}
-
-// fn as_native_steelval(value: &Value) -> steel::rvals::Result<SteelVal> {
-//     match value {
-//         Value::String(s) => Ok(s.clone().into()),
-//         Value::Integer(i) => Ok((*i as i32).into()),
-//         Value::Float(f) => Ok((*f).into()),
-//         Value::Boolean(b) => Ok((*b).into()),
-//         Value::Datetime(_) => todo!(),
-//         Value::Array(a) => Ok(a
-//             .into_iter()
-//             .map(|x| as_native_steelval(x))
-//             .collect::<steel::rvals::Result<steel::List<steel::SteelVal>>>()?
-//             .into()),
-//         Value::Table(m) => Ok(SteelVal::HashMapV(steel::gc::Gc::new(
-//             m.into_iter()
-//                 .map(|x| {
-//                     let key: steel::SteelVal = x.0.clone().into();
-//                     let value = as_native_steelval(x.1)?;
-
-//                     Ok((key, value))
-//                 })
-//                 .collect::<steel::rvals::Result<steel::HashMap<_, _>>>()?,
-//         ))),
-//     }
-// }
-
-fn as_ffi_value(value: &Value) -> FFIValue {
-    match value {
-        Value::String(s) => s.clone().into(),
-        Value::Integer(i) => (*i as isize).into(),
-        Value::Float(f) => (*f).into(),
-        Value::Boolean(b) => (*b).into(),
-        Value::Datetime(_) => todo!(),
-        Value::Array(a) => a.iter().map(as_ffi_value).collect::<RVec<_>>().into(),
-        // Value::Table(m) => Ok(SteelVal::HashMapV(steel::gc::Gc::new(
-        //     m.into_iter()
-        //         .map(|x| {
-        //             let key: steel::SteelVal = x.0.clone().into();
-        //             let value = as_ffi_value(x.1);
-
-        //             Ok((key, value))
-        //         })
-        //         .collect::<steel::rvals::Result<steel::HashMap<_, _>>>()?,
-        // ))),
-        _ => todo!(),
-    }
-}
-// impl FromSteelVal for SteelTomlValue {
-//     fn from_steelval(val: &SteelVal) -> steel::rvals::Result<Self> {
-//         todo!()
-//     }
-// }
-
-// thread_local! {
-//     static MODULE: Rc<BuiltInModule> = create_module();
-// }
-
-declare_module!(create_module);
-
-fn create_module() -> FFIModule {
-    let mut module = FFIModule::new("dylib/toml");
-
-    module.register_fn("toml->value", SteelTomlValue::as_ffi_value);
-    module
-}
diff --git a/crates/steel-values/Cargo.toml b/crates/steel-values/Cargo.toml
deleted file mode 100644
index fd950a0b1..000000000
--- a/crates/steel-values/Cargo.toml
+++ /dev/null
@@ -1,8 +0,0 @@
-[package]
-name = "steel-values"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
diff --git a/crates/steel-values/src/lib.rs b/crates/steel-values/src/lib.rs
deleted file mode 100644
index 7d12d9af8..000000000
--- a/crates/steel-values/src/lib.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
diff --git a/crates/steel-webrequests/Cargo.toml b/crates/steel-webrequests/Cargo.toml
deleted file mode 100644
index 62cf73d37..000000000
--- a/crates/steel-webrequests/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "steel-webrequests"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-name = "steel_webrequests"
-crate-type = ["cdylib"]
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-steel-core = { workspace = true }
-abi_stable = "0.11.1"
-ureq = { version = "2.6.2", features = ["json"] }
diff --git a/crates/steel-webrequests/src/lib.rs b/crates/steel-webrequests/src/lib.rs
deleted file mode 100644
index 51662a897..000000000
--- a/crates/steel-webrequests/src/lib.rs
+++ /dev/null
@@ -1,71 +0,0 @@
-use steel::rvals::Custom;
-use steel::{
-    declare_module,
-    steel_vm::ffi::{FFIModule, RegisterFFIFn},
-};
-
-use ureq::{Request, Response};
-
-declare_module!(create_module);
-
-fn create_module() -> FFIModule {
-    let mut module = FFIModule::new("steel/web/blocking/requests".to_string());
-
-    module
-        .register_fn("get", get)
-        .register_fn(
-            "call",
-            |request: BlockingRequest| -> Result<SteelResponse, BlockingError> {
-                Request::call(request.0)
-                    .map(|x| x.into())
-                    .map_err(BlockingError::Ureq)
-            },
-        )
-        .register_fn("response->text", SteelResponse::into_text);
-
-    module
-}
-
-#[derive(Clone)]
-struct BlockingRequest(Request);
-struct BlockingResponse(Response);
-
-enum BlockingError {
-    Ureq(ureq::Error),
-    ResponseAlreadyUsed,
-}
-
-impl Custom for BlockingRequest {}
-impl Custom for BlockingResponse {}
-impl Custom for BlockingError {}
-
-fn get(url: String) -> BlockingRequest {
-    BlockingRequest(ureq::get(&url))
-}
-
-struct SteelResponse {
-    response: Option<ureq::Response>,
-}
-
-impl SteelResponse {
-    fn into_text(&mut self) -> Result<String, BlockingError> {
-        let resp = self.response.take();
-
-        if let Some(resp) = resp {
-            resp.into_string()
-                .map_err(|x| BlockingError::Ureq(x.into()))
-        } else {
-            Err(BlockingError::ResponseAlreadyUsed)
-        }
-    }
-}
-
-impl From<ureq::Response> for SteelResponse {
-    fn from(value: ureq::Response) -> Self {
-        SteelResponse {
-            response: Some(value),
-        }
-    }
-}
-
-impl Custom for SteelResponse {}
diff --git a/crates/steel-webrequests/webrequests.scm b/crates/steel-webrequests/webrequests.scm
deleted file mode 100644
index e5c06f005..000000000
--- a/crates/steel-webrequests/webrequests.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(#%require-dylib "libsteel_webrequests" (only-in get call response->text))
-
-(provide get
-         call
-         response->text)
diff --git a/crates/steel-webserver/Cargo.toml b/crates/steel-webserver/Cargo.toml
deleted file mode 100644
index 9b687911a..000000000
--- a/crates/steel-webserver/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-name = "steel-webserver"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-name = "steel_webserver"
-crate-type = ["cdylib"]
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-steel-core = { workspace = true }
-axum = { version = "0.6.2", features = ["query"] }
-tokio = { version = "1.0", features = ["full"] }
-crossbeam = "0.8.2"
-serde_json = "1.0.92"
-abi_stable = "0.11.1"
diff --git a/crates/steel-webserver/benches/fast.py b/crates/steel-webserver/benches/fast.py
deleted file mode 100644
index 979a062c3..000000000
--- a/crates/steel-webserver/benches/fast.py
+++ /dev/null
@@ -1,34 +0,0 @@
-import sqlite3
-from fastapi import FastAPI
-
-app = FastAPI()
-
-con = sqlite3.connect(":memory:", check_same_thread=False)
-
-cur = con.cursor()
-
-cur.execute(
-    """
-    CREATE TABLE person (
-        id   INTEGER PRIMARY KEY,
-        name TEXT NOT NULL,
-        data TEXT
-    )"""
-)
-
-cur.executemany(
-    "INSERT INTO person (name, data) VALUES (?1, ?2)",
-    [("Steven", "likes to eat"), ("Alex", "likes biking"), ("Matt", "likes running")],
-)
-
-
-def get_people():
-    return list(cur.execute("SELECT id, name, data FROM person"))
-
-
-# print(get_people())
-
-
-@app.get("/people")
-async def people():
-    return get_people()
diff --git a/crates/steel-webserver/server.scm b/crates/steel-webserver/server.scm
deleted file mode 100644
index 76fe2ec62..000000000
--- a/crates/steel-webserver/server.scm
+++ /dev/null
@@ -1,97 +0,0 @@
-(require-builtin dylib/steel/webserver)
-(require-builtin steel/sqlite)
-(require "steel/result")
-; (require "steel/logging/log.scm")
-
-
-(define connection (unwrap-ok (connection/open-in-memory)))
-
-(connection/execute! connection
-    "CREATE TABLE person (
-        id   INTEGER PRIMARY KEY,
-        name TEXT NOT NULL,
-        data TEXT
-    )" '())
-
-(connection/prepare-and-execute! connection
-    "INSERT INTO person (name, data) VALUES (?1, ?2)"
-    (list (list "Steven" "likes to eat")
-          (list "Alex" "likes biking")
-          (list "Matt" "likes running")))
-
-(define (get-people)
-    (map (lambda (x)
-            (hash "name" (list-ref x 1)
-                  "data" (list-ref x 2)))
-         (unwrap-ok (connection/prepare-and-query! connection "SELECT id, name, data FROM person" '()))))
-
-
-(define (add-person person-hash)
-    (connection/prepare-and-execute! connection 
-        "INSERT INTO person (name, data) VALUES (?1, ?2)"
-        (list (list (hash-get person-hash 'name) 
-                    (hash-get person-hash 'data)))))
-
-
-(define vm-receiver void)
-(define vm-sender void)
-(define command-channel void)
-
-;; We don't need the extra garbage laying around, so we'll just go ahead
-;; and unroot these channels here
-(let ((channels (setup-channels)))
-    (set! vm-sender (first channels))
-    (set! vm-receiver (second channels))
-    (set! command-channel (third channels)))
-
-
-(define (hello-world-handler)
-    (value->jsexpr-string 
-            (hash 'hello "world")))
-
-(define (people-handler)
-    (value->jsexpr-string (get-people)))
-
-(define (add-person-handler person-hash)
-    (displayln person-hash)
-    (add-person person-hash)
-    (value->jsexpr-string person-hash))
-
-(define *routes*
-    (hash "hello/world" hello-world-handler
-          "people" people-handler))
-
-(define *post-routes* (hash "add" add-person-handler))
-
-(define (handle-request req)
-    (define type (request-type req))
-    ; (displayln "Path: " (request-path req))
-    (cond 
-          [(eq? request-type/GET type) => ((hash-get *routes* (request-path req)))]
-          
-        ;   [(eq? request-type/GET type) => (people-handler)]
-          [(eq? request-type/POST type) => ((hash-get *post-routes* (request-path req)) (request-body req))]
-          [else => (displayln "Unknown request type!: " type)]))
-
-
-(define (loop)
-
-    (with-handler 
-        (lambda (err) (report-error! err) (sender/send vm-sender (Err (to-string err))))
-        (->> (receiver/recv vm-receiver)
-                (handle-request)
-                (Ok)
-                (sender/send vm-sender)))
-
-
-    
-
-    (loop))
-
-
-(start-server! 
-    command-channel
-    '("/*route") 
-    3000)
-
-(loop)
\ No newline at end of file
diff --git a/crates/steel-webserver/src/lib.rs b/crates/steel-webserver/src/lib.rs
deleted file mode 100644
index 574206484..000000000
--- a/crates/steel-webserver/src/lib.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-#![allow(unused)]
-
-use axum::{extract::Query, http::StatusCode, routing::get, Json, Router};
-use std::{collections::HashMap, net::SocketAddr};
-use steel::{
-    rvals::Custom,
-    steel_vm::ffi::{FFIModule, FFIValue, IntoFFIVal, RegisterFFIFn},
-    SteelVal,
-};
-
-use crossbeam::channel::{unbounded, Receiver, Sender};
-
-use axum::extract::Path;
-
-thread_local! {
-    static POST: SteelVal = SteelVal::SymbolV("POST".into());
-    static GET: SteelVal = SteelVal::SymbolV("GET".into());
-}
-
-#[derive(Copy, Clone, PartialEq, Eq)]
-enum RequestType {
-    Post,
-    Get,
-}
-
-#[derive(Clone, PartialEq, Eq)]
-struct Request {
-    typ: RequestType,
-    path: String,
-    body: Option<serde_json::Value>,
-}
-
-impl Custom for Request {}
-
-impl Request {
-    fn get_type(&self) -> SteelVal {
-        match self.typ {
-            RequestType::Post => POST.with(|x| x.clone()),
-            RequestType::Get => GET.with(|x| x.clone()),
-        }
-    }
-
-    fn get_path(&self) -> String {
-        self.path.clone()
-    }
-
-    fn get_body(&self) -> Option<serde_json::Value> {
-        self.body.clone()
-    }
-}
-
-#[derive(Clone)]
-struct CommandMessenger {
-    sender: Sender<Request>,
-    receiver: Receiver<Result<String, String>>,
-}
-
-impl Custom for CommandMessenger {}
-
-impl CommandMessenger {
-    pub fn new(sender: Sender<Request>, receiver: Receiver<Result<String, String>>) -> Self {
-        Self { sender, receiver }
-    }
-
-    pub fn send_request(&self, request: Request) {
-        // todo!()
-
-        // Send the message to the VM context to parse
-        match self.sender.send(request) {
-            Ok(_) => {}
-            Err(e) => {
-                println!("Error: {e:?}")
-            }
-        };
-        // .expect("Failed to send message to VM");
-    }
-}
-
-#[derive(Clone)]
-struct WrappedReceiver {
-    receiver: Receiver<Request>,
-}
-
-impl WrappedReceiver {
-    fn recv(&self) -> Request {
-        self.receiver.recv().unwrap()
-    }
-}
-
-impl Custom for WrappedReceiver {}
-
-#[derive(Clone)]
-struct WrappedSender {
-    sender: Sender<Result<String, String>>,
-}
-
-impl WrappedSender {
-    fn send(&self, value: Result<String, String>) {
-        self.sender.send(value).unwrap()
-    }
-}
-
-impl Custom for WrappedSender {}
-
-fn setup_channels() -> Vec<FFIValue> {
-    let (command_sender, vm_receiver) = unbounded();
-    let (vm_sender, command_receiver) = unbounded();
-
-    let command_messenger = CommandMessenger::new(command_sender, command_receiver);
-
-    vec![
-        WrappedSender { sender: vm_sender }.into_ffi_val().unwrap(),
-        WrappedReceiver {
-            receiver: vm_receiver,
-        }
-        .into_ffi_val()
-        .unwrap(),
-        command_messenger.into_ffi_val().unwrap(),
-    ]
-}
-
-// thread_local! {
-//     static MODULE: Rc<BuiltInModule> = create_module();
-// }
-
-// #[no_mangle]
-// fn create_module() -> Box<BuiltInModule> {
-//     let mut module = BuiltInModule::new("dylib/steel/webserver".to_string());
-
-//     // module.register_fn("toml->value", SteelTomlValue::as_value);
-
-//     module
-//         .register_fn("start-server!", spawn_server)
-//         .register_fn("setup-channels", setup_channels)
-//         .register_fn("receiver/recv", WrappedReceiver::recv)
-//         .register_fn("sender/send", WrappedSender::send)
-//         .register_fn("thread/join", WrappedJoinHandler::join)
-//         .register_fn("request-type", Request::get_type)
-//         .register_fn("request-path", Request::get_path)
-//         .register_fn("request-body", Request::get_body)
-//         .register_value("request-type/POST", POST.with(|x| x.clone()))
-//         .register_value("request-type/GET", GET.with(|x| x.clone()));
-
-//     // module.register_type::<SteelTomlValue>("toml?");
-
-//     // module.register_
-
-//     // module.register_value("outside-value", SteelVal::StringV("Hello world!".into()));
-//     // module.register_fn("hidden-function", hidden_function);
-
-//     // Rc::new(module)
-//     Box::new(module)
-// }
-
-steel::declare_module!(build_module);
-
-pub fn build_module() -> FFIModule {
-    let mut module = FFIModule::new("dylib/steel/webserver");
-
-    module
-        .register_fn("start-server!", spawn_server)
-        .register_fn("setup-channels", setup_channels)
-        .register_fn("receiver/recv", WrappedReceiver::recv)
-        // .register_fn("sender/send", WrappedSender::send)
-        .register_fn("thread/join", WrappedJoinHandler::join)
-        // .register_fn("request-type", Request::get_type)
-        .register_fn("request-path", Request::get_path)
-        // .register_fn("request-body", Request::get_body)
-    ;
-
-    //     .register_value("request-type/POST", POST.with(|x| x.clone()))
-    //     .register_value("request-type/GET", GET.with(|x| x.clone()));
-
-    module
-}
-
-struct WrappedJoinHandler {
-    handle: Option<std::thread::JoinHandle<()>>,
-}
-
-impl WrappedJoinHandler {
-    fn join(&mut self) {
-        self.handle.take().unwrap().join().unwrap()
-
-        // self.handle.join().unwrap()
-    }
-}
-
-impl Custom for WrappedJoinHandler {}
-
-fn spawn_server(
-    command_messenger: CommandMessenger,
-    routes: Vec<String>,
-    port: usize,
-) -> WrappedJoinHandler {
-    let handle = std::thread::spawn(move || {
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .build()
-            .unwrap()
-            .block_on(async {
-                // let (command_sender, vm_receiver) = unbounded();
-                // let (vm_sender, command_receiver) = unbounded();
-
-                // let command_messenger = CommandMessenger::new(command_sender, command_receiver);
-
-                // let post_messenger = command_messenger.clone();
-
-                let mut app = Router::new();
-
-                for route in routes {
-                    let messenger = command_messenger.clone();
-
-                    app = app.route(
-                        &route,
-                        get(
-                            |Path(path): Path<String>,
-                             Path(_params): Path<std::collections::HashMap<String, String>>,
-                             Query(_query): Query<HashMap<String, String>>,
-                             _json: Option<Json<serde_json::Value>>| async move {
-                                // println!("Receiving request");
-
-                                // println!("path parameters: {:?}", params);
-                                // println!("Query parameters: {:?}", query);
-                                // println!("Body: {:?}", json);
-
-                                let request = Request {
-                                    typ: RequestType::Get,
-                                    path,
-                                    body: None,
-                                };
-
-                                messenger.send_request(request);
-
-                                match messenger.receiver.recv() {
-                                    Ok(Ok(v)) => Ok(v),
-                                    Ok(Err(_)) => Err(StatusCode::INTERNAL_SERVER_ERROR),
-                                    Err(_) => Err(StatusCode::INTERNAL_SERVER_ERROR),
-                                }
-                                // messenger.receiver.recv().unwrap()
-                            },
-                        ),
-                    );
-                }
-
-                // run it
-                let addr = SocketAddr::from(([127, 0, 0, 1], port as u16));
-                println!("listening on {addr}");
-                axum::Server::bind(&addr)
-                    .serve(app.into_make_service())
-                    .await
-                    .unwrap();
-            })
-    });
-
-    WrappedJoinHandler {
-        handle: Some(handle),
-    }
-}
-
-// async fn handler() -> String {
-//     let mut engine = Engine::new();
-//     let results = engine
-//         .compile_and_run_raw_program(
-//             "(define x 10) (define y 100) (define z (int->string (+ x y))) z",
-//         )
-//         .unwrap();
-//     // println!("{:?}", results);
-//     "Hello world".to_string()
-// }
diff --git a/crates/steel-websockets/Cargo.toml b/crates/steel-websockets/Cargo.toml
deleted file mode 100644
index 17708b52e..000000000
--- a/crates/steel-websockets/Cargo.toml
+++ /dev/null
@@ -1,15 +0,0 @@
-[package]
-name = "steel-websockets"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-name = "steel_websockets"
-crate-type = ["cdylib"]
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-steel-core = { workspace = true }
-abi_stable = "0.11.1"
-tungstenite = { version = "0.18.0", features = ["rustls-tls-native-roots"] }
diff --git a/crates/steel-websockets/src/lib.rs b/crates/steel-websockets/src/lib.rs
deleted file mode 100644
index 8ca2e5e43..000000000
--- a/crates/steel-websockets/src/lib.rs
+++ /dev/null
@@ -1,121 +0,0 @@
-use std::net::TcpStream;
-
-use tungstenite::{
-    connect, handshake::client::Response, stream::MaybeTlsStream, Message, WebSocket,
-};
-
-use steel::{rvals::Custom, steel_vm::ffi::IntoFFIVal};
-
-use steel::{
-    declare_module,
-    steel_vm::ffi::{FFIModule, RegisterFFIFn},
-};
-
-struct SteelWebSocket(WebSocket<MaybeTlsStream<TcpStream>>);
-impl Custom for SteelWebSocket {}
-
-impl SteelWebSocket {
-    fn read_message(&mut self) -> Result<WebSocketMessage, WebSocketError> {
-        self.0
-            .read_message()
-            .map(WebSocketMessage)
-            .map_err(WebSocketError)
-    }
-
-    fn write_message(&mut self, message: WebSocketMessage) -> Result<(), WebSocketError> {
-        self.0.write_message(message.0).map_err(WebSocketError)
-    }
-}
-
-#[derive(Clone)]
-struct WebSocketMessage(Message);
-
-impl Custom for WebSocketMessage {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("{:?}", self.0)))
-    }
-}
-
-impl WebSocketMessage {
-    fn is_ping(&self) -> bool {
-        self.0.is_ping()
-    }
-
-    fn is_pong(&self) -> bool {
-        self.0.is_pong()
-    }
-
-    fn is_text(&self) -> bool {
-        self.0.is_text()
-    }
-}
-
-struct WebSocketResponse(Response);
-impl Custom for WebSocketResponse {}
-
-struct WebSocketError(tungstenite::Error);
-
-impl Custom for WebSocketError {
-    fn fmt(&self) -> Option<std::result::Result<String, std::fmt::Error>> {
-        Some(Ok(format!("{:?}", self.0)))
-    }
-}
-
-/// In lieu of a direct bytes type in Steel, since we need to typically respond to a ping with a pong
-/// containing the matching payload, we can skip the deserializing into the Steel type and directly
-/// construct the pong here
-fn ping_to_pong(message: &WebSocketMessage) -> Option<WebSocketMessage> {
-    if let Message::Ping(payload) = &message.0 {
-        Some(WebSocketMessage(Message::Pong(payload.clone())))
-    } else {
-        None
-    }
-}
-
-/// Extracts the payload from a given message
-fn text_payload(message: &WebSocketMessage) -> Option<String> {
-    if let Message::Text(text) = &message.0 {
-        Some(text.clone())
-    } else {
-        None
-    }
-}
-
-// TODO: @Matt -> perhaps explore this and/or explore using tokio tungstenite for this
-fn _make_non_blocking(socket: &mut SteelWebSocket) -> std::result::Result<(), std::io::Error> {
-    match socket.0.get_mut() {
-        MaybeTlsStream::Plain(s) => s.set_nonblocking(true),
-        MaybeTlsStream::Rustls(s) => s.get_mut().set_nonblocking(true),
-        _ => todo!(),
-    }
-}
-
-declare_module!(create_module);
-
-fn create_module() -> FFIModule {
-    let mut module = FFIModule::new("steel/web/ws");
-
-    module
-        .register_fn("ws/message-ping?", WebSocketMessage::is_ping)
-        .register_fn("ws/message-pong?", WebSocketMessage::is_pong)
-        .register_fn("ws/message-text?", WebSocketMessage::is_text)
-        .register_fn("ws/message-text", |text: String| {
-            WebSocketMessage(Message::Text(text))
-        })
-        .register_fn("ws/message-ping->pong", ping_to_pong)
-        .register_fn("ws/message->text-payload", text_payload)
-        .register_fn("ws/connect", |url: String| {
-            connect(url)
-                .map(|(socket, resp)| {
-                    vec![
-                        SteelWebSocket(socket).into_ffi_val().unwrap(),
-                        WebSocketResponse(resp).into_ffi_val().unwrap(),
-                    ]
-                })
-                .map_err(WebSocketError)
-        })
-        .register_fn("ws/read-message!", SteelWebSocket::read_message)
-        .register_fn("ws/write-message!", SteelWebSocket::write_message);
-
-    module
-}
diff --git a/crates/steel-websockets/websockets.scm b/crates/steel-websockets/websockets.scm
deleted file mode 100644
index 030eb433e..000000000
--- a/crates/steel-websockets/websockets.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-(#%require-dylib "libsteel_websockets"
-                 (only-in ws/message-ping?
-                          ws/message-pong?
-                          ws/message-text?
-                          ws/message-ping->pong
-                          ws/message->text-payload
-                          ws/connect))
-
-(provide ws/message-ping
-         ws/message-pong?
-         ws/message-text?
-         ws/message-ping->pong
-         ws/message->text-payload
-         ws/connect)
diff --git a/docs/.gitignore b/docs/.gitignore
deleted file mode 100644
index 7585238ef..000000000
--- a/docs/.gitignore
+++ /dev/null
@@ -1 +0,0 @@
-book
diff --git a/docs/book.toml b/docs/book.toml
deleted file mode 100644
index e75485aec..000000000
--- a/docs/book.toml
+++ /dev/null
@@ -1,6 +0,0 @@
-[book]
-authors = ["mattwparas"]
-language = "en"
-multilingual = false
-src = "src"
-title = "Steel"
diff --git a/docs/src/SUMMARY.md b/docs/src/SUMMARY.md
deleted file mode 100644
index 1b34fcd84..000000000
--- a/docs/src/SUMMARY.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# Summary
-
-1. [Steel](about/about.md)
-    1. [Features](about/features.md)
-    2. [Licensing](about/license.md)
-2. [Getting Started](start/start.md)
-    1. [Online Playground](start/playground.md)
-    2. [Using Steel on its own](start/standalone.md)
-    3. [Using Steel as an embedded scripting engine](start/embedded.md)
-3. [The Engine API](engine/engine.md)
-    1. [Registering functions](engine/register_function.md)
-    2. [Embedding values](engine/embedding_values.md)
-4. [Language Reference](reference/language.md)
-    1. [Keywords](reference/keywords.md)
-    2. [Syntax](reference/syntax.md)
-    3. [Macros](reference/macros.md)
-    4. [Contracts](reference/contracts.md)
-    5. [Transducers](reference/transducers.md)
-    6. [Modules](reference/modules.md)
-    7. [Functions](reference/functions.md)
-        1. [Logging](generated/logging.md)
-        2. [Built ins](reference/builtins.md)
-            1. [steel/base](builtins/steel_base.md)
-            2. [steel/lists](builtins/steel_lists.md)
-            3. [steel/random](builtins/steel_random.md)
-            4. [steel/time](builtins/steel_time.md)
-            5. [steel/hash](builtins/steel_hash.md)
-            6. [steel/ports](builtins/steel_ports.md)
-            7. [steel/strings](builtins/steel_strings.md) 
-6. [Bytecode](bytecode/bytecode.md)
-    1. [Optimizations](bytecode/optimizations.md)
-7. [Benchmarks](benchmarks/benchmarks.md)
-8. [Common Patterns](patterns/patterns.md)
-    1. [Interior Mutability](patterns/mutability.md)
-    2. [Async](patterns/async.md)
\ No newline at end of file
diff --git a/docs/src/about/about.md b/docs/src/about/about.md
deleted file mode 100644
index 01071d14e..000000000
--- a/docs/src/about/about.md
+++ /dev/null
@@ -1 +0,0 @@
-# Steel
diff --git a/docs/src/about/features.md b/docs/src/about/features.md
deleted file mode 100644
index ead022319..000000000
--- a/docs/src/about/features.md
+++ /dev/null
@@ -1 +0,0 @@
-# Features
diff --git a/docs/src/about/license.md b/docs/src/about/license.md
deleted file mode 100644
index a489b0ce7..000000000
--- a/docs/src/about/license.md
+++ /dev/null
@@ -1 +0,0 @@
-# Licensing
diff --git a/docs/src/benchmarks/benchmarks.md b/docs/src/benchmarks/benchmarks.md
deleted file mode 100644
index 680d5655b..000000000
--- a/docs/src/benchmarks/benchmarks.md
+++ /dev/null
@@ -1 +0,0 @@
-# Benchmarks
diff --git a/docs/src/builtins/steel_base.md b/docs/src/builtins/steel_base.md
deleted file mode 100644
index 49fc18b18..000000000
--- a/docs/src/builtins/steel_base.md
+++ /dev/null
@@ -1,460 +0,0 @@
-# steel/base
-### **pair?**
-Checks if the given value can be treated as a pair.
-Note - there are no improper lists in steel, so any list with at least one element
-is considered a pair.
-
-(pair? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (pair? '(10 20)) ;; => #true
-> (pair? '(10)) ;; => #true
-> (pair? '()) ;; => #false
-```
-### **string-append**
-Concatenates all of the given strings into one
-
-(string-append strs...) -> string?
-
-* strs ... : string?
-
-#### Examples
-```scheme
-> (string-append) ;; => ""
-> (string-append "foo" "bar") ;; => "foobar"
-### **starts-with?**
-Checks if the input string starts with a prefix
-
-(starts-with? input pattern) -> bool?
-
-input : string?
-pattern: string?
-
-#### Examples
-
-```scheme
-> (starts-with? "foobar" "foo") ;; => #true
-> (starts-with? "foobar" "bar") ;; => #false
-```
-### **trim-end**
-Returns a new string with the trailing whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "   foo"
-```
-### **open-output-file**
-Takes a filename `path` referring to a file to be created and returns an output port.
-
-(open-output-file string?) -> output-port?
-
-#### Examples
-```scheme
-> (open-output-file "foo-bar.txt") ;; => #<port>
-```
-### **read-port-to-string**
-Takes a port and reads the entire content into a string
-
-(read-port-to-string port) -> string?
-
-* port : input-port?
-### **hash-ref**
-Gets the `key` from the given `map`. Raises an error if the key does not exist. `hash-get` is an alias for this.
-
-(hash-ref map key) -> any/c
-
-* map : hash?
-* key : any/c
-
-#### Examples
-```scheme
-> (hash-get (hash 'a 10 'b 20) 'b) ;; => 20
-```
-### **hash-contains?**
-Checks whether the given map contains the given key. Key must be hashable.
-
-(hash-contains? map key) -> bool?
-
-* map : hash?
-* key : hashable?
-
-#### Example
-
-```scheme
-> (hash-contains? (hash 'a 10 'b 20) 'a) ;; => #true
-> (hash-contains? (hash 'a 10 'b 20) 'not-there) ;; => #false
-```
-### **list**
-Returns a newly allocated list containing the vs as its elements.
-
-(list v ...) -> list?
-
-* v : any/c
-
-#### Examples
-
-```scheme
-> (list 1 2 3 4 5) ;; => '(1 2 3 4 5)
-> (list (list 1 2) (list 3 4)) ;; => '((1 2) (3 4))
-```
-### **split-whitespace**
-Returns a list of strings from the original string split on the whitespace
-
-(split-whitespace string?) -> (listof string?)
-
-#### Examples
-
-```scheme
-(split-whitespace "apples bananas fruits veggies") ;; '("apples" "bananas" "fruits" "veggies")
-```
-### **int->string**
-Converts an integer into a string.
-
-(int->string int?) -> string?
-
-#### Examples
-
-```scheme
-> (int->string 10) ;; => "10"
-```
-### **hash-insert**
-Returns a new hashmap with the additional key value pair added. Performs a functional update,
-so the old hash map is still accessible.
-
-(hash-insert map key val) -> hash?
-
-* map : hash?
-* key : any/c
-* val : any/c
-
-#### Examples
-```scheme
-> (hash-insert (hash 'a 10 'b 20) 'c 30)
-
-=> #<hashmap {
-'a: 10,
-'b: 20,
-'c: 30
-}>
-```
-### **input-port?**
-Checks if a given value is an input port
-
-(input-port? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (input-port? (stdin)) ;; => #true
-> (input-port? "foo") ;; => #false
-```
-### **string->symbol**
-Converts a string into a symbol.
-
-(string->symbol string?) -> symbol?
-
-#### Examples
-
-```scheme
-> (string->symbol "FooBar") ;; => 'FooBar
-```
-### **second**
-Get the second element of the list. Raises an error if the list does not have an element in the second position.
-
-(second l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (second '(1 2 3)) ;; => 2
-> (second '())
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (second '())
-│  ^^^^^^ second: index out of bounds - list did not have an element in the second position: []
-### **string->list**
-Converts a string into a list of characters.
-
-(string->list string?) -> (listof char?)
-
-#### Examples
-
-```scheme
-> (string->list "hello") ;; => '(#\h #\e #\l #\l #\o)
-```
-### **stdin**
-Gets the port handle to stdin
-
-(stdin) -> input-port?
-
-#### Examples
-
-```scheme
-> (stdin) ;; => #<port>
-```
-### **first**
-Returns the first element of the list l.
-
-(first l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (first '(1 2)) ;; => 1
-> (first (cons 2 3)) ;; => 2
-```
-### **steel/lists**
-#### steel/lists
-
-Lists in Steel have an interface that matches those of classic schemes or lisps.
-At face value, they appear to be implemented as cons cells - however, under the hood
-they are actually implemented as unrolled linked lists.
-
-This means that for most practical purposes, interaction with lists is the same.
-That being said, there are no improper lists, meaning, pairs are actually just lists of two elements.
-
-Indexing into a list also takes O(n/64) - which means you'll get constant time indexing on small lists.
-
-```scheme
-(list 10 20 30 40) ;; => '(10 20 30 40)
-```
-### **trim-start**
-Returns a new string with the leading whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "foo     "
-```
-### **output-port?**
-Checks if a given value is an output port
-
-(output-port? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (define output (open-output-file "foo.txt"))
-> (output-port? output) ;; => #true
-```
-### **string->upper**
-Creates a new uppercased version of the input string
-
-(string->upper string?) -> string?
-
-#### Examples
-
-```scheme
-> (string->upper "lower") ;; => "LOWER"
-```
-### **hash-try-get**
-Gets the `key` from the given `map`. Returns #false if the key does not exist.
-
-(hash-try-get map key) -> (or any/c #false)
-
-* map : hash?
-* key : any/c
-
-#### Examples
-
-```scheme
-> (hash-try-get (hash 'a 10 'b 20) 'b) ;; => 20
-> (hash-try-get (hash 'a 10 'b 20) 'does-not-exist) ;; => #false
-```
-### **string->lower**
-Creates a new lowercased version of the input string
-
-(string->lower string?) -> string?
-
-#### Examples
-
-```scheme
-> (string->lower "sPonGeBoB tExT") ;; => "spongebob text"
-```
-### **trim**
-Returns a new string with the leading and trailing whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "foo"
-```
-### **to-string**
-Concatenatives all of the inputs to their string representation, separated by spaces.
-
-(to-string xs ...)
-
-* xs : any/c
-
-#### Examples
-```scheme
-> (to-string 10) ;; => "10"
-> (to-string "hello" "world") ;; => "hello world"
-```
-### **third**
-Get the third element of the list. Raises an error if the list does not have an element in the third position.
-
-(third l) -> any/c
-
-* l : list?
-
-#### Examples
-```scheme
-> (third '(1 2 3)) ;; => 3
-> (third '())
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (third '())
-│  ^^^^^^ third: index out of bounds - list did not have an element in the second position: []
-```
-### **empty?**
-Checks if the list is empty
-
-(empty? lst) -> bool?
-
-* lst: list?
-
-#### Examples
-
-```scheme
-> (empty? (list 1 2 3 4 5)) ;; => #false
-> (empty? '()) ;; => #true
-```
-### **string-length**
-Get the length of the given string
-
-(string-length string?) -> int?
-
-#### Examples
-
-```scheme
-> (string-length "apples") ;; => 6
-```
-### **steel/time**
-
-
-#### steel/time
-    
-Contains direct wrappers around the Rust `std::time::Instant` and `std::time::Duration` modules. 
-For example, to measure the time something takes:
-
-```scheme
-(define t (instant/now))
-(displayln "Hello world")
-(displayln (instant/elapsed t))
-```
-
-### **hash-length**
-Returns the number of key value pairs in the map
-
-(hash-length map) -> (and positive? int?)
-
-* map : hash?
-
-#### Examples
-
-```scheme
-> (hash-length (hash 'a 10 'b 20)) ;; => 2
-```
-### **range**
-Returns a newly allocated list of the elements in the range (n, m]
-
-(range n m) -> (listof int?)
-
-* n : int?
-* m : int?
-
-```scheme
-> (range 0 10) ;; => '(0 1 2 3 4 5 6 7 8 9)
-```
-### **ends-with?**
-Checks if the input string ends with a given suffix
-
-(ends-with? input pattern) -> bool?
-
-input : string?
-pattern: string?
-
-#### Examples
-
-```scheme
-> (ends-with? "foobar" "foo") ;; => #false
-> (ends-with? "foobar" "bar") ;; => #true
-```
-### **string->int**
-Converts a string into an int. Raises an error if the string cannot be converted to an integer.
-
-(string->int string?) -> int?
-
-#### Examples
-
-```scheme
-> (string->int "100") ;; => 10
-> (string->int "not-an-int") ;; error
-```
-### **car**
-Returns the first element of the list l.
-
-(car l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (car '(1 2)) ;; => 1
-> (car (cons 2 3)) ;; => 2
-```
-### **open-input-file**
-Takes a filename `path` referring to an existing file and returns an input port. Raises an error
-if the file does not exist
-
-(open-input-file string?) -> input-port?
-
-#### Examples
-```scheme
-> (open-input-file "foo-bar.txt") ;; => #<port>
-> (open-input-file "file-does-not-exist.txt")
-error[E08]: Io
-┌─ :1:2
-│
-1 │ (open-input-file "foo-bar.txt")
-│  ^^^^^^^^^^^^^^^ No such file or directory (os error 2)
-```
-### **list-ref**
-Returns the value located at the given index. Will raise an error if you try to index out of bounds.
-
-Note: Runs in time proportional to the length of the list, however lists in Steel are implemented in such a fashion that the
-time complexity is O(n/64). Meaning, for small lists this can be constant.
-
-(list-ref lst index) -> list?
-
-* lst : list?
-* index : (and/c int? positive?)
-
-#### Examples
-```scheme
-> (list-ref (list 1 2 3 4) 2) ;; => 3
-> (list-ref (range 0 100) 42) ;; => 42"
-> (list-ref (list 1 2 3 4) 10)
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (list-ref (list 1 2 3 4) 10)
-│  ^^^^^^^^ out of bounds index in list-ref - list length: 4, index: 10
-```
diff --git a/docs/src/builtins/steel_hash.md b/docs/src/builtins/steel_hash.md
deleted file mode 100644
index 5e78eb1f0..000000000
--- a/docs/src/builtins/steel_hash.md
+++ /dev/null
@@ -1,73 +0,0 @@
-# steel/hash
-### **hash-try-get**
-Gets the `key` from the given `map`. Returns #false if the key does not exist.
-
-(hash-try-get map key) -> (or any/c #false)
-
-* map : hash?
-* key : any/c
-
-#### Examples
-
-```scheme
-> (hash-try-get (hash 'a 10 'b 20) 'b) ;; => 20
-> (hash-try-get (hash 'a 10 'b 20) 'does-not-exist) ;; => #false
-```
-### **hash-ref**
-Gets the `key` from the given `map`. Raises an error if the key does not exist. `hash-get` is an alias for this.
-
-(hash-ref map key) -> any/c
-
-* map : hash?
-* key : any/c
-
-#### Examples
-```scheme
-> (hash-get (hash 'a 10 'b 20) 'b) ;; => 20
-```
-### **hash-length**
-Returns the number of key value pairs in the map
-
-(hash-length map) -> (and positive? int?)
-
-* map : hash?
-
-#### Examples
-
-```scheme
-> (hash-length (hash 'a 10 'b 20)) ;; => 2
-```
-### **hash-insert**
-Returns a new hashmap with the additional key value pair added. Performs a functional update,
-so the old hash map is still accessible.
-
-(hash-insert map key val) -> hash?
-
-* map : hash?
-* key : any/c
-* val : any/c
-
-#### Examples
-```scheme
-> (hash-insert (hash 'a 10 'b 20) 'c 30)
-
-=> #<hashmap {
-'a: 10,
-'b: 20,
-'c: 30
-}>
-```
-### **hash-contains?**
-Checks whether the given map contains the given key. Key must be hashable.
-
-(hash-contains? map key) -> bool?
-
-* map : hash?
-* key : hashable?
-
-#### Example
-
-```scheme
-> (hash-contains? (hash 'a 10 'b 20) 'a) ;; => #true
-> (hash-contains? (hash 'a 10 'b 20) 'not-there) ;; => #false
-```
diff --git a/docs/src/builtins/steel_lists.md b/docs/src/builtins/steel_lists.md
deleted file mode 100644
index 5462cce91..000000000
--- a/docs/src/builtins/steel_lists.md
+++ /dev/null
@@ -1,149 +0,0 @@
-# steel/lists
-### **empty?**
-Checks if the list is empty
-
-(empty? lst) -> bool?
-
-* lst: list?
-
-#### Examples
-
-```scheme
-> (empty? (list 1 2 3 4 5)) ;; => #false
-> (empty? '()) ;; => #true
-```
-### **range**
-Returns a newly allocated list of the elements in the range (n, m]
-
-(range n m) -> (listof int?)
-
-* n : int?
-* m : int?
-
-```scheme
-> (range 0 10) ;; => '(0 1 2 3 4 5 6 7 8 9)
-```
-### **steel/lists**
-#### steel/lists
-
-Lists in Steel have an interface that matches those of classic schemes or lisps.
-At face value, they appear to be implemented as cons cells - however, under the hood
-they are actually implemented as unrolled linked lists.
-
-This means that for most practical purposes, interaction with lists is the same.
-That being said, there are no improper lists, meaning, pairs are actually just lists of two elements.
-
-Indexing into a list also takes O(n/64) - which means you'll get constant time indexing on small lists.
-
-```scheme
-(list 10 20 30 40) ;; => '(10 20 30 40)
-```
-### **third**
-Get the third element of the list. Raises an error if the list does not have an element in the third position.
-
-(third l) -> any/c
-
-* l : list?
-
-#### Examples
-```scheme
-> (third '(1 2 3)) ;; => 3
-> (third '())
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (third '())
-│  ^^^^^^ third: index out of bounds - list did not have an element in the second position: []
-```
-### **list**
-Returns a newly allocated list containing the vs as its elements.
-
-(list v ...) -> list?
-
-* v : any/c
-
-#### Examples
-
-```scheme
-> (list 1 2 3 4 5) ;; => '(1 2 3 4 5)
-> (list (list 1 2) (list 3 4)) ;; => '((1 2) (3 4))
-```
-### **pair?**
-Checks if the given value can be treated as a pair.
-Note - there are no improper lists in steel, so any list with at least one element
-is considered a pair.
-
-(pair? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (pair? '(10 20)) ;; => #true
-> (pair? '(10)) ;; => #true
-> (pair? '()) ;; => #false
-```
-### **first**
-Returns the first element of the list l.
-
-(first l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (first '(1 2)) ;; => 1
-> (first (cons 2 3)) ;; => 2
-```
-### **second**
-Get the second element of the list. Raises an error if the list does not have an element in the second position.
-
-(second l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (second '(1 2 3)) ;; => 2
-> (second '())
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (second '())
-│  ^^^^^^ second: index out of bounds - list did not have an element in the second position: []
-### **list-ref**
-Returns the value located at the given index. Will raise an error if you try to index out of bounds.
-
-Note: Runs in time proportional to the length of the list, however lists in Steel are implemented in such a fashion that the
-time complexity is O(n/64). Meaning, for small lists this can be constant.
-
-(list-ref lst index) -> list?
-
-* lst : list?
-* index : (and/c int? positive?)
-
-#### Examples
-```scheme
-> (list-ref (list 1 2 3 4) 2) ;; => 3
-> (list-ref (range 0 100) 42) ;; => 42"
-> (list-ref (list 1 2 3 4) 10)
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (list-ref (list 1 2 3 4) 10)
-│  ^^^^^^^^ out of bounds index in list-ref - list length: 4, index: 10
-```
-### **car**
-Returns the first element of the list l.
-
-(car l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (car '(1 2)) ;; => 1
-> (car (cons 2 3)) ;; => 2
-```
diff --git a/docs/src/builtins/steel_ports.md b/docs/src/builtins/steel_ports.md
deleted file mode 100644
index 66eba8ec6..000000000
--- a/docs/src/builtins/steel_ports.md
+++ /dev/null
@@ -1,64 +0,0 @@
-# steel/ports
-### **input-port?**
-Checks if a given value is an input port
-
-(input-port? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (input-port? (stdin)) ;; => #true
-> (input-port? "foo") ;; => #false
-```
-### **read-port-to-string**
-Takes a port and reads the entire content into a string
-
-(read-port-to-string port) -> string?
-
-* port : input-port?
-### **stdin**
-Gets the port handle to stdin
-
-(stdin) -> input-port?
-
-#### Examples
-
-```scheme
-> (stdin) ;; => #<port>
-```
-### **open-output-file**
-Takes a filename `path` referring to a file to be created and returns an output port.
-
-(open-output-file string?) -> output-port?
-
-#### Examples
-```scheme
-> (open-output-file "foo-bar.txt") ;; => #<port>
-```
-### **open-input-file**
-Takes a filename `path` referring to an existing file and returns an input port. Raises an error
-if the file does not exist
-
-(open-input-file string?) -> input-port?
-
-#### Examples
-```scheme
-> (open-input-file "foo-bar.txt") ;; => #<port>
-> (open-input-file "file-does-not-exist.txt")
-error[E08]: Io
-┌─ :1:2
-│
-1 │ (open-input-file "foo-bar.txt")
-│  ^^^^^^^^^^^^^^^ No such file or directory (os error 2)
-```
-### **output-port?**
-Checks if a given value is an output port
-
-(output-port? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (define output (open-output-file "foo.txt"))
-> (output-port? output) ;; => #true
-```
diff --git a/docs/src/builtins/steel_random.md b/docs/src/builtins/steel_random.md
deleted file mode 100644
index 86e0f6394..000000000
--- a/docs/src/builtins/steel_random.md
+++ /dev/null
@@ -1 +0,0 @@
-# steel/random
diff --git a/docs/src/builtins/steel_strings.md b/docs/src/builtins/steel_strings.md
deleted file mode 100644
index 4e8c7e325..000000000
--- a/docs/src/builtins/steel_strings.md
+++ /dev/null
@@ -1,163 +0,0 @@
-# steel/strings
-### **trim-start**
-Returns a new string with the leading whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "foo     "
-```
-### **string-append**
-Concatenates all of the given strings into one
-
-(string-append strs...) -> string?
-
-* strs ... : string?
-
-#### Examples
-```scheme
-> (string-append) ;; => ""
-> (string-append "foo" "bar") ;; => "foobar"
-### **int->string**
-Converts an integer into a string.
-
-(int->string int?) -> string?
-
-#### Examples
-
-```scheme
-> (int->string 10) ;; => "10"
-```
-### **ends-with?**
-Checks if the input string ends with a given suffix
-
-(ends-with? input pattern) -> bool?
-
-input : string?
-pattern: string?
-
-#### Examples
-
-```scheme
-> (ends-with? "foobar" "foo") ;; => #false
-> (ends-with? "foobar" "bar") ;; => #true
-```
-### **split-whitespace**
-Returns a list of strings from the original string split on the whitespace
-
-(split-whitespace string?) -> (listof string?)
-
-#### Examples
-
-```scheme
-(split-whitespace "apples bananas fruits veggies") ;; '("apples" "bananas" "fruits" "veggies")
-```
-### **trim**
-Returns a new string with the leading and trailing whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "foo"
-```
-### **string->symbol**
-Converts a string into a symbol.
-
-(string->symbol string?) -> symbol?
-
-#### Examples
-
-```scheme
-> (string->symbol "FooBar") ;; => 'FooBar
-```
-### **string->list**
-Converts a string into a list of characters.
-
-(string->list string?) -> (listof char?)
-
-#### Examples
-
-```scheme
-> (string->list "hello") ;; => '(#\h #\e #\l #\l #\o)
-```
-### **string->upper**
-Creates a new uppercased version of the input string
-
-(string->upper string?) -> string?
-
-#### Examples
-
-```scheme
-> (string->upper "lower") ;; => "LOWER"
-```
-### **string->int**
-Converts a string into an int. Raises an error if the string cannot be converted to an integer.
-
-(string->int string?) -> int?
-
-#### Examples
-
-```scheme
-> (string->int "100") ;; => 10
-> (string->int "not-an-int") ;; error
-```
-### **string-length**
-Get the length of the given string
-
-(string-length string?) -> int?
-
-#### Examples
-
-```scheme
-> (string-length "apples") ;; => 6
-```
-### **to-string**
-Concatenatives all of the inputs to their string representation, separated by spaces.
-
-(to-string xs ...)
-
-* xs : any/c
-
-#### Examples
-```scheme
-> (to-string 10) ;; => "10"
-> (to-string "hello" "world") ;; => "hello world"
-```
-### **trim-end**
-Returns a new string with the trailing whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "   foo"
-```
-### **string->lower**
-Creates a new lowercased version of the input string
-
-(string->lower string?) -> string?
-
-#### Examples
-
-```scheme
-> (string->lower "sPonGeBoB tExT") ;; => "spongebob text"
-```
-### **starts-with?**
-Checks if the input string starts with a prefix
-
-(starts-with? input pattern) -> bool?
-
-input : string?
-pattern: string?
-
-#### Examples
-
-```scheme
-> (starts-with? "foobar" "foo") ;; => #true
-> (starts-with? "foobar" "bar") ;; => #false
-```
diff --git a/docs/src/builtins/steel_time.md b/docs/src/builtins/steel_time.md
deleted file mode 100644
index a76066ee3..000000000
--- a/docs/src/builtins/steel_time.md
+++ /dev/null
@@ -1,15 +0,0 @@
-# steel/time
-### **steel/time**
-
-
-#### steel/time
-    
-Contains direct wrappers around the Rust `std::time::Instant` and `std::time::Duration` modules. 
-For example, to measure the time something takes:
-
-```scheme
-(define t (instant/now))
-(displayln "Hello world")
-(displayln (instant/elapsed t))
-```
-
diff --git a/docs/src/bytecode/bytecode.md b/docs/src/bytecode/bytecode.md
deleted file mode 100644
index 1f13cf2a9..000000000
--- a/docs/src/bytecode/bytecode.md
+++ /dev/null
@@ -1,49 +0,0 @@
-# Bytecode
-
-<!-- These are the current bytecode opcodes:
-
-| Op Code | Description |
-| ------- | ----------- |
-| VOID | |
-| PUSH |
-| LOOKUP | 
-| IF |
-| JMP |
-| FUNC |
-| SCLOSURE |
-| ECLOSURE |
-| STRUCT |
-| POP | 
-| BIND |
-| SDEF |
-| EDEF |
-| PASS |
-| PUSHCONST |
-| NDEFS |
-| EVAL |
-| PANIC |
-| CLEAR |
-| TAILCALL
-| APPLY
-| SET
-| COLLECT
-| TRANSDUCE
-| READ
-| COLLECTTO
-| METALOOKUP
-| CALLCC
-| READLOCAL
-| SETLOCAL
-| READUPVALUE
-| SETUPVALUE
-| FILLUPVALUE
-| FILLLOCALUPVALUE
-| CLOSEUPVALUE | // Should be 1 for close, 0 for not
-| TCOJMP
-| CALLGLOBAL
-| CALLGLOBALTAIL
-| LOADINT0 | // Load const 0
-| LOADINT1
-| LOADINT2
-| CGLOCALCONST -->
-
diff --git a/docs/src/bytecode/optimizations.md b/docs/src/bytecode/optimizations.md
deleted file mode 100644
index b3d77f392..000000000
--- a/docs/src/bytecode/optimizations.md
+++ /dev/null
@@ -1 +0,0 @@
-# Optimizations
diff --git a/docs/src/engine/embedding_values.md b/docs/src/engine/embedding_values.md
deleted file mode 100644
index 4cc3d2086..000000000
--- a/docs/src/engine/embedding_values.md
+++ /dev/null
@@ -1,182 +0,0 @@
-# Embedding values
-
-Rust values, types, and functions are easily embedded into Steel. Using the `register_fn` call, you can embed functions easily:
-
-```rust,noplaypen
-use steel_vm::engine::Engine;
-use steel_vm::register_fn::RegisterFn;
-
-fn external_function(arg1: usize, arg2: usize) -> usize {
-    arg1 + arg2
-}
-
-fn option_function(arg1: Option<String>) -> Option<String> {
-    arg1
-}
-
-fn result_function(arg1: Option<String>) -> Result<String, String> {
-    if let Some(inner) = arg1 {
-        Ok(inner)
-    } else {
-        Err("Got a none".to_string())
-    }
-}
-
-pub fn main() {
-    let mut vm = Engine::new();
-
-    // Here we can register functions
-    // Any function can accept parameters that implement `FromSteelVal` and
-    // return values that implement `IntoSteelVal`
-    vm.register_fn("external-function", external_function);
-
-    // See the docs for more information about `FromSteelVal` and `IntoSteelVal`
-    // but we can see even functions that accept/return Option<T> or Result<T,E>
-    // can be registered
-    vm.register_fn("option-function", option_function);
-
-    // Result values will map directly to errors in the VM and bubble back up
-    vm.register_fn("result-function", result_function);
-
-    vm.run(
-        r#"
-        (define foo (external-function 10 25))
-        (define bar (option-function "applesauce"))
-        (define baz (result-function "bananas"))
-    "#,
-    )
-    .unwrap();
-
-    let foo = vm.extract::<usize>("foo").unwrap();
-    println!("foo: {}", foo);
-    assert_eq!(35, foo);
-
-    // Can also extract a value by specifying the type on the variable
-    let bar: String = vm.extract("bar").unwrap();
-    println!("bar: {}", bar);
-    assert_eq!("applesauce".to_string(), bar);
-
-    let baz: String = vm.extract("baz").unwrap();
-    println!("baz: {}", baz);
-    assert_eq!("bananas".to_string(), baz);
-}
-```
-
-We can also embed structs themselves:
-
-```rust,noplaypen
-use steel_vm::engine::Engine;
-use steel_vm::register_fn::RegisterFn;
-
-use steel_derive::Steel;
-
-// In order to register a type with Steel,
-// it must implement Clone, Debug, and Steel
-#[derive(Clone, Debug, Steel, PartialEq)]
-pub struct ExternalStruct {
-    foo: usize,
-    bar: String,
-    baz: f64,
-}
-
-impl ExternalStruct {
-    pub fn new(foo: usize, bar: String, baz: f64) -> Self {
-        ExternalStruct { foo, bar, baz }
-    }
-
-    // Embedding functions that take self must take by value
-    pub fn method_by_value(self) -> usize {
-        self.foo
-    }
-
-    // Setters should update the value and return a new instance (functional set)
-    pub fn set_foo(mut self, foo: usize) -> Self {
-        self.foo = foo;
-        self
-    }
-}
-
-pub fn main() {
-    let mut vm = Engine::new();
-
-    // Registering a type gives access to a predicate for the type
-    vm.register_type::<ExternalStruct>("ExternalStruct?");
-
-    // Structs in steel typically have a constructor that is the name of the struct
-    vm.register_fn("ExternalStruct", ExternalStruct::new);
-
-    // register_fn can be chained
-    vm.register_fn("method-by-value", ExternalStruct::method_by_value)
-        .register_fn("set-foo", ExternalStruct::set_foo);
-
-    let external_struct = ExternalStruct::new(1, "foo".to_string(), 12.4);
-
-    // Registering an external value is fallible if the conversion fails for some reason
-    // For instance, registering an Err(T) is fallible. However, most implementation outside of manual
-    // ones should not fail
-    vm.register_external_value("external-struct", external_struct)
-        .unwrap();
-
-    let output = vm
-        .run(
-            r#"
-            (define new-external-struct (set-foo external-struct 100))
-            (define get-output (method-by-value external-struct))
-            (define second-new-external-struct (ExternalStruct 50 "bananas" 72.6))
-            "last-result"
-        "#,
-        )
-        .unwrap();
-
-    let new_external_struct = vm.extract::<ExternalStruct>("new-external-struct").unwrap();
-    println!("new_external_struct: {:?}", new_external_struct);
-    assert_eq!(
-        ExternalStruct::new(100, "foo".to_string(), 12.4),
-        new_external_struct
-    );
-
-    // Can also extract a value by specifying the type on the variable
-    let get_output: usize = vm.extract("get-output").unwrap();
-    println!("get_output: {}", get_output);
-    assert_eq!(1, get_output);
-
-    let second_new_external_struct: ExternalStruct =
-        vm.extract("second-new-external-struct").unwrap();
-    println!(
-        "second_new_external_struct: {:?}",
-        second_new_external_struct
-    );
-    assert_eq!(
-        ExternalStruct::new(50, "bananas".to_string(), 72.6),
-        second_new_external_struct
-    );
-
-    // We also get the output of the VM as the value of every expression run
-    // we can inspect the results just by printing like so
-    println!("{:?}", output);
-}
-```
-
-## IntoSteelVal and FromSteelVal
-
-Types that implement `IntoSteelVal` and `FromSteelVal` and be returned and passed into rust functions, respectively. Take the following for example:
-
-```rust
-
-fn foo(value: isize) -> String {
-    ...
-}
-    
-```
-
-This means that steel values will attempt to be coerced to the type in the function signature, and the value that this function returns will then attempt to be coerced into a that Steel understands.
-
-There are some special case conversions that happen specifically:
-
-### `IntoSteelVal`
-
-* Vec<T> -> Steel list
-* HashMap<K, V> -> Steel hashmap
-* HashSet<T> -> Steel hashset
-* Result<T, E> -> if `Ok(T)` then T else `(error E)`
-* Option<T> -> if `Some(T)` then T else `#false`
diff --git a/docs/src/engine/engine.md b/docs/src/engine/engine.md
deleted file mode 100644
index 8c5e435be..000000000
--- a/docs/src/engine/engine.md
+++ /dev/null
@@ -1 +0,0 @@
-# The Engine API
diff --git a/docs/src/engine/register_function.md b/docs/src/engine/register_function.md
deleted file mode 100644
index a2918e5b4..000000000
--- a/docs/src/engine/register_function.md
+++ /dev/null
@@ -1 +0,0 @@
-# Registering functions
diff --git a/docs/src/generated/logging.md b/docs/src/generated/logging.md
deleted file mode 100644
index 9e144c363..000000000
--- a/docs/src/generated/logging.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# cogs/logging/log.scm
-### **log!**
-```scheme
-(log! level arg-list)
-```
-Log directly on the specified level the with arguments, as a list
-### **log/info!**
-```scheme
-(log/info! . args)
-```
-Log the arguments using the *info* target, i.e. log on INFO
-### **log/warn!**
-```scheme
-(log/warn! . args)
-```
-Log the arguments using the *warn* target, i.e. log on WARN
-### **log/debug!**
-```scheme
-(log/debug! . args)
-```
-Log the arguments using the *debug* target, i.e. log on DEBUG
-### **log/error!**
-```scheme
-(log/error! . args)
-```
-Log the arguments using the *error* target, i.e. log on ERROR
-### **log/trace!**
-```scheme
-(log/trace! . args)
-```
-Log the arguments using the *trace* target, i.e. log on TRACE
diff --git a/docs/src/highlight.js b/docs/src/highlight.js
deleted file mode 100644
index 34d4b9c86..000000000
--- a/docs/src/highlight.js
+++ /dev/null
@@ -1,627 +0,0 @@
-/*!
-  Highlight.js v11.0.0-beta0 (git: 6e182e0f30)
-  (c) 2006-2021 Ivan Sagalaev and other contributors
-  License: BSD-3-Clause
- */
-var hljs = function () {
-  "use strict"; var e = { exports: {} }; function t(e) {
-    return e instanceof Map ? e.clear = e.delete = e.set = () => {
-      throw Error("map is read-only")
-    } : e instanceof Set && (e.add = e.clear = e.delete = () => {
-      throw Error("set is read-only")
-    }), Object.freeze(e), Object.getOwnPropertyNames(e).forEach((n => {
-      var i = e[n]
-      ; "object" != typeof i || Object.isFrozen(i) || t(i)
-    })), e
-  }
-  e.exports = t, e.exports.default = t; var n = e.exports; class i {
-    constructor(e) {
-      void 0 === e.data && (e.data = {}), this.data = e.data, this.isMatchIgnored = !1
-    }
-    ignoreMatch() { this.isMatchIgnored = !0 }
-  } function r(e) {
-    return e.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;")
-  } function s(e, ...t) {
-    const n = Object.create(null); for (const t in e) n[t] = e[t]
-      ; return t.forEach((e => { for (const t in e) n[t] = e[t] })), n
-  } const a = e => !!e.kind
-    ; class o {
-      constructor(e, t) {
-        this.buffer = "", this.classPrefix = t.classPrefix, e.walk(this)
-      } addText(e) {
-        this.buffer += r(e)
-      } openNode(e) {
-        if (!a(e)) return; let t = e.kind
-          ; t = e.sublanguage ? "language-" + t : ((e, { prefix: t }) => {
-            if (e.includes(".")) {
-              const n = e.split(".")
-                ; return [`${t}${n.shift()}`, ...n.map(((e, t) => `${e}${"_".repeat(t + 1)}`))].join(" ")
-            } return `${t}${e}`
-          })(t, { prefix: this.classPrefix }), this.span(t)
-      } closeNode(e) {
-        a(e) && (this.buffer += "</span>")
-      } value() { return this.buffer } span(e) {
-        this.buffer += `<span class="${e}">`
-      }
-  } class l {
-    constructor() {
-      this.rootNode = {
-        children: []
-      }, this.stack = [this.rootNode]
-    } get top() {
-      return this.stack[this.stack.length - 1]
-    } get root() { return this.rootNode } add(e) {
-      this.top.children.push(e)
-    } openNode(e) {
-      const t = { kind: e, children: [] }
-      ; this.add(t), this.stack.push(t)
-    } closeNode() {
-      if (this.stack.length > 1) return this.stack.pop()
-    } closeAllNodes() {
-      for (; this.closeNode(););
-    } toJSON() { return JSON.stringify(this.rootNode, null, 4) }
-    walk(e) { return this.constructor._walk(e, this.rootNode) } static _walk(e, t) {
-      return "string" == typeof t ? e.addText(t) : t.children && (e.openNode(t),
-        t.children.forEach((t => this._walk(e, t))), e.closeNode(t)), e
-    } static _collapse(e) {
-      "string" != typeof e && e.children && (e.children.every((e => "string" == typeof e)) ? e.children = [e.children.join("")] : e.children.forEach((e => {
-        l._collapse(e)
-      })))
-    }
-  } class c extends l {
-    constructor(e) { super(), this.options = e }
-    addKeyword(e, t) { "" !== e && (this.openNode(t), this.addText(e), this.closeNode()) }
-    addText(e) { "" !== e && this.add(e) } addSublanguage(e, t) {
-      const n = e.root
-      ; n.kind = t, n.sublanguage = !0, this.add(n)
-    } toHTML() {
-      return new o(this, this.options).value()
-    } finalize() { return !0 }
-  } function g(e) {
-    return e ? "string" == typeof e ? e : e.source : null
-  } function d(e) { return u("(?=", e, ")") }
-  function u(...e) { return e.map((e => g(e))).join("") } function h(...e) {
-    return "(" + ((e => {
-      const t = e[e.length - 1]
-      ; return "object" == typeof t && t.constructor === Object ? (e.splice(e.length - 1, 1), t) : {}
-    })(e).capture ? "" : "?:") + e.map((e => g(e))).join("|") + ")"
-  } function p(e) {
-    return RegExp(e.toString() + "|").exec("").length - 1
-  }
-  const f = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./
-    ; function b(e, { joinWith: t }) {
-      let n = 0; return e.map((e => {
-        n += 1; const t = n
-          ; let i = g(e), r = ""; for (; i.length > 0;) {
-            const e = f.exec(i); if (!e) { r += i; break }
-            r += i.substring(0, e.index),
-              i = i.substring(e.index + e[0].length), "\\" === e[0][0] && e[1] ? r += "\\" + (Number(e[1]) + t) : (r += e[0],
-                "(" === e[0] && n++)
-          } return r
-      })).map((e => `(${e})`)).join(t)
-    }
-  const m = "[a-zA-Z]\\w*", E = "[a-zA-Z_]\\w*", y = "\\b\\d+(\\.\\d+)?", _ = "(-?)(\\b0[xX][a-fA-F0-9]+|(\\b\\d+(\\.\\d*)?|\\.\\d+)([eE][-+]?\\d+)?)", x = "\\b(0b[01]+)", w = {
-    begin: "\\\\[\\s\\S]", relevance: 0
-  }, v = {
-    scope: "string", begin: "'", end: "'",
-    illegal: "\\n", contains: [w]
-  }, N = {
-    scope: "string", begin: '"', end: '"', illegal: "\\n",
-    contains: [w]
-  }, O = (e, t, n = {}) => {
-    const i = s({
-      scope: "comment", begin: e, end: t,
-      contains: []
-    }, n); i.contains.push({
-      scope: "doctag",
-      begin: "[ ]*(?=(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):)",
-      end: /(TODO|FIXME|NOTE|BUG|OPTIMIZE|HACK|XXX):/, excludeBegin: !0, relevance: 0
-    })
-      ; const r = h("I", "a", "is", "so", "us", "to", "at", "if", "in", "it", "on", /[A-Za-z]+['](d|ve|re|ll|t|s|n)/, /[A-Za-z]+[-][a-z]+/, /[A-Za-z][a-z]{2,}/)
-      ; return i.contains.push({ begin: u(/[ ]+/, "(", r, /[.]?[:]?([.][ ]|[ ])/, "){3}") }), i
-  }, k = O("//", "$"), R = O("/\\*", "\\*/"), S = O("#", "$"); var M = Object.freeze({
-    __proto__: null, MATCH_NOTHING_RE: /\b\B/, IDENT_RE: m, UNDERSCORE_IDENT_RE: E,
-    NUMBER_RE: y, C_NUMBER_RE: _, BINARY_NUMBER_RE: x,
-    RE_STARTERS_RE: "!|!=|!==|%|%=|&|&&|&=|\\*|\\*=|\\+|\\+=|,|-|-=|/=|/|:|;|<<|<<=|<=|<|===|==|=|>>>=|>>=|>=|>>>|>>|>|\\?|\\[|\\{|\\(|\\^|\\^=|\\||\\|=|\\|\\||~",
-    SHEBANG: (e = {}) => {
-      const t = /^#![ ]*\//
-      ; return e.binary && (e.begin = u(t, /.*\b/, e.binary, /\b.*/)), s({
-        scope: "meta", begin: t,
-        end: /$/, relevance: 0, "on:begin": (e, t) => { 0 !== e.index && t.ignoreMatch() }
-      }, e)
-    },
-    BACKSLASH_ESCAPE: w, APOS_STRING_MODE: v, QUOTE_STRING_MODE: N, PHRASAL_WORDS_MODE: {
-      begin: /\b(a|an|the|are|I'm|isn't|don't|doesn't|won't|but|just|should|pretty|simply|enough|gonna|going|wtf|so|such|will|you|your|they|like|more)\b/
-    }, COMMENT: O, C_LINE_COMMENT_MODE: k, C_BLOCK_COMMENT_MODE: R, HASH_COMMENT_MODE: S,
-    NUMBER_MODE: { scope: "number", begin: y, relevance: 0 }, C_NUMBER_MODE: {
-      scope: "number",
-      begin: _, relevance: 0
-    }, BINARY_NUMBER_MODE: { scope: "number", begin: x, relevance: 0 },
-    REGEXP_MODE: {
-      begin: /(?=\/[^/\n]*\/)/, contains: [{
-        scope: "regexp", begin: /\//,
-        end: /\/[gimuy]*/, illegal: /\n/, contains: [w, {
-          begin: /\[/, end: /\]/, relevance: 0,
-          contains: [w]
-        }]
-      }]
-    }, TITLE_MODE: { scope: "title", begin: m, relevance: 0 },
-    UNDERSCORE_TITLE_MODE: { scope: "title", begin: E, relevance: 0 }, METHOD_GUARD: {
-      begin: "\\.\\s*[a-zA-Z_]\\w*", relevance: 0
-    }, END_SAME_AS_BEGIN: e => Object.assign(e, {
-      "on:begin": (e, t) => { t.data._beginMatch = e[1] }, "on:end": (e, t) => {
-        t.data._beginMatch !== e[1] && t.ignoreMatch()
-      }
-    })
-  }); function I(e, t) {
-    "." === e.input[e.index - 1] && t.ignoreMatch()
-  } function A(e, t) {
-    void 0 !== e.className && (e.scope = e.className, delete e.className)
-  } function j(e, t) {
-    t && e.beginKeywords && (e.begin = "\\b(" + e.beginKeywords.split(" ").join("|") + ")(?!\\.)(?=\\b|\\s)",
-      e.__beforeBegin = I, e.keywords = e.keywords || e.beginKeywords, delete e.beginKeywords,
-      void 0 === e.relevance && (e.relevance = 0))
-  } function T(e, t) {
-    Array.isArray(e.illegal) && (e.illegal = h(...e.illegal))
-  } function D(e, t) {
-    if (e.match) {
-      if (e.begin || e.end) throw Error("begin & end are not supported with match")
-        ; e.begin = e.match, delete e.match
-    }
-  } function B(e, t) {
-    void 0 === e.relevance && (e.relevance = 1)
-  } const C = (e, t) => {
-    if (!e.beforeMatch) return
-      ; if (e.starts) throw Error("beforeMatch cannot be used with starts")
-        ; const n = Object.assign({}, e); Object.keys(e).forEach((t => {
-          delete e[t]
-        })), e.keywords = n.keywords, e.begin = u(n.beforeMatch, d(n.begin)), e.starts = {
-          relevance: 0, contains: [Object.assign(n, { endsParent: !0 })]
-        }, e.relevance = 0, delete n.beforeMatch
-  }, L = ["of", "and", "for", "in", "not", "or", "if", "then", "parent", "list", "value"]
-    ; function P(e, t, n = "keyword") {
-      const i = Object.create(null)
-      ; return "string" == typeof e ? r(n, e.split(" ")) : Array.isArray(e) ? r(n, e) : Object.keys(e).forEach((n => {
-        Object.assign(i, P(e[n], t, n))
-      })), i; function r(e, n) {
-        t && (n = n.map((e => e.toLowerCase()))), n.forEach((t => {
-          const n = t.split("|")
-          ; i[n[0]] = [e, z(n[0], n[1])]
-        }))
-      }
-    } function z(e, t) {
-      return t ? Number(t) : (e => L.includes(e.toLowerCase()))(e) ? 0 : 1
-    } const U = {}, $ = e => {
-      console.error(e)
-    }, H = (e, ...t) => { console.log("WARN: " + e, ...t) }, q = (e, t) => {
-      U[`${e}/${t}`] || (console.log(`Deprecated as of ${e}. ${t}`), U[`${e}/${t}`] = !0)
-    }, K = Error(); function W(e, t, { key: n }) {
-      let i = 0; const r = e[n], s = {}, a = {}
-        ; for (let e = 1; e <= t.length; e++)a[e + i] = r[e], s[e + i] = !0, i += p(t[e - 1])
-          ; e[n] = a, e[n]._emit = s, e[n]._multi = !0
-    } function F(e) {
-      (e => {
-        e.scope && "object" == typeof e.scope && null !== e.scope && (e.beginScope = e.scope,
-          delete e.scope)
-      })(e), "string" == typeof e.beginScope && (e.beginScope = {
-        _wrap: e.beginScope
-      }), "string" == typeof e.endScope && (e.endScope = {
-        _wrap: e.endScope
-      }), (e => {
-        if (Array.isArray(e.begin)) {
-          if (e.skip || e.excludeBegin || e.returnBegin) throw $("skip, excludeBegin, returnBegin not compatible with beginScope: {}"),
-            K
-            ; if ("object" != typeof e.beginScope || null === e.beginScope) throw $("beginScope must be object"),
-              K; W(e, e.begin, { key: "beginScope" }), e.begin = b(e.begin, { joinWith: "" })
-        }
-      })(e), (e => {
-        if (Array.isArray(e.end)) {
-          if (e.skip || e.excludeEnd || e.returnEnd) throw $("skip, excludeEnd, returnEnd not compatible with endScope: {}"),
-            K
-            ; if ("object" != typeof e.endScope || null === e.endScope) throw $("endScope must be object"),
-              K; W(e, e.end, { key: "endScope" }), e.end = b(e.end, { joinWith: "" })
-        }
-      })(e)
-    } function G(e) {
-      function t(t, n) { return RegExp(g(t), "m" + (e.case_insensitive ? "i" : "") + (n ? "g" : "")) }
-      class n {
-        constructor() {
-          this.matchIndexes = {}, this.regexes = [], this.matchAt = 1, this.position = 0
-        }
-        addRule(e, t) {
-          t.position = this.position++, this.matchIndexes[this.matchAt] = t, this.regexes.push([t, e]),
-            this.matchAt += p(e) + 1
-        } compile() {
-          0 === this.regexes.length && (this.exec = () => null)
-          ; const e = this.regexes.map((e => e[1])); this.matcherRe = t(b(e, {
-            joinWith: "|"
-          }), !0), this.lastIndex = 0
-        } exec(e) {
-          this.matcherRe.lastIndex = this.lastIndex
-          ; const t = this.matcherRe.exec(e); if (!t) return null
-            ; const n = t.findIndex(((e, t) => t > 0 && void 0 !== e)), i = this.matchIndexes[n]
-            ; return t.splice(0, n), Object.assign(t, i)
-        }
-      } class i {
-        constructor() {
-          this.rules = [], this.multiRegexes = [],
-            this.count = 0, this.lastIndex = 0, this.regexIndex = 0
-        } getMatcher(e) {
-          if (this.multiRegexes[e]) return this.multiRegexes[e]; const t = new n
-            ; return this.rules.slice(e).forEach((([e, n]) => t.addRule(e, n))),
-              t.compile(), this.multiRegexes[e] = t, t
-        } resumingScanAtSamePosition() {
-          return 0 !== this.regexIndex
-        } considerAll() { this.regexIndex = 0 } addRule(e, t) {
-          this.rules.push([e, t]), "begin" === t.type && this.count++
-        } exec(e) {
-          const t = this.getMatcher(this.regexIndex); t.lastIndex = this.lastIndex
-            ; let n = t.exec(e)
-            ; if (this.resumingScanAtSamePosition()) if (n && n.index === this.lastIndex); else {
-              const t = this.getMatcher(0); t.lastIndex = this.lastIndex + 1, n = t.exec(e)
-            }
-          return n && (this.regexIndex += n.position + 1,
-            this.regexIndex === this.count && this.considerAll()), n
-        }
-      }
-      if (e.compilerExtensions || (e.compilerExtensions = []),
-        e.contains && e.contains.includes("self")) throw Error("ERR: contains `self` is not supported at the top-level of a language.  See documentation.")
-        ; return e.classNameAliases = s(e.classNameAliases || {}), function n(r, a) {
-          const o = r
-          ; if (r.isCompiled) return o
-            ;[A, D, F, C].forEach((e => e(r, a))), e.compilerExtensions.forEach((e => e(r, a))),
-              r.__beforeBegin = null, [j, T, B].forEach((e => e(r, a))), r.isCompiled = !0; let l = null
-            ; return "object" == typeof r.keywords && r.keywords.$pattern && (r.keywords = Object.assign({}, r.keywords),
-              l = r.keywords.$pattern,
-              delete r.keywords.$pattern), l = l || /\w+/, r.keywords && (r.keywords = P(r.keywords, e.case_insensitive)),
-              o.keywordPatternRe = t(l, !0),
-              a && (r.begin || (r.begin = /\B|\b/), o.beginRe = t(r.begin), r.end || r.endsWithParent || (r.end = /\B|\b/),
-                r.end && (o.endRe = t(r.end)),
-                o.terminatorEnd = g(r.end) || "", r.endsWithParent && a.terminatorEnd && (o.terminatorEnd += (r.end ? "|" : "") + a.terminatorEnd)),
-              r.illegal && (o.illegalRe = t(r.illegal)),
-              r.contains || (r.contains = []), r.contains = [].concat(...r.contains.map((e => (e => (e.variants && !e.cachedVariants && (e.cachedVariants = e.variants.map((t => s(e, {
-                variants: null
-              }, t)))), e.cachedVariants ? e.cachedVariants : X(e) ? s(e, {
-                starts: e.starts ? s(e.starts) : null
-              }) : Object.isFrozen(e) ? s(e) : e))("self" === e ? r : e)))), r.contains.forEach((e => {
-                n(e, o)
-              })), r.starts && n(r.starts, a), o.matcher = (e => {
-                const t = new i
-                ; return e.contains.forEach((e => t.addRule(e.begin, {
-                  rule: e, type: "begin"
-                }))), e.terminatorEnd && t.addRule(e.terminatorEnd, {
-                  type: "end"
-                }), e.illegal && t.addRule(e.illegal, { type: "illegal" }), t
-              })(o), o
-        }(e)
-    } function X(e) {
-      return !!e && (e.endsWithParent || X(e.starts))
-    } const Z = r, V = s, Q = Symbol("nomatch")
-    ; var J = (e => {
-      const t = Object.create(null), r = Object.create(null), s = []; let a = !0
-        ; const o = "Could not find the language '{}', did you forget to load/include a language module?", l = {
-          disableAutodetect: !0, name: "Plain text", contains: []
-        }; let g = {
-          ignoreUnescapedHTML: !1, noHighlightRe: /^(no-?highlight)$/i,
-          languageDetectRe: /\blang(?:uage)?-([\w-]+)\b/i, classPrefix: "hljs-",
-          cssSelector: "pre code", languages: null, __emitter: c
-        }; function d(e) {
-          return g.noHighlightRe.test(e)
-        } function u(e, t, n, i) {
-          let r = "", s = ""
-          ; "object" == typeof t ? (r = e,
-            n = t.ignoreIllegals, s = t.language, i = void 0) : (q("10.7.0", "highlight(lang, code, ...args) has been deprecated."),
-              q("10.7.0", "Please use highlight(code, options) instead.\nhttps://github.com/highlightjs/highlight.js/issues/2277"),
-              s = e, r = t), void 0 === n && (n = !0); const a = { code: r, language: s }; x("before:highlight", a)
-            ; const o = a.result ? a.result : h(a.language, a.code, n, i)
-            ; return o.code = a.code, x("after:highlight", o), o
-        } function h(e, n, r, s) {
-          const l = Object.create(null); function c() {
-            if (!O.keywords) return void R.addText(S)
-              ; let e = 0; O.keywordPatternRe.lastIndex = 0; let t = O.keywordPatternRe.exec(S), n = ""
-              ; for (; t;) {
-                n += S.substring(e, t.index)
-                ; const r = w.case_insensitive ? t[0].toLowerCase() : t[0], s = (i = r, O.keywords[i]); if (s) {
-                  const [e, i] = s
-                    ; if (R.addText(n), n = "", l[r] = (l[r] || 0) + 1, l[r] <= 7 && (M += i), e.startsWith("_")) n += t[0]; else {
-                      const n = w.classNameAliases[e] || e; R.addKeyword(t[0], n)
-                    }
-                } else n += t[0]
-                  ; e = O.keywordPatternRe.lastIndex, t = O.keywordPatternRe.exec(S)
-              } var i
-              ; n += S.substr(e), R.addText(n)
-          } function d() {
-            null != O.subLanguage ? (() => {
-              if ("" === S) return; let e = null; if ("string" == typeof O.subLanguage) {
-                if (!t[O.subLanguage]) return void R.addText(S)
-                  ; e = h(O.subLanguage, S, !0, k[O.subLanguage]), k[O.subLanguage] = e._top
-              } else e = p(S, O.subLanguage.length ? O.subLanguage : null)
-                ; O.relevance > 0 && (M += e.relevance), R.addSublanguage(e._emitter, e.language)
-            })() : c(), S = ""
-          } function u(e, t) {
-            let n = 1; for (; void 0 !== t[n];) {
-              if (!e._emit[n]) {
-                n++
-                ; continue
-              } const i = w.classNameAliases[e[n]] || e[n], r = t[n]
-                ; i ? R.addKeyword(r, i) : (S = r, c(), S = ""), n++
-            }
-          } function f(e, t) {
-            return e.scope && "string" == typeof e.scope && R.openNode(w.classNameAliases[e.scope] || e.scope),
-              e.beginScope && (e.beginScope._wrap ? (R.addKeyword(S, w.classNameAliases[e.beginScope._wrap] || e.beginScope._wrap),
-                S = "") : e.beginScope._multi && (u(e.beginScope, t), S = "")), O = Object.create(e, {
-                  parent: {
-                    value: O
-                  }
-                }), O
-          } function b(e, t, n) {
-            let r = ((e, t) => {
-              const n = e && e.exec(t)
-              ; return n && 0 === n.index
-            })(e.endRe, n); if (r) {
-              if (e["on:end"]) {
-                const n = new i(e)
-                ; e["on:end"](t, n), n.isMatchIgnored && (r = !1)
-              } if (r) {
-                for (; e.endsParent && e.parent;)e = e.parent; return e
-              }
-            }
-            if (e.endsWithParent) return b(e.parent, t, n)
-          } function m(e) {
-            return 0 === O.matcher.regexIndex ? (S += e[0], 1) : (j = !0, 0)
-          } function y(e) {
-            const t = e[0], i = n.substr(e.index), r = b(O, e, i); if (!r) return Q; const s = O
-              ; O.endScope && O.endScope._wrap ? (d(),
-                R.addKeyword(t, O.endScope._wrap)) : O.endScope && O.endScope._multi ? (d(),
-                  u(O.endScope, e)) : s.skip ? S += t : (s.returnEnd || s.excludeEnd || (S += t),
-                    d(), s.excludeEnd && (S = t)); do {
-                      O.scope && !O.isMultiClass && R.closeNode(), O.skip || O.subLanguage || (M += O.relevance),
-                        O = O.parent
-                    } while (O !== r.parent)
-              ; return r.starts && f(r.starts, e), s.returnEnd ? 0 : t.length
-          } let _ = {}; function x(t, s) {
-            const o = s && s[0]; if (S += t, null == o) return d(), 0
-              ; if ("begin" === _.type && "end" === s.type && _.index === s.index && "" === o) {
-                if (S += n.slice(s.index, s.index + 1), !a) {
-                  const t = Error(`0 width match regex (${e})`)
-                  ; throw t.languageName = e, t.badRule = _.rule, t
-                } return 1
-              }
-            if (_ = s, "begin" === s.type) return (e => {
-              const t = e[0], n = e.rule, r = new i(n), s = [n.__beforeBegin, n["on:begin"]]
-                ; for (const n of s) if (n && (n(e, r), r.isMatchIgnored)) return m(t)
-                  ; return n.skip ? S += t : (n.excludeBegin && (S += t),
-                    d(), n.returnBegin || n.excludeBegin || (S = t)), f(n, e), n.returnBegin ? 0 : t.length
-            })(s)
-              ; if ("illegal" === s.type && !r) {
-                const e = Error('Illegal lexeme "' + o + '" for mode "' + (O.scope || "<unnamed>") + '"')
-                  ; throw e.mode = O, e
-              } if ("end" === s.type) { const e = y(s); if (e !== Q) return e }
-            if ("illegal" === s.type && "" === o) return 1
-              ; if (A > 1e5 && A > 3 * s.index) throw Error("potential infinite loop, way more iterations than matches")
-                ; return S += o, o.length
-          } const w = E(e)
-            ; if (!w) throw $(o.replace("{}", e)), Error('Unknown language: "' + e + '"')
-              ; const v = G(w); let N = "", O = s || v; const k = {}, R = new g.__emitter(g); (() => {
-                const e = []
-                ; for (let t = O; t !== w; t = t.parent)t.scope && e.unshift(t.scope)
-                  ; e.forEach((e => R.openNode(e)))
-              })(); let S = "", M = 0, I = 0, A = 0, j = !1; try {
-                for (O.matcher.considerAll(); ;) {
-                  A++, j ? j = !1 : O.matcher.considerAll(), O.matcher.lastIndex = I
-                    ; const e = O.matcher.exec(n); if (!e) break; const t = x(n.substring(I, e.index), e)
-                    ; I = e.index + t
-                } return x(n.substr(I)), R.closeAllNodes(), R.finalize(), N = R.toHTML(), {
-                  language: e, value: N, relevance: M, illegal: !1, _emitter: R, _top: O
-                }
-              } catch (t) {
-                if (t.message && t.message.includes("Illegal")) return {
-                  language: e, value: Z(n),
-                  illegal: !0, relevance: 0, _illegalBy: {
-                    message: t.message, index: I,
-                    context: n.slice(I - 100, I + 100), mode: t.mode, resultSoFar: N
-                  }, _emitter: R
-                }; if (a) return {
-                  language: e, value: Z(n), illegal: !1, relevance: 0, errorRaised: t, _emitter: R, _top: O
-                }
-                  ; throw t
-              }
-        } function p(e, n) {
-          n = n || g.languages || Object.keys(t); const i = (e => {
-            const t = { value: Z(e), illegal: !1, relevance: 0, _top: l, _emitter: new g.__emitter(g) }
-              ; return t._emitter.addText(e), t
-          })(e), r = n.filter(E).filter(_).map((t => h(t, e, !1)))
-            ; r.unshift(i); const s = r.sort(((e, t) => {
-              if (e.relevance !== t.relevance) return t.relevance - e.relevance
-                ; if (e.language && t.language) {
-                  if (E(e.language).supersetOf === t.language) return 1
-                    ; if (E(t.language).supersetOf === e.language) return -1
-                } return 0
-            })), [a, o] = s, c = a
-            ; return c.secondBest = o, c
-        } function f(e) {
-          let t = null; const n = (e => {
-            let t = e.className + " "; t += e.parentNode ? e.parentNode.className : ""
-              ; const n = g.languageDetectRe.exec(t); if (n) {
-                const t = E(n[1])
-                ; return t || (H(o.replace("{}", n[1])),
-                  H("Falling back to no-highlight mode for this block.", e)), t ? n[1] : "no-highlight"
-              }
-            return t.split(/\s+/).find((e => d(e) || E(e)))
-          })(e); if (d(n)) return
-            ; x("before:highlightElement", {
-              el: e, language: n
-            }), !g.ignoreUnescapedHTML && e.children.length > 0 && (console.warn("One of your code blocks includes unescaped HTML. This is a potentially serious security risk."),
-              console.warn("https://github.com/highlightjs/highlight.js/issues/2886"),
-              console.warn(e)), t = e; const i = t.textContent, s = n ? u(i, {
-                language: n, ignoreIllegals: !0
-              }) : p(i); x("after:highlightElement", {
-                el: e, result: s, text: i
-              }), e.innerHTML = s.value, ((e, t, n) => {
-                const i = t && r[t] || n
-                ; e.classList.add("hljs"), e.classList.add("language-" + i)
-              })(e, n, s.language), e.result = {
-                language: s.language, re: s.relevance,
-                relevance: s.relevance
-              }, s.secondBest && (e.secondBest = {
-                language: s.secondBest.language, relevance: s.secondBest.relevance
-              })
-        } let b = !1
-        ; function m() {
-          "loading" !== document.readyState ? document.querySelectorAll(g.cssSelector).forEach(f) : b = !0
-        } function E(e) { return e = (e || "").toLowerCase(), t[e] || t[r[e]] }
-      function y(e, { languageName: t }) {
-        "string" == typeof e && (e = [e]), e.forEach((e => {
-          r[e.toLowerCase()] = t
-        }))
-      } function _(e) {
-        const t = E(e)
-        ; return t && !t.disableAutodetect
-      } function x(e, t) {
-        const n = e; s.forEach((e => {
-          e[n] && e[n](t)
-        }))
-      }
-      "undefined" != typeof window && window.addEventListener && window.addEventListener("DOMContentLoaded", (() => {
-        b && m()
-      }), !1), Object.assign(e, {
-        highlight: u, highlightAuto: p, highlightAll: m,
-        highlightElement: f,
-        highlightBlock: e => (q("10.7.0", "highlightBlock will be removed entirely in v12.0"),
-          q("10.7.0", "Please use highlightElement now."), f(e)), configure: e => { g = V(g, e) },
-        initHighlighting: () => {
-          m(), q("10.6.0", "initHighlighting() deprecated.  Use highlightAll() now.")
-        },
-        initHighlightingOnLoad: () => {
-          m(), q("10.6.0", "initHighlightingOnLoad() deprecated.  Use highlightAll() now.")
-        }, registerLanguage: (n, i) => {
-          let r = null; try { r = i(e) } catch (e) {
-            if ($("Language definition for '{}' could not be registered.".replace("{}", n)),
-              !a) throw e; $(e), r = l
-          }
-          r.name || (r.name = n), t[n] = r, r.rawDefinition = i.bind(null, e), r.aliases && y(r.aliases, {
-            languageName: n
-          })
-        }, unregisterLanguage: e => {
-          delete t[e]
-          ; for (const t of Object.keys(r)) r[t] === e && delete r[t]
-        },
-        listLanguages: () => Object.keys(t), getLanguage: E, registerAliases: y,
-        autoDetection: _, inherit: V, addPlugin: e => {
-          (e => {
-            e["before:highlightBlock"] && !e["before:highlightElement"] && (e["before:highlightElement"] = t => {
-              e["before:highlightBlock"](Object.assign({ block: t.el }, t))
-            }), e["after:highlightBlock"] && !e["after:highlightElement"] && (e["after:highlightElement"] = t => {
-              e["after:highlightBlock"](Object.assign({ block: t.el }, t))
-            })
-          })(e), s.push(e)
-        }
-      }), e.debugMode = () => { a = !1 }, e.safeMode = () => { a = !0 }, e.versionString = "11.0.0-beta0"
-        ; for (const e in M) "object" == typeof M[e] && n(M[e]); return Object.assign(e, M), e
-    })({}), Y = Object.freeze({
-      __proto__: null, grmr_scheme: e => {
-        const t = "[^\\(\\)\\[\\]\\{\\}\",'`;#|\\\\\\s]+", n = {
-          $pattern: t,
-          built_in: "case-lambda call/cc class define-class exit-handler field import inherit init-field interface let*-values let-values let/ec mixin opt-lambda override protect provide public rename require require-for-syntax syntax syntax-case syntax-error unit/sig unless when with-syntax and begin call-with-current-continuation call-with-input-file call-with-output-file case cond define define-syntax delay do dynamic-wind else for-each if lambda let let* let-syntax letrec letrec-syntax map or syntax-rules ' * + , ,@ - ... / ; < <= = => > >= ` abs acos angle append apply asin assoc assq assv atan boolean? caar cadr call-with-input-file call-with-output-file call-with-values car cdddar cddddr cdr ceiling char->integer char-alphabetic? char-ci<=? char-ci<? char-ci=? char-ci>=? char-ci>? char-downcase char-lower-case? char-numeric? char-ready? char-upcase char-upper-case? char-whitespace? char<=? char<? char=? char>=? char>? char? close-input-port close-output-port complex? cons cos current-input-port current-output-port denominator display eof-object? eq? equal? eqv? eval even? exact->inexact exact? exp expt floor force gcd imag-part inexact->exact inexact? input-port? integer->char integer? interaction-environment lcm length list list->string list->vector list-ref list-tail list? load log magnitude make-polar make-rectangular make-string make-vector max member memq memv min modulo negative? newline not null-environment null? number->string number? numerator odd? open-input-file open-output-file output-port? pair? peek-char port? positive? procedure? quasiquote quote quotient rational? rationalize read read-char real-part real? remainder reverse round scheme-report-environment set! set-car! set-cdr! sin sqrt string string->list string->number string->symbol string-append string-ci<=? string-ci<? string-ci=? string-ci>=? string-ci>? string-copy string-fill! string-length string-ref string-set! string<=? string<? string=? string>=? string>? string? substring symbol->string symbol? tan transcript-off transcript-on truncate values vector vector->list vector-fill! vector-length vector-ref vector-set! with-input-from-file with-output-to-file write write-char zero?"
-        }, i = { className: "literal", begin: "(#t|#f|#\\\\" + t + "|#\\\\.)" }, r = {
-          className: "number", variants: [{ begin: "(-|\\+)?\\d+([./]\\d+)?", relevance: 0 }, {
-            begin: "(-|\\+)?\\d+([./]\\d+)?[+\\-](-|\\+)?\\d+([./]\\d+)?i", relevance: 0
-          }, {
-            begin: "#b[0-1]+(/[0-1]+)?"
-          }, { begin: "#o[0-7]+(/[0-7]+)?" }, {
-            begin: "#x[0-9a-f]+(/[0-9a-f]+)?"
-          }]
-        }, s = e.QUOTE_STRING_MODE, a = [e.COMMENT(";", "$", {
-          relevance: 0
-        }), e.COMMENT("#\\|", "\\|#")], o = { begin: t, relevance: 0 }, l = {
-          className: "symbol", begin: "'" + t
-        }, c = { endsWithParent: !0, relevance: 0 }, g = {
-          variants: [{
-            begin: /'/
-          }, { begin: "`" }], contains: [{
-            begin: "\\(", end: "\\)",
-            contains: ["self", i, s, r, o, l]
-          }]
-        }, d = {
-          className: "name", relevance: 0, begin: t,
-          keywords: n
-        }, u = {
-          variants: [{ begin: "\\(", end: "\\)" }, { begin: "\\[", end: "\\]" }],
-          contains: [{
-            begin: /lambda/, endsWithParent: !0, returnBegin: !0, contains: [d, {
-              endsParent: !0, variants: [{ begin: /\(/, end: /\)/ }, { begin: /\[/, end: /\]/ }],
-              contains: [o]
-            }]
-          }, d, c]
-        }; return c.contains = [i, r, s, o, l, g, u].concat(a), {
-          name: "Scheme", illegal: /\S/, contains: [e.SHEBANG(), r, s, l, g, u].concat(a)
-        }
-      },
-      grmr_rust: e => {
-        const t = {
-          className: "title.function.invoke", relevance: 0,
-          begin: u(/\b/, /(?!let\b)/, e.IDENT_RE, d(/\s*\(/))
-        }, n = "([ui](8|16|32|64|128|size)|f(32|64))?", i = ["drop ", "Copy", "Send", "Sized", "Sync", "Drop", "Fn", "FnMut", "FnOnce", "ToOwned", "Clone", "Debug", "PartialEq", "PartialOrd", "Eq", "Ord", "AsRef", "AsMut", "Into", "From", "Default", "Iterator", "Extend", "IntoIterator", "DoubleEndedIterator", "ExactSizeIterator", "SliceConcatExt", "ToString", "assert!", "assert_eq!", "bitflags!", "bytes!", "cfg!", "col!", "concat!", "concat_idents!", "debug_assert!", "debug_assert_eq!", "env!", "panic!", "file!", "format!", "format_args!", "include_bin!", "include_str!", "line!", "local_data_key!", "module_path!", "option_env!", "print!", "println!", "select!", "stringify!", "try!", "unimplemented!", "unreachable!", "vec!", "write!", "writeln!", "macro_rules!", "assert_ne!", "debug_assert_ne!"]
-        ; return {
-          name: "Rust", aliases: ["rs"], keywords: {
-            $pattern: e.IDENT_RE + "!?",
-            type: ["i8", "i16", "i32", "i64", "i128", "isize", "u8", "u16", "u32", "u64", "u128", "usize", "f32", "f64", "str", "char", "bool", "Box", "Option", "Result", "String", "Vec"],
-            keyword: ["abstract", "as", "async", "await", "become", "box", "break", "const", "continue", "crate", "do", "dyn", "else", "enum", "extern", "false", "final", "fn", "for", "if", "impl", "in", "let", "loop", "macro", "match", "mod", "move", "mut", "override", "priv", "pub", "ref", "return", "self", "Self", "static", "struct", "super", "trait", "true", "try", "type", "typeof", "unsafe", "unsized", "use", "virtual", "where", "while", "yield"],
-            literal: ["true", "false", "Some", "None", "Ok", "Err"], built_in: i
-          }, illegal: "</",
-          contains: [e.C_LINE_COMMENT_MODE, e.COMMENT("/\\*", "\\*/", {
-            contains: ["self"]
-          }), e.inherit(e.QUOTE_STRING_MODE, { begin: /b?"/, illegal: null }), {
-            className: "string", variants: [{ begin: /b?r(#*)"(.|\n)*?"\1(?!#)/ }, {
-              begin: /b?'\\?(x\w{2}|u\w{4}|U\w{8}|.)'/
-            }]
-          }, {
-            className: "symbol",
-            begin: /'[a-zA-Z_][a-zA-Z0-9_]*/
-          }, {
-            className: "number", variants: [{
-              begin: "\\b0b([01_]+)" + n
-            }, { begin: "\\b0o([0-7_]+)" + n }, {
-              begin: "\\b0x([A-Fa-f0-9_]+)" + n
-            }, {
-              begin: "\\b(\\d[\\d_]*(\\.[0-9_]+)?([eE][+-]?[0-9_]+)?)" + n
-            }], relevance: 0
-          }, {
-            begin: [/fn/, /\s+/, e.UNDERSCORE_IDENT_RE], className: {
-              1: "keyword",
-              3: "title.function"
-            }
-          }, {
-            className: "meta", begin: "#!?\\[", end: "\\]", contains: [{
-              className: "string", begin: /"/, end: /"/
-            }]
-          }, {
-            begin: [/let/, /\s+/, /(?:mut\s+)?/, e.UNDERSCORE_IDENT_RE], className: {
-              1: "keyword",
-              3: "keyword", 4: "variable"
-            }
-          }, {
-            begin: [/for/, /\s+/, e.UNDERSCORE_IDENT_RE, /\s+/, /in/], className: {
-              1: "keyword",
-              3: "variable", 5: "keyword"
-            }
-          }, {
-            begin: [/type/, /\s+/, e.UNDERSCORE_IDENT_RE],
-            className: { 1: "keyword", 3: "title.class" }
-          }, {
-            begin: [/(?:trait|enum|struct|union|impl|for)/, /\s+/, e.UNDERSCORE_IDENT_RE],
-            className: { 1: "keyword", 3: "title.class" }
-          }, {
-            begin: e.IDENT_RE + "::", keywords: {
-              keyword: "Self", built_in: i
-            }
-          }, { className: "punctuation", begin: "->" }, t]
-        }
-      }
-    })
-    ; const ee = J; for (const e of Object.keys(Y)) {
-      const t = e.replace("grmr_", "")
-      ; ee.registerLanguage(t, Y[e])
-    } return ee
-}()
-  ; "object" == typeof exports && "undefined" != typeof module && (module.exports = hljs);
\ No newline at end of file
diff --git a/docs/src/patterns/async.md b/docs/src/patterns/async.md
deleted file mode 100644
index b3dfed0b0..000000000
--- a/docs/src/patterns/async.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Async
-
-
diff --git a/docs/src/patterns/mutability.md b/docs/src/patterns/mutability.md
deleted file mode 100644
index 3d4bc4cab..000000000
--- a/docs/src/patterns/mutability.md
+++ /dev/null
@@ -1 +0,0 @@
-# Interior Mutability
diff --git a/docs/src/patterns/patterns.md b/docs/src/patterns/patterns.md
deleted file mode 100644
index 539599a1e..000000000
--- a/docs/src/patterns/patterns.md
+++ /dev/null
@@ -1 +0,0 @@
-# Common Patterns
diff --git a/docs/src/reference/builtins.md b/docs/src/reference/builtins.md
deleted file mode 100644
index 4b6630da5..000000000
--- a/docs/src/reference/builtins.md
+++ /dev/null
@@ -1,947 +0,0 @@
-
-# steel/core/option
-# steel/core/result
-# steel/identity
-# steel/hash
-### **hash-try-get**
-Gets the `key` from the given `map`. Returns #false if the key does not exist.
-
-(hash-try-get map key) -> (or any/c #false)
-
-* map : hash?
-* key : any/c
-
-#### Examples
-
-```scheme
-> (hash-try-get (hash 'a 10 'b 20) 'b) ;; => 20
-> (hash-try-get (hash 'a 10 'b 20) 'does-not-exist) ;; => #false
-```
-### **hash-length**
-Returns the number of key value pairs in the map
-
-(hash-length map) -> (and positive? int?)
-
-* map : hash?
-
-#### Examples
-
-```scheme
-> (hash-length (hash 'a 10 'b 20)) ;; => 2
-```
-### **hash-ref**
-Gets the `key` from the given `map`. Raises an error if the key does not exist. `hash-get` is an alias for this.
-
-(hash-ref map key) -> any/c
-
-* map : hash?
-* key : any/c
-
-#### Examples
-```scheme
-> (hash-get (hash 'a 10 'b 20) 'b) ;; => 20
-```
-### **hash-contains?**
-Checks whether the given map contains the given key. Key must be hashable.
-
-(hash-contains? map key) -> bool?
-
-* map : hash?
-* key : hashable?
-
-#### Example
-
-```scheme
-> (hash-contains? (hash 'a 10 'b 20) 'a) ;; => #true
-> (hash-contains? (hash 'a 10 'b 20) 'not-there) ;; => #false
-```
-### **hash-insert**
-Returns a new hashmap with the additional key value pair added. Performs a functional update,
-so the old hash map is still accessible.
-
-(hash-insert map key val) -> hash?
-
-* map : hash?
-* key : any/c
-* val : any/c
-
-#### Examples
-```scheme
-> (hash-insert (hash 'a 10 'b 20) 'c 30)
-
-=> #<hashmap {
-'a: 10,
-'b: 20,
-'c: 30
-}>
-```
-# steel/random
-# steel/io
-# steel/equality
-# steel/ord
-# steel/json
-# steel/sets
-# steel/time
-### **steel/time**
-
-
-#### steel/time
-    
-Contains direct wrappers around the Rust `std::time::Instant` and `std::time::Duration` modules. 
-For example, to measure the time something takes:
-
-```scheme
-(define t (instant/now))
-(displayln "Hello world")
-(displayln (instant/elapsed t))
-```
-
-# steel/vectors
-# steel/ports
-### **read-port-to-string**
-Takes a port and reads the entire content into a string
-
-(read-port-to-string port) -> string?
-
-* port : input-port?
-### **output-port?**
-Checks if a given value is an output port
-
-(output-port? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (define output (open-output-file "foo.txt"))
-> (output-port? output) ;; => #true
-```
-### **open-input-file**
-Takes a filename `path` referring to an existing file and returns an input port. Raises an error
-if the file does not exist
-
-(open-input-file string?) -> input-port?
-
-#### Examples
-```scheme
-> (open-input-file "foo-bar.txt") ;; => #<port>
-> (open-input-file "file-does-not-exist.txt")
-error[E08]: Io
-┌─ :1:2
-│
-1 │ (open-input-file "foo-bar.txt")
-│  ^^^^^^^^^^^^^^^ No such file or directory (os error 2)
-```
-### **stdin**
-Gets the port handle to stdin
-
-(stdin) -> input-port?
-
-#### Examples
-
-```scheme
-> (stdin) ;; => #<port>
-```
-### **input-port?**
-Checks if a given value is an input port
-
-(input-port? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (input-port? (stdin)) ;; => #true
-> (input-port? "foo") ;; => #false
-```
-### **open-output-file**
-Takes a filename `path` referring to a file to be created and returns an output port.
-
-(open-output-file string?) -> output-port?
-
-#### Examples
-```scheme
-> (open-output-file "foo-bar.txt") ;; => #<port>
-```
-# steel/strings
-### **starts-with?**
-Checks if the input string starts with a prefix
-
-(starts-with? input pattern) -> bool?
-
-input : string?
-pattern: string?
-
-#### Examples
-
-```scheme
-> (starts-with? "foobar" "foo") ;; => #true
-> (starts-with? "foobar" "bar") ;; => #false
-```
-### **split-whitespace**
-Returns a list of strings from the original string split on the whitespace
-
-(split-whitespace string?) -> (listof string?)
-
-#### Examples
-
-```scheme
-(split-whitespace "apples bananas fruits veggies") ;; '("apples" "bananas" "fruits" "veggies")
-```
-### **trim-end**
-Returns a new string with the trailing whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "   foo"
-```
-### **string->int**
-Converts a string into an int. Raises an error if the string cannot be converted to an integer.
-
-(string->int string?) -> int?
-
-#### Examples
-
-```scheme
-> (string->int "100") ;; => 10
-> (string->int "not-an-int") ;; error
-```
-### **ends-with?**
-Checks if the input string ends with a given suffix
-
-(ends-with? input pattern) -> bool?
-
-input : string?
-pattern: string?
-
-#### Examples
-
-```scheme
-> (ends-with? "foobar" "foo") ;; => #false
-> (ends-with? "foobar" "bar") ;; => #true
-```
-### **string-length**
-Get the length of the given string
-
-(string-length string?) -> int?
-
-#### Examples
-
-```scheme
-> (string-length "apples") ;; => 6
-```
-### **trim-start**
-Returns a new string with the leading whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "foo     "
-```
-### **string->upper**
-Creates a new uppercased version of the input string
-
-(string->upper string?) -> string?
-
-#### Examples
-
-```scheme
-> (string->upper "lower") ;; => "LOWER"
-```
-### **trim**
-Returns a new string with the leading and trailing whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "foo"
-```
-### **string->list**
-Converts a string into a list of characters.
-
-(string->list string?) -> (listof char?)
-
-#### Examples
-
-```scheme
-> (string->list "hello") ;; => '(#\h #\e #\l #\l #\o)
-```
-### **string->symbol**
-Converts a string into a symbol.
-
-(string->symbol string?) -> symbol?
-
-#### Examples
-
-```scheme
-> (string->symbol "FooBar") ;; => 'FooBar
-```
-### **int->string**
-Converts an integer into a string.
-
-(int->string int?) -> string?
-
-#### Examples
-
-```scheme
-> (int->string 10) ;; => "10"
-```
-### **string-append**
-Concatenates all of the given strings into one
-
-(string-append strs...) -> string?
-
-* strs ... : string?
-
-#### Examples
-```scheme
-> (string-append) ;; => ""
-> (string-append "foo" "bar") ;; => "foobar"
-### **string->lower**
-Creates a new lowercased version of the input string
-
-(string->lower string?) -> string?
-
-#### Examples
-
-```scheme
-> (string->lower "sPonGeBoB tExT") ;; => "spongebob text"
-```
-### **to-string**
-Concatenatives all of the inputs to their string representation, separated by spaces.
-
-(to-string xs ...)
-
-* xs : any/c
-
-#### Examples
-```scheme
-> (to-string 10) ;; => "10"
-> (to-string "hello" "world") ;; => "hello world"
-```
-# steel/filesystem
-# steel/syntax
-# steel/transducers
-# steel/symbols
-# steel/strings/colors
-# steel/meta
-# steel/base
-### **read-port-to-string**
-Takes a port and reads the entire content into a string
-
-(read-port-to-string port) -> string?
-
-* port : input-port?
-### **hash-contains?**
-Checks whether the given map contains the given key. Key must be hashable.
-
-(hash-contains? map key) -> bool?
-
-* map : hash?
-* key : hashable?
-
-#### Example
-
-```scheme
-> (hash-contains? (hash 'a 10 'b 20) 'a) ;; => #true
-> (hash-contains? (hash 'a 10 'b 20) 'not-there) ;; => #false
-```
-### **list-ref**
-Returns the value located at the given index. Will raise an error if you try to index out of bounds.
-
-Note: Runs in time proportional to the length of the list, however lists in Steel are implemented in such a fashion that the
-time complexity is O(n/64). Meaning, for small lists this can be constant.
-
-(list-ref lst index) -> list?
-
-* lst : list?
-* index : (and/c int? positive?)
-
-#### Examples
-```scheme
-> (list-ref (list 1 2 3 4) 2) ;; => 3
-> (list-ref (range 0 100) 42) ;; => 42"
-> (list-ref (list 1 2 3 4) 10)
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (list-ref (list 1 2 3 4) 10)
-│  ^^^^^^^^ out of bounds index in list-ref - list length: 4, index: 10
-```
-### **second**
-Get the second element of the list. Raises an error if the list does not have an element in the second position.
-
-(second l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (second '(1 2 3)) ;; => 2
-> (second '())
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (second '())
-│  ^^^^^^ second: index out of bounds - list did not have an element in the second position: []
-### **to-string**
-Concatenatives all of the inputs to their string representation, separated by spaces.
-
-(to-string xs ...)
-
-* xs : any/c
-
-#### Examples
-```scheme
-> (to-string 10) ;; => "10"
-> (to-string "hello" "world") ;; => "hello world"
-```
-### **output-port?**
-Checks if a given value is an output port
-
-(output-port? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (define output (open-output-file "foo.txt"))
-> (output-port? output) ;; => #true
-```
-### **open-output-file**
-Takes a filename `path` referring to a file to be created and returns an output port.
-
-(open-output-file string?) -> output-port?
-
-#### Examples
-```scheme
-> (open-output-file "foo-bar.txt") ;; => #<port>
-```
-### **range**
-Returns a newly allocated list of the elements in the range (n, m]
-
-(range n m) -> (listof int?)
-
-* n : int?
-* m : int?
-
-```scheme
-> (range 0 10) ;; => '(0 1 2 3 4 5 6 7 8 9)
-```
-### **string-length**
-Get the length of the given string
-
-(string-length string?) -> int?
-
-#### Examples
-
-```scheme
-> (string-length "apples") ;; => 6
-```
-### **car**
-Returns the first element of the list l.
-
-(car l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (car '(1 2)) ;; => 1
-> (car (cons 2 3)) ;; => 2
-```
-### **hash-ref**
-Gets the `key` from the given `map`. Raises an error if the key does not exist. `hash-get` is an alias for this.
-
-(hash-ref map key) -> any/c
-
-* map : hash?
-* key : any/c
-
-#### Examples
-```scheme
-> (hash-get (hash 'a 10 'b 20) 'b) ;; => 20
-```
-### **first**
-Returns the first element of the list l.
-
-(first l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (first '(1 2)) ;; => 1
-> (first (cons 2 3)) ;; => 2
-```
-### **split-whitespace**
-Returns a list of strings from the original string split on the whitespace
-
-(split-whitespace string?) -> (listof string?)
-
-#### Examples
-
-```scheme
-(split-whitespace "apples bananas fruits veggies") ;; '("apples" "bananas" "fruits" "veggies")
-```
-### **list**
-Returns a newly allocated list containing the vs as its elements.
-
-(list v ...) -> list?
-
-* v : any/c
-
-#### Examples
-
-```scheme
-> (list 1 2 3 4 5) ;; => '(1 2 3 4 5)
-> (list (list 1 2) (list 3 4)) ;; => '((1 2) (3 4))
-```
-### **hash-try-get**
-Gets the `key` from the given `map`. Returns #false if the key does not exist.
-
-(hash-try-get map key) -> (or any/c #false)
-
-* map : hash?
-* key : any/c
-
-#### Examples
-
-```scheme
-> (hash-try-get (hash 'a 10 'b 20) 'b) ;; => 20
-> (hash-try-get (hash 'a 10 'b 20) 'does-not-exist) ;; => #false
-```
-### **pair?**
-Checks if the given value can be treated as a pair.
-Note - there are no improper lists in steel, so any list with at least one element
-is considered a pair.
-
-(pair? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (pair? '(10 20)) ;; => #true
-> (pair? '(10)) ;; => #true
-> (pair? '()) ;; => #false
-```
-### **steel/lists**
-#### steel/lists
-
-Lists in Steel have an interface that matches those of classic schemes or lisps.
-At face value, they appear to be implemented as cons cells - however, under the hood
-they are actually implemented as unrolled linked lists.
-
-This means that for most practical purposes, interaction with lists is the same.
-That being said, there are no improper lists, meaning, pairs are actually just lists of two elements.
-
-Indexing into a list also takes O(n/64) - which means you'll get constant time indexing on small lists.
-
-```scheme
-(list 10 20 30 40) ;; => '(10 20 30 40)
-```
-### **third**
-Get the third element of the list. Raises an error if the list does not have an element in the third position.
-
-(third l) -> any/c
-
-* l : list?
-
-#### Examples
-```scheme
-> (third '(1 2 3)) ;; => 3
-> (third '())
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (third '())
-│  ^^^^^^ third: index out of bounds - list did not have an element in the second position: []
-```
-### **hash-length**
-Returns the number of key value pairs in the map
-
-(hash-length map) -> (and positive? int?)
-
-* map : hash?
-
-#### Examples
-
-```scheme
-> (hash-length (hash 'a 10 'b 20)) ;; => 2
-```
-### **string->upper**
-Creates a new uppercased version of the input string
-
-(string->upper string?) -> string?
-
-#### Examples
-
-```scheme
-> (string->upper "lower") ;; => "LOWER"
-```
-### **trim**
-Returns a new string with the leading and trailing whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "foo"
-```
-### **starts-with?**
-Checks if the input string starts with a prefix
-
-(starts-with? input pattern) -> bool?
-
-input : string?
-pattern: string?
-
-#### Examples
-
-```scheme
-> (starts-with? "foobar" "foo") ;; => #true
-> (starts-with? "foobar" "bar") ;; => #false
-```
-### **open-input-file**
-Takes a filename `path` referring to an existing file and returns an input port. Raises an error
-if the file does not exist
-
-(open-input-file string?) -> input-port?
-
-#### Examples
-```scheme
-> (open-input-file "foo-bar.txt") ;; => #<port>
-> (open-input-file "file-does-not-exist.txt")
-error[E08]: Io
-┌─ :1:2
-│
-1 │ (open-input-file "foo-bar.txt")
-│  ^^^^^^^^^^^^^^^ No such file or directory (os error 2)
-```
-### **input-port?**
-Checks if a given value is an input port
-
-(input-port? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (input-port? (stdin)) ;; => #true
-> (input-port? "foo") ;; => #false
-```
-### **ends-with?**
-Checks if the input string ends with a given suffix
-
-(ends-with? input pattern) -> bool?
-
-input : string?
-pattern: string?
-
-#### Examples
-
-```scheme
-> (ends-with? "foobar" "foo") ;; => #false
-> (ends-with? "foobar" "bar") ;; => #true
-```
-### **string-append**
-Concatenates all of the given strings into one
-
-(string-append strs...) -> string?
-
-* strs ... : string?
-
-#### Examples
-```scheme
-> (string-append) ;; => ""
-> (string-append "foo" "bar") ;; => "foobar"
-### **steel/time**
-
-
-#### steel/time
-    
-Contains direct wrappers around the Rust `std::time::Instant` and `std::time::Duration` modules. 
-For example, to measure the time something takes:
-
-```scheme
-(define t (instant/now))
-(displayln "Hello world")
-(displayln (instant/elapsed t))
-```
-
-### **trim-end**
-Returns a new string with the trailing whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "   foo"
-```
-### **string->list**
-Converts a string into a list of characters.
-
-(string->list string?) -> (listof char?)
-
-#### Examples
-
-```scheme
-> (string->list "hello") ;; => '(#\h #\e #\l #\l #\o)
-```
-### **empty?**
-Checks if the list is empty
-
-(empty? lst) -> bool?
-
-* lst: list?
-
-#### Examples
-
-```scheme
-> (empty? (list 1 2 3 4 5)) ;; => #false
-> (empty? '()) ;; => #true
-```
-### **int->string**
-Converts an integer into a string.
-
-(int->string int?) -> string?
-
-#### Examples
-
-```scheme
-> (int->string 10) ;; => "10"
-```
-### **trim-start**
-Returns a new string with the leading whitespace removed.
-
-(trim string?) -> string?
-
-#### Examples
-
-```scheme
-> (trim "   foo     ") ;; => "foo     "
-```
-### **stdin**
-Gets the port handle to stdin
-
-(stdin) -> input-port?
-
-#### Examples
-
-```scheme
-> (stdin) ;; => #<port>
-```
-### **hash-insert**
-Returns a new hashmap with the additional key value pair added. Performs a functional update,
-so the old hash map is still accessible.
-
-(hash-insert map key val) -> hash?
-
-* map : hash?
-* key : any/c
-* val : any/c
-
-#### Examples
-```scheme
-> (hash-insert (hash 'a 10 'b 20) 'c 30)
-
-=> #<hashmap {
-'a: 10,
-'b: 20,
-'c: 30
-}>
-```
-### **string->lower**
-Creates a new lowercased version of the input string
-
-(string->lower string?) -> string?
-
-#### Examples
-
-```scheme
-> (string->lower "sPonGeBoB tExT") ;; => "spongebob text"
-```
-### **string->int**
-Converts a string into an int. Raises an error if the string cannot be converted to an integer.
-
-(string->int string?) -> int?
-
-#### Examples
-
-```scheme
-> (string->int "100") ;; => 10
-> (string->int "not-an-int") ;; error
-```
-### **string->symbol**
-Converts a string into a symbol.
-
-(string->symbol string?) -> symbol?
-
-#### Examples
-
-```scheme
-> (string->symbol "FooBar") ;; => 'FooBar
-```
-# steel/process
-# steel/numbers
-# steel/streams
-# steel/constants
-# steel/threads
-# steel/lists
-### **steel/lists**
-#### steel/lists
-
-Lists in Steel have an interface that matches those of classic schemes or lisps.
-At face value, they appear to be implemented as cons cells - however, under the hood
-they are actually implemented as unrolled linked lists.
-
-This means that for most practical purposes, interaction with lists is the same.
-That being said, there are no improper lists, meaning, pairs are actually just lists of two elements.
-
-Indexing into a list also takes O(n/64) - which means you'll get constant time indexing on small lists.
-
-```scheme
-(list 10 20 30 40) ;; => '(10 20 30 40)
-```
-### **pair?**
-Checks if the given value can be treated as a pair.
-Note - there are no improper lists in steel, so any list with at least one element
-is considered a pair.
-
-(pair? any/c) -> bool?
-
-#### Examples
-
-```scheme
-> (pair? '(10 20)) ;; => #true
-> (pair? '(10)) ;; => #true
-> (pair? '()) ;; => #false
-```
-### **car**
-Returns the first element of the list l.
-
-(car l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (car '(1 2)) ;; => 1
-> (car (cons 2 3)) ;; => 2
-```
-### **third**
-Get the third element of the list. Raises an error if the list does not have an element in the third position.
-
-(third l) -> any/c
-
-* l : list?
-
-#### Examples
-```scheme
-> (third '(1 2 3)) ;; => 3
-> (third '())
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (third '())
-│  ^^^^^^ third: index out of bounds - list did not have an element in the second position: []
-```
-### **empty?**
-Checks if the list is empty
-
-(empty? lst) -> bool?
-
-* lst: list?
-
-#### Examples
-
-```scheme
-> (empty? (list 1 2 3 4 5)) ;; => #false
-> (empty? '()) ;; => #true
-```
-### **range**
-Returns a newly allocated list of the elements in the range (n, m]
-
-(range n m) -> (listof int?)
-
-* n : int?
-* m : int?
-
-```scheme
-> (range 0 10) ;; => '(0 1 2 3 4 5 6 7 8 9)
-```
-### **first**
-Returns the first element of the list l.
-
-(first l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (first '(1 2)) ;; => 1
-> (first (cons 2 3)) ;; => 2
-```
-### **list**
-Returns a newly allocated list containing the vs as its elements.
-
-(list v ...) -> list?
-
-* v : any/c
-
-#### Examples
-
-```scheme
-> (list 1 2 3 4 5) ;; => '(1 2 3 4 5)
-> (list (list 1 2) (list 3 4)) ;; => '((1 2) (3 4))
-```
-### **second**
-Get the second element of the list. Raises an error if the list does not have an element in the second position.
-
-(second l) -> any/c
-
-* l : list?
-
-#### Examples
-
-```scheme
-> (second '(1 2 3)) ;; => 2
-> (second '())
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (second '())
-│  ^^^^^^ second: index out of bounds - list did not have an element in the second position: []
-### **list-ref**
-Returns the value located at the given index. Will raise an error if you try to index out of bounds.
-
-Note: Runs in time proportional to the length of the list, however lists in Steel are implemented in such a fashion that the
-time complexity is O(n/64). Meaning, for small lists this can be constant.
-
-(list-ref lst index) -> list?
-
-* lst : list?
-* index : (and/c int? positive?)
-
-#### Examples
-```scheme
-> (list-ref (list 1 2 3 4) 2) ;; => 3
-> (list-ref (range 0 100) 42) ;; => 42"
-> (list-ref (list 1 2 3 4) 10)
-error[E11]: Generic
-┌─ :1:2
-│
-1 │ (list-ref (list 1 2 3 4) 10)
-│  ^^^^^^^^ out of bounds index in list-ref - list length: 4, index: 10
-```
-# steel/contracts
diff --git a/docs/src/reference/contracts.md b/docs/src/reference/contracts.md
deleted file mode 100644
index 3678c2b25..000000000
--- a/docs/src/reference/contracts.md
+++ /dev/null
@@ -1,86 +0,0 @@
-# Contracts
-
-Inspired by Racket's higher order contracts, `Steel` implements\* higher order contracts to enable design by contract, made easy with a `define/contract` macro for easier ergonomics. Racket makes use of a concept known as _blame_ which seeks to identify the violating party - `Steel` does not quite have fully fleshed out blame but that is a work in progress. Here are some examples:
-
-```scheme
-;; Simple flat contracts
-(define/contract (test x y)
-    (->/c even? even? odd?)
-    (+ x y 1))
-
-(test 2 2) ;; => 5
-
-(define/contract (test-violation x y)
-    (->/c even? even? odd?)
-    (+ x y 1))
-
-(test-violation 1 2) ;; contract violation
-
-```
-
-Contracts are implemented as _values_, so they are bound to functions. This enables the use of contract checking on functions themselves since functions can be passed around:
-
-```scheme
-;; Higher order contracts, check on application
-(define/contract (higher-order func y)
-    (->/c (->/c even? odd?) even? even?)
-    (+ 1 (func y)))
-
-(higher-order (lambda (x) (+ x 1)) 2) ;; => 4
-
-(define/contract (higher-order-violation func y)
-    (->/c (->/c even? odd?) even? even?)
-    (+ 1 (func y)))
-
-(higher-order-violation (lambda (x) (+ x 2)) 2) ;; contract violation
-```
-
-Contracts on functions do not get checked until they are applied, so a function returning a _contracted_ function won't cause a violation until that function is actually used:
-
-```scheme
-;; More higher order contracts, get checked on application
-(define/contract (output)
-    (->/c (->/c string? int?))
-    (lambda (x) 10))
-
-(define/contract (accept func)
-    (->/c (->/c string? int?) string?)
-    "cool cool cool")
-
-(accept (output)) ;; => "cool cool cool"
-
-;; different contracts on the argument
-(define/contract (accept-violation func)
-    (->/c (->/c string? string?) string?)
-    (func "applesauce")
-    "cool cool cool")
-
-(accept-violation (output)) ;; contract violation
-
-;; generates a function
-(define/contract (generate-closure)
-    (->/c (->/c string? int?))
-    (lambda (x) 10))
-
-;; calls generate-closure which should result in a contract violation
-(define/contract (accept-violation)
-    (->/c (->/c string? string?))
-    (generate-closure))
-
-((accept-violation) "test") ;; contract violation
-```
-
-Perhaps a more nuanced case:
-
-```scheme
-(define/contract (output)
-    (->/c (->/c string? int?))
-    (lambda (x) 10.2))
-
-(define/contract (accept)
-    (->/c (->/c string? number?))
-    (output))
-
-
-((accept) "test") ;; contract violation 10.2 satisfies number? but _not_ int?
-```
\ No newline at end of file
diff --git a/docs/src/reference/functions.md b/docs/src/reference/functions.md
deleted file mode 100644
index 40fb3a87b..000000000
--- a/docs/src/reference/functions.md
+++ /dev/null
@@ -1,50 +0,0 @@
-# Functions
-
-
-### keyword?
-
-```scheme
-
-(keyword? v) -> boolean?
-
-v: any/c
-
-```
-
-### mutable-vector
-
-```scheme
-
-(mutable-vector args ...) -> mutable-vector?
-
-```
-
-### struct
-
-Macro for creating a new struct, in the form of:
-`(struct <struct-name> (fields ...) options ...)`
-The options can consist of the following:
-
-Single variable options (those which their presence indicates `#true`)
-- `#:mutable`
-- `#:transparent`
-
-Other options must be presented as key value pairs, and will get stored
-in the struct instance. They will also be bound to the variable
-`___<struct-name>-options___` in the same lexical environment where the
-struct was defined. For example:
-
-```scheme
-λ > (struct Applesauce (a b c) #:mutable #:transparent #:unrecognized-option 1234)
-λ > ___Applesauce-options___
-=> #<hashmap {
-    '#:fields: '(a b c),
-    '#:mutable: #false,
-    '#:transparent: #false,
-    '#:unrecognized-option: 1234,
-}> 
-```
-
-By default, structs are immutable, which means setter functions will not
-be generated. Also by default, structs are not transparent, which means
-printing them will result in an opaque struct that does not list the fields
\ No newline at end of file
diff --git a/docs/src/reference/keywords.md b/docs/src/reference/keywords.md
deleted file mode 100644
index 21be43dbf..000000000
--- a/docs/src/reference/keywords.md
+++ /dev/null
@@ -1 +0,0 @@
-# Keywords
diff --git a/docs/src/reference/language.md b/docs/src/reference/language.md
deleted file mode 100644
index becfff769..000000000
--- a/docs/src/reference/language.md
+++ /dev/null
@@ -1 +0,0 @@
-# Language Reference
diff --git a/docs/src/reference/macros.md b/docs/src/reference/macros.md
deleted file mode 100644
index 7ef4911eb..000000000
--- a/docs/src/reference/macros.md
+++ /dev/null
@@ -1,25 +0,0 @@
-# Macros
-
-Steel contains a limited form of the `syntax-rules` that scheme provides. These macros build on the small primary language constructs that exist. Consider the following:
-
-```scheme
-(define-syntax or
-  (syntax-rules ()
-    [(or) #f]
-    [(or x) x]
-    [(or x y) (let ([z x])
-                (if z z y))]
-    [(or x y ...) (or x (or y ...))]))
-
-(or #f #f #t)
-```
-
-This will actually expand into something like this
-
-```scheme
-((λ (__z)
-     (if __z __z ((λ (__z) (if __z __z #t)) #f)))
-   #f)
-```
-
-These macros allow for a simple extension of Steel to however you see fit - defining macros in terms of the syntax rules format is fairly straightforward.
\ No newline at end of file
diff --git a/docs/src/reference/modules.md b/docs/src/reference/modules.md
deleted file mode 100644
index 5f2520255..000000000
--- a/docs/src/reference/modules.md
+++ /dev/null
@@ -1,35 +0,0 @@
-# Modules
-
-In order to support a growing codebase, Steel has module support for projects spanning multiple files. Steel files can `provide` values (with contracts attached) and `require` modules from other files:
-
-```scheme
-;; main.stl
-(require "provide.stl")
-
-(even->odd 10)
-
-
-;; provide.stl
-(provide 
-    (contract/out even->odd (->/c even? odd?))
-    no-contract
-    flat-value)
-
-(define (even->odd x) 
-    (+ x 1))
-
-(define (accept-number x) (+ x 10))
-
-(define (no-contract) "cool cool cool")
-(define flat-value 15)
-
-(displayln "Calling even->odd with some bad inputs but its okay")
-(displayln (even->odd 1))
-```
-
-Here we can see if we were to run `main` that it would include the contents of `provide`, and only provided values would be accessible from `main`. The contract is attached at the contract boundary, so inside the `provide` module, you can violate the contract, but outside the module the contract will be applied.
-
-A few notes on modules:
-* Cyclical dependencies are not allowed
-* Modules will be only compiled once and used across multiple files. If `A` requires `B` and `C`, and `B` requires `C`, `C` will be compiled once and shared between `A` and `B`. 
-* Modules will be recompiled when changed, and any dependent files will also be recompiled as necessary
\ No newline at end of file
diff --git a/docs/src/reference/syntax.md b/docs/src/reference/syntax.md
deleted file mode 100644
index 10d246900..000000000
--- a/docs/src/reference/syntax.md
+++ /dev/null
@@ -1 +0,0 @@
-# Syntax
diff --git a/docs/src/reference/transducers.md b/docs/src/reference/transducers.md
deleted file mode 100644
index 247b6868a..000000000
--- a/docs/src/reference/transducers.md
+++ /dev/null
@@ -1,66 +0,0 @@
-# Transducers
-
-Inspired by clojure's transducers, `Steel` has a similar object that is somewhere half way in between transducers and iterators. Consider the following:
-
-```scheme
-
-(mapping (lambda (x) (+ x 1))) ;; => <#iterator>
-(filtering even?) ;; => <#iterator>
-(taking 15) ;; => <#iterator>
-
-(compose 
-    (mapping add1)
-    (filtering odd?)
-    (taking 15)) ;; => <#iterator>
-```
-
-Each of these expressions emit an `<#iterator>` object, which means they're compatible with `execute` and `transduce`. Execute takes a transducer (i.e. `<#iterator>`) and a collection that can be iterated (`list`, `vector`, or `stream`) and applies the transducer.
-
-```scheme
-;; Accepts lists
-(execute (mapping (lambda (x) (+ x 1))) (list 1 2 3 4 5)) ;; => '(2 3 4 5 6)
-
-;; Accepts vectors
-(execute (mapping (lambda (x) (+ x 1))) (vector 1 2 3 4 5)) ;; '#(2 3 4 5 6)
-
-;; Even accepts streams!
-(define (integers n)
-    (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(execute (taking 5) (integers 0)) ;; => '(0 1 2 3 4)
-```
-
-Transduce is just `reduce` with more bells and whistles and works similarly:
-
-```scheme
-;; (-> transducer reducing-function initial-value iterable)
-(transduce (mapping (lambda (x) (+ x 1))) + 0 (list 0 1 2 3)) ;; => 10
-```
-
-Compose just combines the iterator functions and lets us avoid intermediate allocation. The composition works left to right - it chains each value through the functions and then accumulates into the output type. See the following:
-
-```scheme
-(define xf 
-    (compose 
-        (mapping add1)
-        (filtering odd?)
-        (taking 5)))
-
-(execute xf (range 0 100)) ;; => '(1 3 5 7 9)
-```
-
-By default, execute outputs to the same type that was passed in. In other words, if you `execute` a `list`, it will return a `list`. However, if you so choose, you can pass in a symbol specifying the output type of your choosing like so:
-
-```scheme
-(define xf 
-    (compose 
-        (mapping add1)
-        (filtering odd?)
-        (taking 5)))
-
-;; Takes a list and returns a vector
-(execute xf (range 0 100) 'vector) ;; => '#(1 3 5 7 9)
-
-;; Takes a vector and returns a list
-(execute xf (vector 0 1 2 3 4 5 6 7 8 9 10) 'list) ;; => '(1 3 5 7 9)
-```
\ No newline at end of file
diff --git a/docs/src/start/embedded.md b/docs/src/start/embedded.md
deleted file mode 100644
index aae5b6c52..000000000
--- a/docs/src/start/embedded.md
+++ /dev/null
@@ -1 +0,0 @@
-# Using Steel as an embedded scripting engine
diff --git a/docs/src/start/playground.md b/docs/src/start/playground.md
deleted file mode 100644
index d13fbd13a..000000000
--- a/docs/src/start/playground.md
+++ /dev/null
@@ -1 +0,0 @@
-# Online Playground
diff --git a/docs/src/start/standalone.md b/docs/src/start/standalone.md
deleted file mode 100644
index 3247d9fa1..000000000
--- a/docs/src/start/standalone.md
+++ /dev/null
@@ -1 +0,0 @@
-# Using Steel on its own
diff --git a/docs/src/start/start.md b/docs/src/start/start.md
deleted file mode 100644
index bad55622f..000000000
--- a/docs/src/start/start.md
+++ /dev/null
@@ -1 +0,0 @@
-# Getting Started
diff --git a/examples/interior_mutability.rs b/examples/interior_mutability.rs
deleted file mode 100644
index 85598fa85..000000000
--- a/examples/interior_mutability.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-use std::{
-    cell::RefCell,
-    rc::Rc,
-    sync::{Arc, Mutex},
-};
-
-use steel::steel_vm::engine::Engine;
-use steel::steel_vm::register_fn::RegisterFn;
-
-use once_cell::sync::Lazy;
-use steel_derive::Steel; // 1.3.1
-
-// Since Steel is a functional language, we can perform mutation by using the interior mutability pattern
-// We expose an Rc<RefCell<T>> (or, in a multi thread environment an Arc<Mutex<T>>) and expose
-// functions to interact with it
-#[derive(Clone, Debug, Steel, PartialEq)]
-pub struct RcRefCellWrapper(Rc<RefCell<usize>>);
-
-pub fn new_rc_ref_cell(val: usize) -> RcRefCellWrapper {
-    RcRefCellWrapper(Rc::new(RefCell::new(val)))
-}
-
-pub fn rc_refcell_increment(value: RcRefCellWrapper) {
-    *value.0.borrow_mut() += 1;
-}
-
-#[derive(Clone, Debug, Steel)]
-pub struct MutexWrapper(Arc<Mutex<usize>>);
-
-pub fn new_mutex_wrapper(val: usize) -> MutexWrapper {
-    MutexWrapper(Arc::new(Mutex::new(val)))
-}
-
-pub fn mutex_increment(value: MutexWrapper) {
-    *value.0.lock().unwrap() += 1;
-}
-
-// Optionally, you can also provide functions which hold references to static global
-// variables
-static ARRAY: Lazy<Mutex<Vec<u8>>> = Lazy::new(|| Mutex::new(vec![]));
-
-fn push_global_vector() {
-    ARRAY.lock().unwrap().push(1);
-    println!("{:?}", ARRAY.lock().unwrap());
-}
-
-pub fn main() {
-    let mut vm = Engine::new();
-
-    vm.register_type::<RcRefCellWrapper>("RcRefCellWrapper?")
-        .register_type::<MutexWrapper>("MutexWrapper?")
-        .register_fn("new-rc-refcell", new_rc_ref_cell)
-        .register_fn("rc-refcell-inc", rc_refcell_increment)
-        .register_fn("new-mutex-wrapper", new_mutex_wrapper)
-        .register_fn("mutex-inc", mutex_increment)
-        .register_fn("push-global-vector", push_global_vector);
-
-    vm.compile_and_run_raw_program(
-        r#"
-        (define rc (new-rc-refcell 0))
-        (define mutex (new-mutex-wrapper 0))
-
-        ;; Increment 5 times
-        (rc-refcell-inc rc)
-        (rc-refcell-inc rc)
-        (rc-refcell-inc rc)
-        (rc-refcell-inc rc)
-        (rc-refcell-inc rc)
-
-        ;; Increment 3 times
-        (mutex-inc mutex)
-        (mutex-inc mutex)
-        (mutex-inc mutex)
-
-        ;; Will print out twice with a growing vector
-        (push-global-vector)
-        (push-global-vector)
-    "#,
-    )
-    .unwrap();
-
-    let rc = vm.extract::<RcRefCellWrapper>("rc").unwrap();
-    let mutex: MutexWrapper = vm.extract("mutex").unwrap();
-
-    println!("RcRefCellWrapper: {rc:?}");
-    println!("MutexWrapper: {mutex:?}");
-}
diff --git a/examples/modules.rs b/examples/modules.rs
deleted file mode 100644
index 77286593d..000000000
--- a/examples/modules.rs
+++ /dev/null
@@ -1,24 +0,0 @@
-use steel::steel_vm::engine::Engine;
-
-// Steel allows for flexibility with modules as well. If you wanted to
-// expose a module with a clean api, you can do so using the `provide` syntax.
-// `require` is used to bring a module into scope - this requires the relative path
-// (from the directory of whatever project main is in), or absolute path to the script.
-// See the `modules` directory for the code used here
-//
-// Note: This should be run from the root of the project
-// Otherwise, it will fatal with a 'file not found'
-pub fn main() {
-    let mut vm = Engine::new();
-
-    vm.compile_and_run_raw_program(
-        r#"
-        (require "examples/modules/sort_export.scm")
-
-        (define sorted (sort '(1000 342 1 5534 34243 223 23495)))
-
-        (displayln sorted)
-    "#,
-    )
-    .unwrap();
-}
diff --git a/examples/modules/sort.scm b/examples/modules/sort.scm
deleted file mode 100644
index 764cfac01..000000000
--- a/examples/modules/sort.scm
+++ /dev/null
@@ -1,39 +0,0 @@
-(provide merge-sort)
-
-;;; Define a merge sort for sake of simplicity
-(define (merge-lists l1 l2)
-  (cond [(null? l1) l2]
-        [(null? l2) l1]
-        [(< (car l1) (car l2))
-         (cons (car l1) (merge-lists (cdr l1) l2))]
-        [else
-         (cons (car l2) (merge-lists (cdr l2) l1))]))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in even positions
-
-(define (even-numbers l)
-  (cond [(null? l) '()]
-        [(null? (cdr l)) '()]
-        [else
-         (cons (car (cdr l)) (even-numbers (cdr (cdr l))))]))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in odd positions
-
-(define (odd-numbers l)
-  (cond [(null? l) '()]
-        [(null? (cdr l)) (list (car l))]
-        [else
-         (cons (car l) (odd-numbers (cdr (cdr l))))]))
-
-;;; ---------------------------------------------------------------------
-;;; Use the procedures above to create a simple and efficient merge-sort
-
-(define (merge-sort l)
-  (cond [(null? l) l]
-        [(null? (cdr l)) l]
-        [else
-         (merge-lists
-          (merge-sort (odd-numbers l))
-          (merge-sort (even-numbers l)))]))
\ No newline at end of file
diff --git a/examples/modules/sort_export.scm b/examples/modules/sort_export.scm
deleted file mode 100644
index f431398e4..000000000
--- a/examples/modules/sort_export.scm
+++ /dev/null
@@ -1,5 +0,0 @@
-(require "sort.scm")
-
-(provide sort)
-
-(define (sort x) (merge-sort x))
\ No newline at end of file
diff --git a/examples/register_async_function.rs b/examples/register_async_function.rs
deleted file mode 100644
index 89868108e..000000000
--- a/examples/register_async_function.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use steel::steel_vm::engine::Engine;
-use steel::steel_vm::register_fn::RegisterFn;
-
-use env_logger::Builder;
-use log::LevelFilter;
-
-async fn test_function() -> usize {
-    println!("Inside async function!");
-    10 + await_within().await
-}
-
-async fn await_within() -> usize {
-    25
-}
-
-pub fn main() {
-    let mut builder = Builder::new();
-
-    builder
-        .filter(Some("steel::steel_vm::contracts"), LevelFilter::Trace)
-        .init();
-
-    let mut vm = Engine::new();
-
-    // You can even register async functions
-    // Using these in a script requires invoking them from an async context
-    // Or, explicitly poll them yourself in a non async context if you would
-    // like to not invoke it from an async context
-    vm.register_fn("test", test_function);
-
-    let contents = include_str!("scripts/async.scm");
-
-    let res = vm.compile_and_run_raw_program(contents);
-
-    if let Err(e) = res {
-        e.emit_result("async.rkt", contents);
-    }
-
-    let contents = include_str!("scripts/async-threads.scm");
-
-    let res = vm.compile_and_run_raw_program(contents);
-
-    if let Err(e) = res {
-        e.emit_result("async-threads.rkt", contents);
-    }
-
-    let contents = include_str!("scripts/poll.scm");
-
-    let res = vm.compile_and_run_raw_program(contents);
-
-    if let Err(e) = res {
-        e.emit_result("poll.rkt", contents);
-    }
-}
diff --git a/examples/register_functions.rs b/examples/register_functions.rs
deleted file mode 100644
index 4005a88c7..000000000
--- a/examples/register_functions.rs
+++ /dev/null
@@ -1,73 +0,0 @@
-use steel::steel_vm::engine::Engine;
-use steel::steel_vm::register_fn::RegisterFn;
-
-fn external_function(arg1: usize, arg2: usize) -> usize {
-    arg1 + arg2
-}
-
-fn option_function(arg1: Option<String>) -> Option<String> {
-    arg1
-}
-
-fn result_function(arg1: Option<String>) -> Result<String, String> {
-    if let Some(inner) = arg1 {
-        Ok(inner)
-    } else {
-        Err("Got a none".to_string())
-    }
-}
-
-async fn test_function() -> usize {
-    10
-}
-
-pub fn main() {
-    let mut vm = Engine::new();
-
-    // Here we can register functions
-    // Any function can accept parameters that implement `FromSteelVal` and
-    // return values that implement `IntoSteelVal`
-    vm.register_fn("external-function", external_function);
-
-    // See the docs for more information about `FromSteelVal` and `IntoSteelVal`
-    // but we can see even functions that accept/return Option<T> or Result<T,E>
-    // can be registered
-    vm.register_fn("option-function", option_function);
-
-    // Result values will map directly to errors in the VM and bubble back up
-    vm.register_fn("result-function", result_function);
-
-    // You can even register async finctions
-    vm.register_fn("test", test_function);
-
-    // vm.register_fn(
-    //     "unwrap-or",
-    //     std::result::Result::<String, String>::unwrap_or,
-    // );
-
-    vm.compile_and_run_raw_program(
-        r#"
-        (define foo (external-function 10 25))
-        (define bar (option-function "applesauce"))
-        (define baz (result-function "bananas"))
-        ;; (define res (unwrap-or baz "default"))
-    "#,
-    )
-    .unwrap();
-
-    let foo = vm.extract::<usize>("foo").unwrap();
-    println!("foo: {foo}");
-    assert_eq!(35, foo);
-
-    // Can also extract a value by specifying the type on the variable
-    let bar: String = vm.extract("bar").unwrap();
-    println!("bar: {bar}");
-    assert_eq!("applesauce".to_string(), bar);
-
-    let baz: Result<String, String> = vm.extract("baz").unwrap();
-    println!("baz: {baz:?}");
-    assert_eq!("bananas".to_string(), baz.unwrap());
-
-    // let res: SteelVal = vm.extract("res").unwrap();
-    // println!("res: {}", res);
-}
diff --git a/examples/register_types.rs b/examples/register_types.rs
deleted file mode 100644
index b3fdf75b5..000000000
--- a/examples/register_types.rs
+++ /dev/null
@@ -1,130 +0,0 @@
-use steel::steel_vm::engine::Engine;
-use steel::steel_vm::register_fn::RegisterFn;
-
-use steel_derive::Steel;
-
-// In order to register a type with Steel,
-// it must implement Clone, Debug, and Steel
-#[derive(Clone, Debug, Steel, PartialEq)]
-pub struct ExternalStruct {
-    foo: usize,
-    bar: String,
-    baz: f64,
-}
-
-#[derive(Clone, Debug, Steel, PartialEq)]
-pub enum ExternalEnum {
-    Foo,
-    Bar(String),
-}
-
-impl ExternalStruct {
-    pub fn new(foo: usize, bar: String, baz: f64) -> Self {
-        ExternalStruct { foo, bar, baz }
-    }
-
-    pub fn dumb() -> Self {
-        ExternalStruct::new(10, "hello-world".to_string(), 10.0)
-    }
-
-    // Embedding functions that take self must take by value
-    pub fn method_by_value(self) -> usize {
-        self.foo
-    }
-
-    // Setters should update the value and return a new instance (functional set)
-    pub fn set_foo(mut self, foo: usize) -> Self {
-        self.foo = foo;
-        self
-    }
-
-    pub fn method_by_reference(&self) -> usize {
-        self.foo
-    }
-
-    pub fn method_by_reference_mut(&mut self) -> usize {
-        self.foo
-    }
-
-    pub fn dummy_method(&self) -> bool {
-        true
-    }
-
-    pub fn dummy_test(&self, _other: &ExternalStruct) -> usize {
-        10
-    }
-}
-
-pub fn main() {
-    let mut vm = Engine::new();
-
-    // Registering a type gives access to a predicate for the type
-    vm.register_type::<ExternalStruct>("ExternalStruct?");
-    vm.register_type::<ExternalEnum>("ExternalEnum");
-
-    // Structs in steel typically have a constructor that is the name of the struct
-    vm.register_fn("ExternalStruct", ExternalStruct::new);
-    vm.register_fn("ExternalEnum::Foo", || ExternalEnum::Foo);
-    vm.register_fn("ExtenalEnum::Bar", ExternalEnum::Bar);
-    vm.register_fn("dumy", ExternalStruct::dumb);
-
-    vm.register_fn("dummy_test", ExternalStruct::dummy_test);
-
-    vm.register_fn("dummy-method", ExternalStruct::dummy_method);
-
-    // TODO -> this won't work because Custom is not implemented for option
-    // since it has a specialized implementation
-    // vm.register_method_fn("is_some", SteelValOption::is_some);
-
-    // register_fn can be chained
-    vm.register_fn("method-by-value", ExternalStruct::method_by_value)
-        .register_fn("method-by-reference", ExternalStruct::method_by_reference)
-        .register_fn(
-            "method-by-reference-mut",
-            ExternalStruct::method_by_reference_mut,
-        )
-        .register_fn("set-foo", ExternalStruct::set_foo);
-
-    let external_struct = ExternalStruct::new(1, "foo".to_string(), 12.4);
-
-    // Registering an external value is fallible if the conversion fails for some reason
-    // For instance, registering an Err(T) is fallible. However, most implementation outside of manual
-    // ones should not fail
-    vm.register_external_value("external-struct", external_struct)
-        .unwrap();
-
-    let output = vm
-        .compile_and_run_raw_program(
-            r#"
-            (define new-external-struct (set-foo external-struct 100))
-            (define get-output (method-by-value external-struct))
-            (define second-new-external-struct (ExternalStruct 50 "bananas" 72.6))
-            "last-result"
-        "#,
-        )
-        .unwrap();
-
-    let new_external_struct = vm.extract::<ExternalStruct>("new-external-struct").unwrap();
-    println!("new_external_struct: {new_external_struct:?}");
-    assert_eq!(
-        ExternalStruct::new(100, "foo".to_string(), 12.4),
-        new_external_struct
-    );
-
-    // Can also extract a value by specifying the type on the variable
-    let get_output: usize = vm.extract("get-output").unwrap();
-    println!("get_output: {get_output}");
-    assert_eq!(1, get_output);
-
-    let second_new_external_struct: ExternalStruct =
-        vm.extract("second-new-external-struct").unwrap();
-    println!("second_new_external_struct: {second_new_external_struct:?}");
-    assert_eq!(
-        ExternalStruct::new(50, "bananas".to_string(), 72.6),
-        second_new_external_struct
-    );
-
-    // We also get the output of the VM as the value of every expression run
-    // we can inspect the results just by printing like so
-    println!("{output:?}");
-}
diff --git a/examples/scripts/async-threads.scm b/examples/scripts/async-threads.scm
deleted file mode 100644
index f6f503a46..000000000
--- a/examples/scripts/async-threads.scm
+++ /dev/null
@@ -1,93 +0,0 @@
-; *thread-queue* : list[continuation]
-(define *thread-queue* '())
-
-; halt : continuation
-(define halt #f)
-
-; current-continuation : -> continuation
-(define (current-continuation)
-  (call/cc
-   (lambda (cc)
-     (cc cc))))
-
-; await : future -> value
-; yield the current thread and loop until the value is completed
-(define (await future)
-    (define output (poll! future))
-    ; (displayln output)
-    (if output
-        output
-        (begin
-            (yield)
-            (await future))))
-
-; spawn : (-> anything) -> void
-(define (spawn thunk)
-  (let ((cc (current-continuation)))
-    (if (continuation? cc)
-        (set! *thread-queue* (append *thread-queue* (list cc)))
-        (begin 
-               (thunk)
-               (quit)))))
-
-; yield : value -> void
-(define (yield)
-  (let ((cc (current-continuation)))
-    (if (and (continuation? cc) (pair? *thread-queue*))
-        (let ((next-thread (car *thread-queue*)))
-          (set! *thread-queue* (append (cdr *thread-queue*) (list cc)))
-          (next-thread 'resume))
-        void)))
-
-; quit : -> ...
-(define (quit)
-  (if (pair? *thread-queue*)
-      (let ((next-thread (car *thread-queue*)))
-        (set! *thread-queue* (cdr *thread-queue*))
-        (next-thread 'resume))
-      (halt)))
-   
-; start-threads : -> ...
-(define (start-threads)
-  (let ((cc (current-continuation)))
-    (if cc
-        (begin
-          (set! halt (lambda () (cc #f)))
-          (if (null? *thread-queue*)
-              void
-              (let ((next-thread (car *thread-queue*)))
-                    (set! *thread-queue* (cdr *thread-queue*))
-                    (next-thread 'resume))))
-        void)))
-
-;; Define an entry point 
-(define-syntax async-main
-  (syntax-rules ()
-    [(async-main main-func)
-    (begin main-func (spawn main) (start-threads))]))
-
-;; Use a macro to make it a little bit prettier
-(async-main
-  (define (main)
-      (displayln "Starting the main thread now!")
-      (define fut-1 (test))
-      (define fut-2 (test))
-      (define fut-3 (test))
-      ;; we're just going to block on the three different async calls
-      (await 
-          (join! fut-1 fut-2 fut-3))))
-
-;; Alternatively, we could just do this normally
-; (define (main)
-;     (displayln "Starting the main thread now!")
-;     (define fut-1 (test))
-;     (define fut-2 (test))
-;     (define fut-3 (test))
-;     ;; we're just going to block on the three different async calls
-;     (await 
-;         (join! fut-1 fut-2 fut-3)))
-; ;; Start one 'thread' for main
-; (spawn main)
-
-; ;; Kick off the execution
-; (start-threads)
diff --git a/examples/scripts/async.scm b/examples/scripts/async.scm
deleted file mode 100644
index 7f1d2bc73..000000000
--- a/examples/scripts/async.scm
+++ /dev/null
@@ -1,89 +0,0 @@
-; *thread-queue* : list[continuation]
-(define *thread-queue* '())
-
-; halt : continuation
-(define halt #f)
-
-; current-continuation : -> continuation
-(define (current-continuation)
-  (call/cc
-   (lambda (cc)
-     (cc cc))))
-
-; await : future -> value
-; yield the current thread and loop until the value is completed
-(define (await future)
-    (define output (poll! future))
-    (if output
-        output
-        (begin
-            (yield)
-            (await future))))
-
-; spawn : (-> anything) -> void
-(define (spawn thunk)
-  (let ((cc (current-continuation)))
-    (if (continuation? cc)
-        (set! *thread-queue* (append *thread-queue* (list cc)))
-        (begin 
-               (thunk)
-               (quit)))))
-
-; yield : value -> void
-(define (yield)
-  (let ((cc (current-continuation)))
-    (if (and (continuation? cc) (pair? *thread-queue*))
-        (let ((next-thread (car *thread-queue*)))
-          (set! *thread-queue* (append (cdr *thread-queue*) (list cc)))
-          (next-thread 'resume))
-        void)))
-
-; quit : -> ...
-(define (quit)
-  (if (pair? *thread-queue*)
-      (let ((next-thread (car *thread-queue*)))
-        (set! *thread-queue* (cdr *thread-queue*))
-        (next-thread 'resume))
-      (halt)))
-   
-; start-threads : -> ...
-(define (start-threads)
-  (let ((cc (current-continuation)))
-    (if cc
-        (begin
-          (set! halt (lambda () (cc #f)))
-          (if (null? *thread-queue*)
-              void
-              (begin
-                (let ((next-thread (car *thread-queue*)))
-                  (set! *thread-queue* (cdr *thread-queue*))
-                  (next-thread 'resume)))))
-        void)))
-
-
-;; Example cooperatively threaded program
-(define counter 2)
-
-(define (make-thread-thunk name)
-  (define (loop)
-        (when (< counter 0)
-            (quit))
-        (display "in thread ")
-        (display name)
-        (display "; counter = ")
-        (display counter)
-        (newline)
-        (set! counter (- counter 1))
-        (define output (await (test))) ;; block the execution of this thread on this future
-        (display "Future done!: ")
-        (display output)
-        (newline)
-        (yield)
-        (loop))
-  loop)
-
-(spawn (make-thread-thunk 'a))
-(spawn (make-thread-thunk 'b))
-(spawn (make-thread-thunk 'c))
-
-(start-threads)
diff --git a/examples/scripts/poll.scm b/examples/scripts/poll.scm
deleted file mode 100644
index a97811946..000000000
--- a/examples/scripts/poll.scm
+++ /dev/null
@@ -1,83 +0,0 @@
-; await : future -> value
-; yield the current thread and loop until the value is completed
-
-;; How to make the contract compile the exact same as a normal function?
-; (define/contract (block-on future)
-;   (->/c future? any/c)
-;   (define (loop future)
-;     (define output (poll! future))
-;     (if (equal? #f output)
-;         ;; Here, we would yield to the executor if we were await-ing
-;         ;; but we're going to just block until the future is complete
-;         (loop future)
-;         output))
-;   (loop future))
-
-
-; (define (block-on future)
-;   ; (->/c future? any/c)
-;     (define output (poll! future))
-;     (if (equal? #f output)
-;         ;; Here, we would yield to the executor if we were await-ing
-;         ;; but we're going to just block until the future is complete
-;         (block-on future)
-;         output))
-
-(define (test) 10)
-
-
-(define (block-on future)
-  ; (->/c future? any/c)
-    (define output (poll! future))
-    (if (equal? #f output)
-        ;; Here, we would yield to the executor if we were await-ing
-        ;; but we're going to just block until the future is complete
-        (block-on future)
-        output))
-
-(define block-on 
-  (bind/c
-     (make-function/c
-        (make/c future? 'future?)
-        (make/c any/c 'any/c))
-      block-on
-      'block-on))
-
-
-(define (main)
-    (displayln "Starting the main (single) thread now!")
-    (define fut-1 (test))
-    (define fut-2 (test))
-    (define fut-3 (test))
-    (displayln "Made it to here!")
-    ;; we're just going to block on the three different async calls
-    (block-on 
-        (join! fut-1 fut-2 fut-3))
-    ; (displayln "testing")
-    
-    )
-
-; (main)
-
-; (define main
-;   (λ ()
-;     ((λ (#####define-conversion0 fut-1 fut-2 fut-3)
-;          ((λ (#####define-conversion0
-;                 #####fut-11
-;                 #####fut-22
-;                 #####fut-33)
-;               (begin
-;                (set! fut-1 #####fut-11)
-;                 (set! fut-2 #####fut-22)
-;                 (set! fut-3 #####fut-33)
-;                 (displayln "Made it to here!")
-;                 (block-on (join! fut-1 fut-2 fut-3))))
-;             (displayln
-;                "Starting the main (single) thread now!")
-;             (test)
-;             (test)
-;             (test)))
-;        123
-;        123
-;        123
-;        123)))
\ No newline at end of file
diff --git a/examples/scripts/spellcheck.scm b/examples/scripts/spellcheck.scm
deleted file mode 100644
index bd91ef6aa..000000000
--- a/examples/scripts/spellcheck.scm
+++ /dev/null
@@ -1,108 +0,0 @@
-;; ----------- Levenshtein Distance Stuff ------------
-
-;; Get a globally accessibly levenshtein object for holding edit distance
-(define *levenshtein-obj* (new-levenshtein))
-(define (levenshtein l r)
-  (edit-distance *levenshtein-obj* l r))
-
-
-;; ------------------- utils ------------------------
-
-(define (flatten lst)
-  (cond ((null? lst) '())
-        ((list? lst)
-         (append (flatten (car lst)) (flatten (cdr lst))))
-        (else (list lst))))
-
-(define (hash-adjust m key func)
-  (define value (hash-try-get m key))
-  (if value
-      (hash-insert m key (func value))
-      m))
-
-;; ------------------- BK Tree ----------------------
-
-
-(struct BKTree (s children))
-
-(define (bk-empty? bktree)
-  (and (equal? "" (BKTree-s bktree))
-       (zero? (hash-length (BKTree-children bktree)))))
-
-(define empty-bk-tree (BKTree "" (hash)))
-
-;; BKTree -> String -> BKTree
-;; TODO make this part tail recursive
-(define (insert-word bktree new-word)
-  (define children-map (BKTree-children bktree))
-  (define root-word (BKTree-s bktree))
-  ;; (displayln "calculating...")
-  (define dist (levenshtein root-word new-word))
-  ;; (displayln "done")
-  (cond [(bk-empty? bktree) (BKTree new-word (hash))]
-        [(hash-try-get children-map dist)
-         (define children (hash-adjust children-map dist
-                                        (lambda (x) (insert-word x new-word))))
-         (BKTree root-word children)]
-        [else
-         (define children  (hash-insert children-map dist (BKTree new-word (hash))))
-         (BKTree root-word children)]))
-
-
-
-;; Int -> String -> BKTree -> [String]
-(define (query n query-word bktree)
-  (define root-word (BKTree-s bktree))
-  (define ts (BKTree-children bktree))
-  (define d (levenshtein root-word query-word))
-  (define lower (let ((res (- d n)))
-                  (if (< res 0)
-                      (* -1 res)
-                      res)))
-  (define upper (+ d n))
-  (define cs (filter (lambda (x) (if x #t #f))
-                     (map (lambda (y) (hash-try-get ts y))
-                          (range lower upper))))
-  (define ms (flatten (map (lambda (x) (query n query-word x)) cs)))
-  (if (<= d n)
-      (cons root-word ms)
-      ms))
-
-
-;; (define *bktree* (reduce insert-word empty-bk-tree '("hell" "help" "shel" "smell" "fell" "felt" "oops" "pop" "oouch" "halt")))
-(define *edit-distance* 2)
-(define *corpus-path* "/usr/share/dict/words")
-(define *corpus-port* (open-input-file *corpus-path*))
-
-;; returns false if can't get the next word
-;; otherwise returns the trimmed word
-(define (get-next-word!)
-  (define line (read-line-from-port *corpus-port*))
-  (if (symbol? line)
-      #f
-      (trim line)))
-
-;; For now just exclude anything longer than 6 letters for the sake of time
-(define (generate bktree func)
-    (define next-word (func))
-    ; (displayln next-word)
-    (if next-word
-        (if (> 6 (string-length next-word))
-            (generate (insert-word bktree next-word) func)
-            (generate bktree func))
-        bktree))
-
-(define (read-to-list lst)
-  (define next-word (get-next-word!))
-  (if next-word
-      (read-to-list (cons next-word lst))
-      lst))
-
-(displayln "Generating the bk tree")
-(define *bktree* (generate empty-bk-tree get-next-word!))
-(displayln "Done!")
-
-
-
-(define (suggest word)
-  (query *edit-distance* word *bktree*))
diff --git a/examples/spellcheck.rs b/examples/spellcheck.rs
deleted file mode 100644
index 9b8704b3f..000000000
--- a/examples/spellcheck.rs
+++ /dev/null
@@ -1,216 +0,0 @@
-extern crate steel;
-extern crate steel_derive;
-extern crate steel_repl;
-
-use steel_derive::Steel;
-
-use steel::steel_vm::engine::Engine;
-use steel_repl::repl::repl_base;
-
-use std::cell::RefCell;
-use std::cmp::{max, min};
-use std::collections::HashMap;
-use std::process;
-use std::rc::Rc;
-use steel::steel_vm::register_fn::RegisterFn;
-
-use env_logger::Builder;
-use log::LevelFilter;
-
-/// An implementation of a spell check in steel, with the levenshtein distance calculated
-/// via Rust, and a BKTree implementation in steel
-/// For optimal performance, implementing the entire spellchecker in Rust and exposing
-/// an interface to Steel would be ideal, however since trees go naturally with schemes
-/// in general, I opted to include this as an example
-/// Note: It is possible to implement the levenshtein distance in Steel, however at scale
-/// it proves to be cumbersome and slows down the spell checking greatly.
-///
-///
-/// This will launch a repl instance after building the spellchecker
-/// see `spellcheck.rkt` for the exact script
-fn main() {
-    let mut builder = Builder::new();
-
-    builder
-        .filter(Some("steel::compiler::code_generator"), LevelFilter::Trace)
-        .init();
-
-    let mut vm = configure_engine();
-
-    let contents = include_str!("scripts/spellcheck.scm");
-
-    let res = vm.compile_and_run_raw_program(contents);
-
-    if let Err(e) = res {
-        e.emit_result("spellcheck.rkt", contents);
-    }
-
-    finish(repl_base(vm))
-}
-
-fn finish(result: Result<(), std::io::Error>) -> ! {
-    let code = match result {
-        Ok(()) => 0,
-        Err(e) => {
-            eprintln!(
-                "{}: {}",
-                std::env::args().next().unwrap_or_else(|| "steel".into()),
-                e
-            );
-            1
-        }
-    };
-
-    process::exit(code);
-}
-
-pub fn configure_engine() -> Engine {
-    let mut vm = Engine::new();
-    vm.register_type::<Levenshtein>("Levenshtein?")
-        .register_fn("new-levenshtein", new_levenshtein)
-        .register_fn("edit-distance", Levenshtein::edit_distance);
-    vm
-}
-
-#[derive(Clone, Debug, Steel)]
-pub struct Levenshtein(Rc<RefCell<EditDistance>>);
-
-impl Levenshtein {
-    pub fn edit_distance(self, one: String, two: String) -> usize {
-        self.0
-            .borrow_mut()
-            .get_edit_distance(one.as_str(), two.as_str())
-    }
-}
-
-pub fn new_levenshtein() -> Levenshtein {
-    Levenshtein(Rc::new(RefCell::new(EditDistance::new(15))))
-}
-
-/// Represents edit distance with a preallocated array for distances
-#[derive(Default, Debug, PartialEq)]
-pub struct EditDistance {
-    mat: Vec<Vec<usize>>,
-}
-
-impl EditDistance {
-    /// Creates a new `EditDistance` with dimensions `n` x `n`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use correct::bktree::EditDistance;
-    /// let mut ed1 = EditDistance::new(5);
-    /// let mut ed2 = EditDistance::new(5);
-    /// ed1.get_edit_distance("one", "ones");
-    /// assert_ne!(ed1, ed2);
-    /// ed1.clear_mat();
-    /// assert_eq!(ed1, ed2);
-    /// ```
-    ///
-    pub fn new(n: usize) -> Self {
-        EditDistance {
-            mat: vec![vec![0; n + 2]; n + 2],
-        }
-    }
-
-    /// Zeros out the edit distance matrix
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use correct::bktree::EditDistance;
-    /// let mut ed1 = EditDistance::new(5);
-    /// let mut ed2 = EditDistance::new(5);
-    /// ed1.get_edit_distance("one", "ones");
-    /// assert_ne!(ed1, ed2);
-    /// ed1.clear_mat();
-    /// assert_eq!(ed1, ed2);
-    /// ```
-    ///
-    pub fn clear_mat(&mut self) {
-        for i in 0..self.mat.len() {
-            for j in 0..self.mat.len() {
-                self.mat[i][j] = 0;
-            }
-        }
-    }
-
-    /// Calculates the Damerau-Levenshtein distance between two
-    /// `&str`s, `s`, and `t`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use correct::bktree::EditDistance;
-    /// let mut ed = EditDistance::new(6);
-    /// assert_eq!(1, ed.get_edit_distance("matt", "mat"));
-    /// assert_eq!(1, ed.get_edit_distance("mattt", "matt"));
-    /// assert_eq!(1, ed.get_edit_distance("maat", "matt"));
-    /// assert_eq!(1, ed.get_edit_distance("kevin", "kevi"));
-    /// assert_eq!(1, ed.get_edit_distance("kevn", "kevin"));
-    /// assert_eq!(2, ed.get_edit_distance("abcde", "badce"));
-    /// assert_eq!(2, ed.get_edit_distance("m", "man"));
-    /// assert_eq!(0, ed.get_edit_distance("", ""));
-    /// assert_eq!(3, ed.get_edit_distance("", "one"));
-    /// assert_eq!(3, ed.get_edit_distance("two", ""));
-    /// assert_eq!(3, ed.get_edit_distance("1234", "21435"));
-    ///
-    /// ```
-    ///
-    pub fn get_edit_distance(&mut self, s: &str, t: &str) -> usize {
-        // get length of unicode chars
-        let len_s = s.chars().count();
-        let len_t = t.chars().count();
-        let max_distance = len_t + len_s;
-        let longest = max(len_s, len_t);
-
-        // TODO make this better
-        // expand the matrix if its not big enough
-        // self.mat = vec![vec![0; longest + 2]; longest + 2];
-        if self.mat.len() < longest + 2 {
-            self.mat = vec![vec![0; longest + 2]; longest + 2];
-        }
-
-        // initialize the matrix
-        self.mat[0][0] = max_distance;
-        for i in 0..=len_s {
-            self.mat[i + 1][0] = max_distance;
-            self.mat[i + 1][1] = i;
-        }
-        for i in 0..=len_t {
-            self.mat[0][i + 1] = max_distance;
-            self.mat[1][i + 1] = i;
-        }
-
-        let mut char_map: HashMap<char, usize> = HashMap::new();
-        // apply edit operations
-        for (i, s_char) in s.chars().enumerate() {
-            let mut db = 0;
-            let i = i + 1;
-            for (j, t_char) in t.chars().enumerate() {
-                let j = j + 1;
-                let last = *char_map.get(&t_char).unwrap_or(&0);
-
-                let cost = if s_char == t_char { 0 } else { 1 };
-                self.mat[i + 1][j + 1] = min(
-                    self.mat[i + 1][j] + 1, // deletion
-                    min(
-                        self.mat[i][j + 1] + 1, // insertion
-                        min(
-                            self.mat[i][j] + cost,                                  // substitution
-                            self.mat[last][db] + (i - last - 1) + 1 + (j - db - 1), // transposition
-                        ),
-                    ),
-                );
-                if cost == 0 {
-                    db = j;
-                }
-            }
-
-            char_map.insert(s_char, i);
-        }
-
-        self.mat[len_s + 1][len_t + 1]
-    }
-}
diff --git a/flake.lock b/flake.lock
deleted file mode 100644
index 6280488f8..000000000
--- a/flake.lock
+++ /dev/null
@@ -1,82 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1694529238,
-        "narHash": "sha256-zsNZZGTGnMOf9YpHKJqMSsa0dXbfmxeoJ7xHlrt+xmY=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "ff7b65b44d01cf9ba6a71320833626af21126384",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "gitignore": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
-      "locked": {
-        "lastModified": 1694102001,
-        "narHash": "sha256-vky6VPK1n1od6vXbqzOXnekrQpTL4hbPAwUhT5J9c9E=",
-        "owner": "hercules-ci",
-        "repo": "gitignore.nix",
-        "rev": "9e21c80adf67ebcb077d75bd5e7d724d21eeafd6",
-        "type": "github"
-      },
-      "original": {
-        "owner": "hercules-ci",
-        "repo": "gitignore.nix",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1699099776,
-        "narHash": "sha256-X09iKJ27mGsGambGfkKzqvw5esP1L/Rf8H3u3fCqIiU=",
-        "owner": "nixos",
-        "repo": "nixpkgs",
-        "rev": "85f1ba3e51676fa8cc604a3d863d729026a6b8eb",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nixos",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "gitignore": "gitignore",
-        "nixpkgs": "nixpkgs"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}
diff --git a/flake.nix b/flake.nix
deleted file mode 100644
index 0313eea2c..000000000
--- a/flake.nix
+++ /dev/null
@@ -1,55 +0,0 @@
-{
-  description = "Steel";
-
-  inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable"; # We want to use packages from the binary cache
-    flake-utils.url = "github:numtide/flake-utils";
-    gitignore = {
-      url = "github:hercules-ci/gitignore.nix";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
-  };
-
-  outputs = {
-    self,
-    nixpkgs,
-    flake-utils,
-    gitignore,
-  }:
-    flake-utils.lib.eachDefaultSystem (system: let
-      inherit (gitignore.lib) gitignoreSource;
-      pkgs = nixpkgs.legacyPackages.${system};
-
-      manifest = pkgs.lib.importTOML ./Cargo.toml;
-      steel = with pkgs;
-        rustPlatform.buildRustPackage rec {
-          pname = manifest.package.name;
-          version = manifest.workspace.package.version;
-          src = gitignoreSource ./.;
-          cargoLock.lockFile = ./Cargo.lock;
-          buildInputs = [openssl] ++ lib.optionals stdenv.isDarwin [darwin.apple_sdk.frameworks.Security];
-          nativeBuildInputs = [
-            pkg-config
-          ];
-          # Test failing
-          doCheck = false;
-          postInstall = ''
-            mkdir $out/lib
-            export STEEL_HOME="$out/lib"
-            pushd cogs
-            $out/bin/steel install.scm
-            popd
-          '';
-        };
-    in rec {
-      packages.steel = steel;
-      legacyPackages = packages;
-      defaultPackage = packages.steel;
-      devShell = with pkgs; mkShell {
-        buildInputs = [cargo openssl] ++ lib.optionals stdenv.isDarwin [darwin.apple_sdk.frameworks.Security];
-        nativeBuildInputs = [
-          pkg-config
-        ];
-      };
-    });
-}
diff --git a/images/logo.txt b/images/logo.txt
deleted file mode 100644
index dc1d87750..000000000
--- a/images/logo.txt
+++ /dev/null
@@ -1,41 +0,0 @@
-                                                                                                    
-                                                                                                    
-                                                                                                    
-                                                                                                    
-                                                                                                    
-                                                                                                    
-                                              .....                                                 
-                                             .kkkkk:                                                
-                                .,lc         :kkkkkd         ,o;.                                   
-                              .dkkkkx;       xkkkkkk.      .dkkkkx,                                 
-                               ;kkkkkkd'.';:lkkkkkkkdc;'..okkkkkko                                  
-                                lkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkx.                                  
-                                .xkkkkkkkkkkkxxxxOOkkkkkkkkkkkkk,                                   
-                      lc;'.    ;xkkkkkkxdollcccccoKXXXK00Okkkkkkkl.    .,co'                        
-                    .dkkkkkxocxkkkkkkkxddolcccccccl0XXXXXXXKOkkkkkkooxkkkkkk;                       
-                    ,dkkkkkkkkkkkkkkkkkkkkkoccccccclKXXXXXXXXXOkkkkkkkkkkkkx:                       
-                      .cxkkkkkkkkkkkkkkkkkkklcccccccoXXXXXXXXXXKOkkkkkkkkl'                         
-                         :kkkkkkkkkkkkkkkkkkxccccccccxXXXXXXXXXXXOkkkkko.                           
-                         okkkkkkkkkkkkkkkkkkxcccccccccOXXXXXXXXXXXOkkkkx.                           
-                        ;kkkkkkkkkkkkkkkkkkxccccccccccc0XXXXXXXXXXXkkkkkl.                          
-                 :lodxkkkkkkkkkkkkkkkkkkkkxlcccccccccccoXXXXXXXXXXXOkkkkkkkxdolc.                   
-                 kkkkkkkkkkkkkkkkkkkkkkkkklcccccccccccccdXXXXXXXXXX0kkkkkkkkkkkk,                   
-                 dxkkkkkkkkkkkkkkkkkkkkkklccccccccccccccckXXXXXXXXX0kkkkkkkkkkkx'                   
-                    ...'lkkkkkkkkkkkkkkkoccccccclocccccccc0XXXXXXXXkkkkkd,...                       
-                         xkkkkkkkkkkkkkoccccccclkklccccccclKXXXXXX0kkkkk'                           
-                         ;kkkkkkkkkkkkdccccccccxkkklcccccccoXXXXX0kkkkkx                            
-                       'lkkkkkkkkkkkkxccccccccdkkkkxccccccccxXXX0kkkkkkkd;                          
-                    .:xkkkkkkkkkkkkkxccccccccdkkkkkkdccccccccOKkkkkkkkkkkkkl.                       
-                    ;kkkkkkkkxkkkkkkdlccccccokkkkkkkkocccccloxkkkkkxkkkkkkkko                       
-                     .xxoc,.. 'okkkkkkxdolclkkkkkkkkkkllodxkkkkkkx;  .':ldk:                        
-                                .xkkkkkkkkkxkkkkkkkkkkkkkkkkkkkk:                                   
-                                :kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkko                                   
-                               'kkkkkkkc,:ldxkkkkkkkkdoc;;xkkkkkkc                                  
-                              .xkkkkko.      xkkkkkk,      :xkkkkk,                                 
-                               .,lxd'        ckkkkkx        .lko;.                                  
-                                             .kkkkkc                                                
-                                              ;;;;;.                                                
-                                                                                                    
-                                                                                                    
-                                                                                                    
-                                                                                                    
diff --git a/images/repl.gif b/images/repl.gif
deleted file mode 100644
index 9d8872d35..000000000
Binary files a/images/repl.gif and /dev/null differ
diff --git a/images/styled.jpg b/images/styled.jpg
deleted file mode 100644
index f82d0c61f..000000000
Binary files a/images/styled.jpg and /dev/null differ
diff --git a/images/styled.png b/images/styled.png
deleted file mode 100644
index bacaf5612..000000000
Binary files a/images/styled.png and /dev/null differ
diff --git a/notes/.obsidian/app.json b/notes/.obsidian/app.json
deleted file mode 100644
index 9e26dfeeb..000000000
--- a/notes/.obsidian/app.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
\ No newline at end of file
diff --git a/notes/.obsidian/appearance.json b/notes/.obsidian/appearance.json
deleted file mode 100644
index 5a41a71b0..000000000
--- a/notes/.obsidian/appearance.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-  "accentColor": "",
-  "cssTheme": ""
-}
\ No newline at end of file
diff --git a/notes/.obsidian/core-plugins.json b/notes/.obsidian/core-plugins.json
deleted file mode 100644
index 96869dfde..000000000
--- a/notes/.obsidian/core-plugins.json
+++ /dev/null
@@ -1,19 +0,0 @@
-[
-  "file-explorer",
-  "global-search",
-  "switcher",
-  "graph",
-  "backlink",
-  "outgoing-link",
-  "tag-pane",
-  "page-preview",
-  "daily-notes",
-  "templates",
-  "note-composer",
-  "command-palette",
-  "editor-status",
-  "starred",
-  "outline",
-  "word-count",
-  "file-recovery"
-]
\ No newline at end of file
diff --git a/notes/.obsidian/hotkeys.json b/notes/.obsidian/hotkeys.json
deleted file mode 100644
index 9e26dfeeb..000000000
--- a/notes/.obsidian/hotkeys.json
+++ /dev/null
@@ -1 +0,0 @@
-{}
\ No newline at end of file
diff --git a/notes/.obsidian/themes/Obsidian Nord/manifest.json b/notes/.obsidian/themes/Obsidian Nord/manifest.json
deleted file mode 100644
index b735c7258..000000000
--- a/notes/.obsidian/themes/Obsidian Nord/manifest.json	
+++ /dev/null
@@ -1,7 +0,0 @@
-{
-   "name": "Obsidian Nord",
-   "version": "0.1.7",
-   "minAppVersion": "0.16.0",
-   "author": "insanum",
-   "authorUrl": "https://insanum.com"
-}
diff --git a/notes/.obsidian/themes/Obsidian Nord/theme.css b/notes/.obsidian/themes/Obsidian Nord/theme.css
deleted file mode 100644
index 0a1b50136..000000000
--- a/notes/.obsidian/themes/Obsidian Nord/theme.css	
+++ /dev/null
@@ -1,481 +0,0 @@
-
-:root
-{
-    --dark0_x:  46,52,64; /* #2e3440 */
-    --dark0:    rgb(var(--dark0_x));
-    --dark1_x:  59,66,82; /* #3b4252 */
-    --dark1:    rgb(var(--dark1_x));
-    --dark2_x:  67,76,94; /* #434c5e */
-    --dark2:    rgb(var(--dark2_x));
-    --dark3_x:  76,86,106; /* #4c566a */
-    --dark3:    rgb(var(--dark3_x));
-
-    --light0_x: 216,222,233; /* #d8dee9 */
-    --light0:   rgb(var(--light0_x));
-    --light1_x: 229,233,240; /* #e5e9f0 */
-    --light1:   rgb(var(--light1_x));
-    --light2_x: 236,239,244; /* #eceff4 */
-    --light2:   rgb(var(--light2_x));
-    --light3_x: 255,255,255; /* #ffffff */
-    --light3:   rgb(var(--light3_x));
-
-    --frost0_x: 143,188,187; /* #8fbcbb */
-    --frost0:   rgb(var(--frost0_x));
-    --frost1_x: 136,192,208; /* #88c0d0 */
-    --frost1:   rgb(var(--frost1_x));
-    --frost2_x: 129,161,193; /* #81a1c1 */
-    --frost2:   rgb(var(--frost2_x));
-    --frost3_x: 94,129,172; /* #5e81ac */
-    --frost3:   rgb(var(--frost3_x));
-
-    --red_x:    191,97,106; /* #bf616a */
-    --red:      rgb(var(--red_x));
-    --orange_x: 208,135,112; /* #d08770 */
-    --orange:   rgb(var(--orange_x));
-    --yellow_x: 235,203,139; /* #ebcb8b */
-    --yellow:   rgb(var(--yellow_x));
-    --green_x:  163,190,140; /* #a3be8c */
-    --green:    rgb(var(--green_x));
-    --purple_x: 180,142,173; /* #b48ead */
-    --purple:   rgb(var(--purple_x));
-}
-
-body
-{
-    --accent-h: 354; /* --red #bf616a */
-    --accent-s: 42%;
-    --accent-l: 56%;
-
-    --link-decoration:                none;
-    --link-decoration-hover:          none;
-    --link-external-decoration:       none;
-    --link-external-decoration-hover: none;
-
-    --tag-decoration:                 none;
-    --tag-decoration-hover:           underline;
-    --tag-padding-x:                  .5em;
-    --tag-padding-y:                  .2em;
-    --tag-radius:                     .5em;
-
-    --tab-font-weight:                600;
-    --bold-weight:                    600;
-
-    --checkbox-radius:                0;
-
-    /* --list-indent:                    2em; */
-
-    --embed-border-left: 6px double var(--interactive-accent);
-}
-
-.theme-dark
-{
-    --color-red-rgb:                 var(--red_x);
-    --color-red:                     var(--red);
-    --color-purple-rgb:              var(--purple_x);
-    --color-purple:                  var(--purple);
-    --color-green-rgb:               var(--green_x);
-    --color-green:                   var(--green);
-    --color-cyan-rgb:                var(--frost1_x);
-    --color-cyan:                    var(--frost1);
-    --color-blue-rgb:                var(--frost3_x);
-    --color-blue:                    var(--frost3);
-    --color-yellow-rgb:              var(--yellow_x);
-    --color-yellow:                  var(--yellow);
-    --color-orange-rgb:              var(--orange_x);
-    --color-orange:                  var(--orange);
-    /* --color-pink:                    var(--purple); */
-
-    --background-primary:            var(--dark0);
-    --background-primary-alt:        var(--dark0);
-    --background-secondary:          var(--dark1);
-    --background-secondary-alt:      var(--dark2);
-    --background-modifier-border:    var(--dark2);
-
-    --cursor-line-background:        rgba(var(--dark3_x), 0.5);
-
-    --text-normal:                   var(--light2);
-    --text-faint:                    var(--light0);
-    --text-muted:                    var(--light1);
-
-    --h1-color:                      var(--red);
-    --h2-color:                      var(--yellow);
-    --h3-color:                      var(--green);
-    --h4-color:                      var(--purple);
-    --h5-color:                      var(--frost0);
-    --h6-color:                      var(--frost2);
-
-    --text-highlight-bg:             var(--frost1);
-    --text-highlight-fg:             var(--dark0);
-
-    --text-accent:                   var(--orange);
-    --text-accent-hover:             var(--frost2);
-
-    --tag-color:                     var(--frost0);
-    --tag-background:                var(--dark2);
-    --tag-background-hover:          var(--dark1);
-
-    --titlebar-text-color-focused:   var(--red);
-
-    --inline-title-color:            var(--yellow);
-
-    --bold-color:                    var(--yellow);
-    --italic-color:                  var(--yellow);
-
-    --checkbox-color:                var(--frost0);
-    --checkbox-color-hover:          var(--frost0);
-    --checkbox-border-color:         var(--frost0);
-    --checkbox-border-color-hover:   var(--frost0);
-    --checklist-done-color:          rgba(var(--light2_x), 0.5);
-
-    --table-header-background:       hsl(220, 16%, 16%);
-    --table-header-background-hover: var(--dark3);
-    --table-row-even-background:     hsl(220, 16%, 20%);
-    --table-row-odd-background:      hsl(220, 16%, 24%);
-    --table-row-background-hover:    var(--dark3);
-
-    --text-selection:                rgba(var(--red_x), 0.6);
-    --flashing-background:           rgba(var(--red_x), 0.3);
-
-    --code-normal:                   var(--frost1);
-    --code-background:               var(--dark1);
-
-    --mermaid-note:                  var(--frost3);
-    --mermaid-loopline:              var(--frost1);
-
-    --icon-color-hover:              var(--red);
-    --icon-color-focused:            var(--frost2);
-
-    --nav-item-color-hover:          var(--red);
-    --nav-item-color-active:         var(--frost2);
-    --nav-file-tag:                  rgba(var(--yellow_x), 0.9);
-
-    --graph-line:                    var(--dark3);
-    --graph-node:                    var(--light3);
-    --graph-node-tag:                var(--red);
-    --graph-node-attachment:         var(--green);
-
-    --calendar-hover:                var(--red);
-    --calendar-background-hover:     var(--dark3);
-    --calendar-week:                 var(--yellow);
-    --calendar-today:                var(--yellow);
-
-    --dataview-key:                  var(--text-faint);
-    --dataview-key-background:       rgba(var(--frost2_x), 0.3);
-    --dataview-value:                var(--text-faint);
-    --dataview-value-background:     rgba(var(--red_x), 0.3);
-
-    --tab-text-color-focused-active:         var(--frost2);
-    --tab-text-color-focused-active-current: var(--red);
-}
-
-.theme-light
-{
-    --color-red-rgb:                 var(--red_x);
-    --color-red:                     var(--red);
-    --color-purple-rgb:              var(--purple_x);
-    --color-purple:                  var(--purple);
-    --color-green-rgb:               var(--green_x);
-    --color-green:                   var(--green);
-    --color-cyan-rgb:                var(--frost1_x);
-    --color-cyan:                    var(--frost1);
-    --color-blue-rgb:                var(--frost3_x);
-    --color-blue:                    var(--frost3);
-    --color-yellow-rgb:              var(--yellow_x);
-    --color-yellow:                  var(--yellow);
-    --color-orange-rgb:              var(--orange_x);
-    --color-orange:                  var(--orange);
-    /* --color-pink:                    var(--purple); */
-
-    --background-primary:            var(--light3);
-    --background-primary-alt:        var(--light3);
-    --background-secondary:          var(--light2);
-    --background-secondary-alt:      var(--light1);
-    --background-modifier-border:    var(--light1);
-
-    --cursor-line-background:        rgba(var(--light0_x), 0.2);
-
-    --text-normal:                   var(--dark2);
-    --text-faint:                    var(--dark0);
-    --text-muted:                    var(--dark1);
-
-    --h1-color:                      var(--red);
-    --h2-color:                      var(--yellow);
-    --h3-color:                      var(--green);
-    --h4-color:                      var(--purple);
-    --h5-color:                      var(--frost0);
-    --h6-color:                      var(--frost2);
-
-    --text-highlight-bg:             var(--yellow);
-    --text-highlight-fg:             var(--dark0);
-
-    --text-accent:                   var(--orange);
-    --text-accent-hover:             var(--frost2);
-
-    --tag-color:                     var(--dark3);
-    --tag-background:                var(--light1);
-    --tag-background-hover:          var(--light0);
-
-    --titlebar-text-color-focused:   var(--red);
-
-    --inline-title-color:            var(--yellow);
-
-    --bold-color:                    var(--green);
-    --italic-color:                  var(--green);
-
-    --checkbox-color:                var(--frost2);
-    --checkbox-color-hover:          var(--frost2);
-    --checkbox-border-color:         var(--frost2);
-    --checkbox-border-color-hover:   var(--frost2);
-    --checklist-done-color:          rgba(var(--dark2_x), 0.4);
-
-    --table-header-background:       rgba(var(--light2_x), 0.2);
-    --table-header-background-hover: var(--frost2);
-    --table-row-even-background:     rgba(var(--light2_x), 0.4);
-    --table-row-odd-background:      rgba(var(--light2_x), 0.8);
-    --table-row-background-hover:    var(--frost2);
-
-    --text-selection:                rgba(var(--red_x), 0.6);
-    --flashing-background:           rgba(var(--red_x), 0.3);
-
-    --code-normal:                   var(--frost1);
-    --code-background:               var(--light2);
-
-    --mermaid-note:                  var(--frost0);
-    --mermaid-loopline:              var(--frost1);
-
-    --icon-color-hover:              var(--red);
-    --icon-color-focused:            var(--frost3);
-
-    --nav-item-color-hover:          var(--red);
-    --nav-item-color-active:         var(--frost2);
-    --nav-file-tag:                  rgba(var(--orange_x), 0.9);
-
-    --graph-line:                    var(--light0);
-    --graph-node:                    var(--dark3);
-    --graph-node-tag:                var(--red);
-    --graph-node-attachment:         var(--green);
-
-    --calendar-hover:                var(--red);
-    --calendar-background-hover:     var(--light0);
-    --calendar-week:                 var(--orange);
-    --calendar-today:                var(--orange);
-
-    --dataview-key:                  var(--text-faint);
-    --dataview-key-background:       rgba(var(--frost2_x), 0.3);
-    --dataview-value:                var(--text-faint);
-    --dataview-value-background:     rgba(var(--red_x), 0.3);
-
-    --tab-text-color-focused-active:         var(--frost2);
-    --tab-text-color-focused-active-current: var(--red);
-}
-
-table
-{
-    border: 1px solid var(--background-secondary) !important;
-    border-collapse: collapse;
-}
-
-thead
-{
-    border-bottom: 2px solid var(--background-modifier-border) !important;
-}
-  
-th
-{
-    font-weight: 600 !important;
-    border: 1px solid var(--background-secondary) !important;
-}
-
-td
-{
-    border-left: 1px solid var(--background-secondary) !important;
-    border-right: 1px solid var(--background-secondary) !important;
-    border-bottom: 1px solid var(--background-secondary) !important;
-}
-
-.markdown-rendered tbody tr:nth-child(even)
-{
-    background-color: var(--table-row-even-background) !important;
-}
-
-.markdown-rendered tbody tr:nth-child(odd)
-{
-    background-color: var(--table-row-odd-background) !important;
-}
-
-.markdown-rendered tbody tr:nth-child(even):hover,
-.markdown-rendered tbody tr:nth-child(odd):hover
-{
-    background-color: var(--table-row-background-hover) !important;
-}
-
-.markdown-rendered mark
-{
-    background-color: var(--text-highlight-bg) !important;
-    color: var(--text-highlight-fg) !important;
-}
-
-.markdown-rendered mark a
-{
-    color: var(--red) !important;
-    font-weight: 600;
-}
-
-.search-result-file-matched-text
-{
-    color: var(--text-highlight-fg) !important;
-}
-
-.cm-hashtag-begin:hover, .cm-hashtag-end:hover
-{
-    color: var(--text-accent);
-    /* background-color: var(--tag-background-hover); */
-    text-decoration: underline;
-}
-
-input[type=checkbox]
-{
-    border: 1px solid var(--checkbox-color);
-}
-
-input[type=checkbox]:checked
-{
-    background-color: var(--checkbox-color);
-    box-shadow: inset 0 0 0 2px var(--background-primary);
-}
-
-input[type=checkbox]:checked:after
-{
-    display: none;
-}
-
-code[class*="language-"],
-pre[class*="language-"]
-{
-    line-height: var(--line-height-tight) !important;
-}
-
-/* Keep highlight/marks the same between viewer and editor. */
-.cm-highlight
-{
-    color: var(--text-highlight-fg) !important;
-}
-
-/* Keep inline code the same between viewer and editor. */
-.cm-inline-code
-{
-    border-radius: var(--radius-s);
-    font-size: var(--code-size);
-    padding: 0.1em 0.25em;
-}
-
-.cm-formatting-code + .cm-inline-code
-{
-    border-radius: 0;
-    padding: 0.1em 0;
-}
-
-.cm-formatting-code
-{
-    border-radius: var(--radius-s) 0 0 var(--radius-s);
-    padding: 0.1em 0 0.1em 0.25em;
-}
-
-.cm-inline-code + .cm-formatting-code
-{
-    border-radius: 0 var(--radius-s) var(--radius-s) 0;
-    padding: 0.1em 0.25em 0.1em 0;
-}
-
-/* Keep list bullet padding the same between viewer and editor. */
-.cm-formatting-list
-{
-    padding-right: 4px !important;
-}
-
-/*
- * Keep sub-list indenting the same between viewer and editor.
- * This assumes --list-indent is default at 2em.
- */
-/*
-.cm-indent 
-{
-    text-indent: 1em !important;
-}
-*/
-
-.mermaid .note
-{
-    fill: var(--mermaid-note) !important;
-}
-
-.calendar .week-num
-{
-    color: var(--calendar-week) !important;
-}
-
-.mermaid .loopLine
-{
-    stroke: var(--mermaid-loopline) !important;
-}
-
-.calendar .today
-{
-    color: var(--calendar-today) !important;
-}
-
-.calendar .week-num:hover,
-.calendar .day:hover
-{
-    color: var(--calendar-hover) !important;
-    background-color: var(--calendar-background-hover) !important;
-}
-
-.markdown-embed-title
-{
-    color: var(--yellow);
-    font-weight: 600 !important;
-}
-
-.cm-active
-{
-    background-color: var(--cursor-line-background) !important;
-}
-
-.nav-file-tag
-{
-    color: var(--nav-file-tag) !important;
-}
-
-.is-flashing
-{
-    background-color: var(--flashing-background) !important;
-}
-
-.dataview.inline-field-key
-{
-    border-top-left-radius: var(--radius-s);
-    border-bottom-left-radius: var(--radius-s);
-    padding-left: 4px;
-    font-family: var(--font-monospace);
-    font-size: var(--font-smaller);
-    color: var(--dataview-key) !important;
-    background-color: var(--dataview-key-background) !important;
-}
-
-.dataview.inline-field-value
-{
-    border-top-right-radius: var(--radius-s);
-    border-bottom-right-radius: var(--radius-s);
-    padding-right: 4px;
-    font-family: var(--font-monospace);
-    font-size: var(--font-smaller);
-    color: var(--dataview-value) !important;
-    background-color: var(--dataview-value-background) !important;
-}
-
-.suggestion-highlight
-{
-    color: var(--red);
-}
-
diff --git a/notes/.obsidian/workspace.json b/notes/.obsidian/workspace.json
deleted file mode 100644
index fba2aa501..000000000
--- a/notes/.obsidian/workspace.json
+++ /dev/null
@@ -1,141 +0,0 @@
-{
-  "main": {
-    "id": "97f003a5f0b78789",
-    "type": "split",
-    "children": [
-      {
-        "id": "f3ad6cc024488448",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "cf29b62c848afc44",
-            "type": "leaf",
-            "state": {
-              "type": "markdown",
-              "state": {
-                "file": "todo.md",
-                "mode": "source",
-                "source": false
-              }
-            }
-          }
-        ]
-      }
-    ],
-    "direction": "vertical"
-  },
-  "left": {
-    "id": "9de5fcab25317010",
-    "type": "split",
-    "children": [
-      {
-        "id": "8850d0757dea15d3",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "9bab4808c7193900",
-            "type": "leaf",
-            "state": {
-              "type": "file-explorer",
-              "state": {
-                "sortOrder": "alphabetical"
-              }
-            }
-          },
-          {
-            "id": "11745d7617ee5f50",
-            "type": "leaf",
-            "state": {
-              "type": "search",
-              "state": {
-                "query": "",
-                "matchingCase": false,
-                "explainSearch": false,
-                "collapseAll": false,
-                "extraContext": false,
-                "sortOrder": "alphabetical"
-              }
-            }
-          },
-          {
-            "id": "ca7652256bab275f",
-            "type": "leaf",
-            "state": {
-              "type": "starred",
-              "state": {}
-            }
-          }
-        ]
-      }
-    ],
-    "direction": "horizontal",
-    "width": 300
-  },
-  "right": {
-    "id": "f8bc473eca261d3a",
-    "type": "split",
-    "children": [
-      {
-        "id": "026984091d5dae53",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "7d581c5246a6ede3",
-            "type": "leaf",
-            "state": {
-              "type": "backlink",
-              "state": {
-                "file": "todo.md",
-                "collapseAll": false,
-                "extraContext": false,
-                "sortOrder": "alphabetical",
-                "showSearch": false,
-                "searchQuery": "",
-                "backlinkCollapsed": false,
-                "unlinkedCollapsed": true
-              }
-            }
-          },
-          {
-            "id": "bade530d0eaeca1d",
-            "type": "leaf",
-            "state": {
-              "type": "outgoing-link",
-              "state": {
-                "file": "todo.md",
-                "linksCollapsed": false,
-                "unlinkedCollapsed": true
-              }
-            }
-          },
-          {
-            "id": "ea6a50fe65d99537",
-            "type": "leaf",
-            "state": {
-              "type": "tag",
-              "state": {
-                "sortOrder": "frequency",
-                "useHierarchy": true
-              }
-            }
-          },
-          {
-            "id": "7eee52d0550d9885",
-            "type": "leaf",
-            "state": {
-              "type": "outline",
-              "state": {
-                "file": "todo.md"
-              }
-            }
-          }
-        ]
-      }
-    ],
-    "direction": "horizontal",
-    "width": 300,
-    "collapsed": true
-  },
-  "active": "cf29b62c848afc44",
-  "lastOpenFiles": []
-}
\ No newline at end of file
diff --git a/notes/todo.md b/notes/todo.md
deleted file mode 100644
index 3ecb96572..000000000
--- a/notes/todo.md
+++ /dev/null
@@ -1,116 +0,0 @@
-### Defines in expression position
-
-Define should not be allowed in an expression context, right now this is legal:
-```scheme
-(when (vector 1 2 3) (define x 10))
-```
-
-This shouldn't be allowed, otherwise we're gonna run into a weird state.
-
-### Modules
-
-Modules are pretty busted as well. Because modules get shared at the top level, their requires also seem to get shared at the top level as well, for instance, see `steel/tests/modules/main.rkt` - b shows up at the top level even if b is not required. This is not what we want, it should have its own dedicated namespace thats not polluted.
-	- Modules _should_ be able to live on their own. We create one top level one, and each sub module should be able to access it independently, with proper namespacing. If every module just mangles their definitions with a module prefix, we should be in a good spot I think.
-
-The transformation should look like this:
-```scheme
-;; b-module.rkt
-(provide b)
-
-(define (b x) (+ x 27))
-(define (c x) (+ x 350))
-(define (b-private) "hi this is a private function change this part")
-```
-
-```scheme
-(provide b-module.rkt-b)
-
-(define b-module.rkt-b x (+ x 27))
-(define b-module.rkt-c x (+ x 350))
-(define (b-module.rkt-b-private) "hi this is a private function change this part")
-```
-
-Because then, from another module, we can require it like so:
-```scheme
-(require "b-module.rkt")
-
-(b 10)
-```
-
-Would expand to:
-
-```scheme
-(define b-module.rkt-b x (+ x 27))
-(define b-module.rkt-c x (+ x 350))
-(define (b-module.rkt-b-private) "hi this is a prvate function change this part")
-
-;; This creates a namespace that we can interact with
-(define __module-b-module.rkt 
-		(hash 'b b-module.rkt-b))
-
-;; Refresh the module definition in this namespace
-(define b (hash-get 'b b-module.rkt-b))
-```
-
-Now, lets say this is a module that exports stuff, something like this:
-
-```scheme
-;; a-module.rkt
-
-(require "b-module.rkt")
-(provide a)
-
-(define a (b 10))
-```
-
-Then requiring `a-module.rkt` would look like this:
-
-```scheme
-(require "a-module.rkt")
-```
-
-Expands to:
-
-```scheme
-;; Load in b-module
-(define b-module.rkt-b x (+ x 27))
-(define b-module.rkt-c x (+ x 350))
-(define (b-module.rkt-b-private) "hi this is a private function change this part")
-
-;; This creates a namespace that we can interact with
-(define __module-b-module.rkt 
-		(hash 'b b-module.rkt-b))
-
-;; Refresh the module definition in this namespace
-(define a-module.rkt-b (hash-get 'b __module-b-module.rkt))
-
-;; Mangled definition in the a module
-(define a-module.rkt-a (a-module.rkt-b 10))
-(define __module-a-module.rkt (hash 'a a-module.rkt-a))
-
-;; Set up the namespace for the top level module, wherever this is then
-(define a (hash-get 'a a-module.rkt-a))
-
-;; Do whatever we want with a...
-```
-
-### Transformations at the module boundary
-
-Now, we also want to provide the ability to apply transformations at the module level, take for instance something like this:
-
-```scheme
-(provide  
-	(contract-out [add-2 (->/c integer? integer? integer?)]))
-
-(define (add-2 x y) (+ x y))
-```
-
-We want this to actually apply the contract transformation explicitly at the module boundary - that way only modules that explicitly import this will see the contract applied here.
-
-
-### Constant folding of bytecode ops
-
-* So we can generate a trace, to not only create super instructions, but rather to just flatten the sequence of instructions
-* Even better, if we can constant fold some of the operations, that would be better, take for example something like this:
-
-<!-- https://www3.hhu.de/stups/downloads/pdf/BoCuFiRi09_246.pdf -->
diff --git a/r7rs-benchmarks/ack.scm b/r7rs-benchmarks/ack.scm
deleted file mode 100644
index 037f3a87d..000000000
--- a/r7rs-benchmarks/ack.scm
+++ /dev/null
@@ -1,44 +0,0 @@
-(define values list)
-(define (call-with-values producer consumer)
-  (define result (apply consumer (producer)))
-  (if (= (length result) 1) (car result) result))
-
-(define (hide r x)
-  (call-with-values (lambda () (values (vector values (lambda (x) x)) (if (< r 100) 0 1)))
-                    (lambda (v i) ((vector-ref v i) x))))
-
-(define (ack m n)
-  (cond
-    [(= m 0) (+ n 1)]
-    [(= n 0) (ack (- m 1) 1)]
-    [else (ack (- m 1) (ack m (- n 1)))]))
-
-; 2
-; 3
-; 12
-; 32765
-
-(define count 2)
-
-(let loop ([i 0])
-  ; (when (< i 1000000)
-  (when (< i count)
-    (begin
-      (equal? (ack (hide count 3) (hide count 12)) 32765)
-
-      (loop (+ i 1)))))
-
-; (define (run-benchmark)
-;   (let* ((count (read))
-;          (input1 (read))
-;          (input2 (read))
-;          (output (read))
-;          (s3 (number->string count))
-;          (s2 (number->string input2))
-;          (s1 (number->string input1))
-;          (name "ack"))
-;     (run-r7rs-benchmark
-;      (string-append name ":" s1 ":" s2 ":" s3)
-;      count
-;      (lambda () (ack (hide count input1) (hide count input2)))
-;      (lambda (result) (= result output)))))
diff --git a/r7rs-benchmarks/array1.scm b/r7rs-benchmarks/array1.scm
deleted file mode 100644
index 2919f366e..000000000
--- a/r7rs-benchmarks/array1.scm
+++ /dev/null
@@ -1,64 +0,0 @@
-(define-syntax do
-  (syntax-rules ()
-    [(do ((var init step ...) ...) (test expr ...) command ...)
-     (letrec* ([loop
-                (lambda (var ...)
-                  (if test
-                      (begin
-                        expr ...)
-                      (begin
-                        command ...
-                        (loop (do "step" var step ...) ...))))])
-              (loop init ...))]
-    [(do "step" x) x]
-    [(do "step" x y) y]))
-
-(define vector->list mutable-vector->list)
-(define vector-ref mut-vector-ref)
-(define vector-length mut-vec-len)
-; (define (make-vector n)
-;   (apply mutable-vector (map (lambda (x) 0) (range 0 n))))
-
-(define values list)
-(define (call-with-values producer consumer)
-  (define result (apply consumer (producer)))
-  (if (= (length result) 1) (car result) result))
-
-(define (hide r x)
-  (call-with-values (lambda () (values (vector values (lambda (x) x)) (if (< r 100) 0 1)))
-                    (lambda (v i) ((vector-ref v i) x))))
-
-(define (create-x n)
-  (define result (make-vector n))
-  (do ((i 0 (+ i 1))) ((>= i n) result) (vector-set! result i i)))
-
-(define (create-y x)
-  (let* ([n (vector-length x)] [result (make-vector n)])
-    (do ((i (- n 1) (- i 1))) ((< i 0) result) (vector-set! result i (vector-ref x i)))))
-
-(define (my-try n)
-  (vector-length (create-y (create-x n))))
-
-(define (go m n)
-  (let loop ([repeat m] [result '()])
-    (if (> repeat 0) (loop (- repeat 1) (my-try n)) result)))
-
-; (displayln (go 50 1000000))
-
-(displayln (go 1 1000))
-
-; 500
-; 1000000
-; 1000000
-
-; (define (run-benchmark)
-;   (let* ([count (read)]
-;          [input1 (read)]
-;          [output (read)]
-;          [s2 (number->string count)]
-;          [s1 (number->string input1)]
-;          [name "array1"])
-;     (run-r7rs-benchmark (string-append name ":" s1 ":" s2)
-;                         1
-;                         (lambda () (go (hide count count) (hide count input1)))
-;                         (lambda (result) (equal? result output)))))
diff --git a/r7rs-benchmarks/common.scm b/r7rs-benchmarks/common.scm
deleted file mode 100644
index 5411ac9bf..000000000
--- a/r7rs-benchmarks/common.scm
+++ /dev/null
@@ -1,86 +0,0 @@
-;;; The following code is appended to all benchmarks.
-
-; (define current-second current-seconds)
-; (define (jiffies-per-second)
-;   1000)
-; (define (current-jiffy)
-;   (llong->flonum (current-nanoseconds)))
-
-(require-builtin steel/time)
-
-; (define values list)
-; (define (call-with-values producer consumer)
-;   (define result (apply consumer (producer)))
-;   (if (= (length result) 1) (car result) result))
-
-(define (this-scheme-implementation-name)
-  "steel")
-
-(define (current-jiffy)
-  (current-milliseconds))
-
-(define (jiffies-per-second)
-  1000)
-
-(define (current-second)
-  (* 0.001 (current-inexact-milliseconds)))
-
-(define inexact exact->inexact)
-
-;;; Given an integer and an object, returns the object
-;;; without making it too easy for compilers to tell
-;;; the object will be returned.
-
-(define (hide r x)
-  (call-with-values (lambda () (values (vector values (lambda (x) x)) (if (< r 100) 0 1)))
-                    (lambda (v i) ((vector-ref v i) x))))
-
-;;; Given the name of a benchmark,
-;;; the number of times it should be executed,
-;;; a thunk that runs the benchmark once,
-;;; and a unary predicate that is true of the
-;;; correct results the thunk may return,
-;;; runs the benchmark for the number of specified iterations.
-
-(define (run-r7rs-benchmark name count thunk ok?)
-
-  ;; Rounds to thousandths.
-  (define (rounded x)
-    (/ (round (* 1000 x)) 1000))
-
-  (display "Running ")
-  (display name)
-  (newline)
-  (flush-output-port (current-output-port))
-  (let* ([j/s (jiffies-per-second)] [t0 (current-second)] [j0 (current-jiffy)])
-    (let loop ([i 0] [result #f])
-      (cond
-        [(< i count) (loop (+ i 1) (thunk))]
-        [(ok? result)
-         (let* ([j1 (current-jiffy)]
-                [t1 (current-second)]
-                [jifs (- j1 j0)]
-                [secs (inexact (/ jifs j/s))]
-                [secs2 (rounded (- t1 t0))])
-           (display "Elapsed time: ")
-           (write secs)
-           (display " seconds (")
-           (write secs2)
-           (display ") for ")
-           (display name)
-           (newline)
-           (display "+!CSVLINE!+")
-           (display (this-scheme-implementation-name))
-           (display ",")
-           (display name)
-           (display ",")
-           (display secs)
-           (newline)
-           (flush-output-port (current-output-port)))
-         0]
-        [else
-         (display "ERROR: returned incorrect result: ")
-         (write result)
-         (newline)
-         (flush-output-port (current-output-port))
-         0]))))
diff --git a/r7rs-benchmarks/cpstak.scm b/r7rs-benchmarks/cpstak.scm
deleted file mode 100644
index 019669ad1..000000000
--- a/r7rs-benchmarks/cpstak.scm
+++ /dev/null
@@ -1,20 +0,0 @@
-(define (cpstak x y z)
-
-  (define (tak x y z k)
-    (if (not (< y x))
-        (k z)
-        (tak (- x 1)
-             y
-             z
-             (lambda (v1)
-               (tak (- y 1) z x (lambda (v2) (tak (- z 1) x y (lambda (v3) (tak v1 v2 v3 k)))))))))
-
-  (tak x y z (lambda (a) a)))
-
-; 1
-; 40
-; 20
-; 11
-; 12
-
-(cpstak 40 20 11)
diff --git a/r7rs-benchmarks/ctak.scm b/r7rs-benchmarks/ctak.scm
deleted file mode 100644
index 684e0c054..000000000
--- a/r7rs-benchmarks/ctak.scm
+++ /dev/null
@@ -1,23 +0,0 @@
-;; TODO: This takes _way_ too long. Most likely need to optimize how call/cc works internally.
-
-(define (ctak x y z)
-  (#%prim.call-with-current-continuation (lambda (k) (ctak-aux k x y z))))
-
-(define (ctak-aux k x y z)
-  (if (not (< y x))
-      (k z)
-      (#%prim.call-with-current-continuation
-       (lambda (k)
-         (ctak-aux k
-                   (#%prim.call-with-current-continuation (lambda (k) (ctak-aux k (- x 1) y z)))
-                   (#%prim.call-with-current-continuation (lambda (k) (ctak-aux k (- y 1) z x)))
-                   (#%prim.call-with-current-continuation (lambda (k) (ctak-aux k (- z 1) x y))))))))
-
-; (ctak 27 20 11)
-(displayln (ctak 32 16 8))
-
-; 1
-; 32
-; 16
-; 8
-; 9
diff --git a/r7rs-benchmarks/equal.scm b/r7rs-benchmarks/equal.scm
deleted file mode 100644
index dbb6b9366..000000000
--- a/r7rs-benchmarks/equal.scm
+++ /dev/null
@@ -1,239 +0,0 @@
-(define (hide r x)
-  (call-with-values (lambda () (values (vector values (lambda (x) x)) (if (< r 100) 0 1)))
-                    (lambda (v i) ((vector-ref v i) x))))
-
-(define vector->list mutable-vector->list)
-(define list-tail drop)
-
-;; Returns a list with n elements, all equal to x.
-(define (make-test-list1 n x)
-  (if (zero? n) '() (cons x (make-test-list1 (- n 1) x))))
-
-;; Returns a list of n lists, each consisting of n x's.
-;; The n elements of the outer list are actually the same list.
-
-(define (make-test-tree1 n)
-  (if (zero? n) '() (make-test-list1 n (make-test-tree1 (- n 1)))))
-
-;; Returns a list of n elements, as returned by the thunk.
-
-(define (make-test-list2 n thunk)
-  ; (displayln "CALLING make-test-list2" n)
-  (if (zero? n) '() (cons (thunk) (make-test-list2 (- n 1) thunk))))
-
-;; Returns a balanced tree of height n, with the branching factor
-;; at each level equal to the height of the tree at that level.
-;; The subtrees do not share structure.
-
-(define (make-test-tree2 n)
-  ; (displayln "CALLING make-test-tree2" n)
-  (if (zero? n) '() (make-test-list2 n (lambda () (make-test-tree2 (- n 1))))))
-
-;; Returns an extremely unbalanced tree of height n.
-
-(define (make-test-tree5 n)
-  (if (zero? n) '() (cons (make-test-tree5 (- n 1)) 'a)))
-
-;; Calls the thunk n times.
-
-(define (iterate n thunk)
-  ; (displayln n)
-  (cond
-    [(= n 1) (thunk)]
-    [(> n 1)
-     (thunk)
-     (iterate (- n 1) thunk)]
-    [else #f]))
-
-;; A simple circular list is a worst case for R5RS equal?.
-
-; (define (equality-benchmark0 n)
-;   (let ([x (vector->list (make-vector n 'a))])
-;     (set-cdr! (list-tail x (- n 1)) x)
-;     (iterate n (hide n (lambda () (equal? x (cdr x)))))))
-
-;; DAG with much sharing.
-;; 10 is a good parameter for n.
-
-(define (equality-benchmark1 n)
-  (let ([x (make-test-tree1 n)] [y (make-test-tree1 n)])
-    (iterate n (hide n (lambda () (equal? x y))))))
-
-;; Tree with no sharing.
-;; 8 is a good parameter for n.
-
-(define (equality-benchmark2 n)
-  (let ([x (make-test-tree2 n)] [y (make-test-tree2 n)])
-    ; (displayln y)
-
-    (iterate n (hide n (lambda () (equal? x y))))))
-
-;; Flat vectors.
-;; 1000 might be a good parameter for n.
-
-(define (equality-benchmark3 n)
-  (let* ([x (make-vector n 'a)] [y (make-vector n 'a)])
-    (iterate n (hide n (lambda () (equal? x y))))))
-
-;; Shallow lists.
-;; 300 might be a good parameter for n.
-
-(define (equality-benchmark4 n)
-  (let* ([x (vector->list (make-vector n (make-test-tree2 3)))]
-         [y (vector->list (make-vector n (make-test-tree2 3)))])
-    (iterate n (hide n (lambda () (equal? x y))))))
-
-;; No sharing, no proper lists,
-;; and deep following car chains instead of cdr.
-
-(define (equality-benchmark5 n . rest)
-  (let* ([x (make-test-tree5 n)] [y (make-test-tree5 n)] [iterations (if (null? rest) n (car rest))])
-    (iterate iterations (hide n (lambda () (equal? x y))))))
-
-;; A shorter form of the benchmark above.
-
-(define (equality-benchmark5short n)
-  (equality-benchmark5 n 100))
-
-(define (equality-benchmarks n0 n1 n2 n3 n4 n5)
-  (and ; (equality-benchmark0 n0) ;; cyclic benchmark does not work on most non-R7RS schemes
-   (equality-benchmark1 n1)
-   (equality-benchmark2 n2)
-   (equality-benchmark3 n3)
-   (equality-benchmark4 n4)
-   (equality-benchmark5 n5)))
-
-; 100
-; 100
-; 8
-; 1000
-; 2000
-; 5000
-; #t
-
-;; Actual test
-; (equality-benchmarks 100 100 8 1000 2000 5000)
-
-;; For test suite
-
-; (equality-benchmarks 10 10 3 100 200 500)
-
-(define (run-benchmark)
-  (let* ([input0 (read)]
-         [input1 (read)]
-         [input2 (read)]
-         [input3 (read)]
-         [input4 (read)]
-         [input5 (read)]
-         [output (read)]
-         [s5 (number->string input5)]
-         [s4 (number->string input4)]
-         [s3 (number->string input3)]
-         [s2 (number->string input2)]
-         [s1 (number->string input1)]
-         [s0 (number->string input0)]
-         [name "equal"])
-    (run-r7rs-benchmark (string-append name ":" s0 ":" s1 ":" s2 ":" s3 ":" s4 ":" s5)
-                        1
-                        (lambda ()
-                          (equality-benchmarks (hide input0 input0)
-                                               (hide input0 input1)
-                                               (hide input0 input2)
-                                               (hide input0 input3)
-                                               (hide input0 input4)
-                                               (hide input0 input5)))
-                        (lambda (result) (eq? result #t)))))
-
-(require-builtin steel/time)
-
-; (define values list)
-; (define (call-with-values producer consumer)
-;   (define result (apply consumer (producer)))
-;   (if (= (length result) 1) (car result) result))
-
-(define (this-scheme-implementation-name)
-  "steel")
-
-(define (current-jiffy)
-  (current-milliseconds))
-
-(define (jiffies-per-second)
-  1000)
-
-(define (current-second)
-  (* 0.001 (current-inexact-milliseconds)))
-
-(define inexact exact->inexact)
-
-;;; Given an integer and an object, returns the object
-;;; without making it too easy for compilers to tell
-;;; the object will be returned.
-
-(define (hide r x)
-  (call-with-values (lambda () (values (vector values (lambda (x) x)) (if (< r 100) 0 1)))
-                    (lambda (v i) ((vector-ref v i) x))))
-
-;;; Given the name of a benchmark,
-;;; the number of times it should be executed,
-;;; a thunk that runs the benchmark once,
-;;; and a unary predicate that is true of the
-;;; correct results the thunk may return,
-;;; runs the benchmark for the number of specified iterations.
-
-(define (run-r7rs-benchmark name count thunk ok?)
-
-  ;; Rounds to thousandths.
-  (define (rounded x)
-    (/ (round (* 1000 x)) 1000))
-
-  (display "Running ")
-  (display name)
-  (newline)
-  (flush-output-port (current-output-port))
-  (let* ([j/s (jiffies-per-second)] [t0 (current-second)] [j0 (current-jiffy)])
-    (let loop ([i 0] [result #f])
-      (cond
-        [(< i count) (loop (+ i 1) (thunk))]
-        [(ok? result)
-         (let* ([j1 (current-jiffy)]
-                [t1 (current-second)]
-                [jifs (- j1 j0)]
-                [secs (inexact (/ jifs j/s))]
-                [secs2 (rounded (- t1 t0))])
-           (display "Elapsed time: ")
-           ; (write secs)
-           (display secs)
-           (display " seconds (")
-           ; (write secs2)
-           (display secs2)
-           (display ") for ")
-           (display name)
-           (newline)
-           (display "+!CSVLINE!+")
-           (display (this-scheme-implementation-name))
-           (display ",")
-           (display name)
-           (display ",")
-           (display secs)
-           (newline)
-           (flush-output-port (current-output-port)))
-         0]
-        [else
-         (display "ERROR: returned incorrect result: ")
-         (write result)
-         (newline)
-         (flush-output-port (current-output-port))
-         0]))))
-
-;; Run the bench!
-(parameterize ([current-input-port (open-input-file "r7rs-benchmarks/inputs/equal.input")])
-
-  ; (displayln (read))
-  ; (displayln (read))
-  ; (displayln (read))
-  ; (displayln (read))
-  ; (displayln (read))
-
-  ; (read)
-
-  (run-benchmark))
diff --git a/r7rs-benchmarks/inputs/equal.input b/r7rs-benchmarks/inputs/equal.input
deleted file mode 100644
index c893d4853..000000000
--- a/r7rs-benchmarks/inputs/equal.input
+++ /dev/null
@@ -1,7 +0,0 @@
-100
-100
-8
-1000
-2000
-5000
-#t
diff --git a/r7rs-benchmarks/scheme.scm b/r7rs-benchmarks/scheme.scm
deleted file mode 100644
index 3c1965c83..000000000
--- a/r7rs-benchmarks/scheme.scm
+++ /dev/null
@@ -1,1134 +0,0 @@
-;;; SCHEME -- A Scheme interpreter evaluating a sort, written by Marc Feeley.
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-; (import (scheme base)
-;         (scheme cxr)
-;         (scheme inexact)
-;         (scheme char)
-;         (scheme file)
-;         (scheme read)
-;         (scheme write)
-;         (scheme time))
-
-; (require "steel/mutable-vectors")
-
-(define member
-  (lambda (x los)
-    ; (displayln "Calling member")
-    (cond
-      [(null? los) #f]
-      ; (begin
-      ; (displayln los)
-      [(equal? x (car los)) los]
-      [else (member x (cdr los))])))
-
-;; Compatibility -----------------------------------------------------------
-(define assq assoc)
-(define assv assoc)
-(define memq member)
-(define memv member)
-(define eq? equal?)
-
-; (define vector-set! mutable-vector-set!)
-(define vector-ref mut-vector-ref)
-(define vector mutable-vector)
-(define (make-vector n)
-  (apply mutable-vector (map (lambda (x) 0) (range 0 n))))
-
-;; --------------------------------------------------------------------------
-
-(define scheme-global-environment
-  (cons '() ;; environment chain
-        '())) ;; macros
-
-(define (scheme-eval expr)
-  (let ([code (scheme-comp expr scheme-global-environment)]) (code #f)))
-
-; (define (scheme-add-macro name proc)
-;   (set-cdr! scheme-global-environment (cons (cons name proc) (cdr scheme-global-environment)))
-;   name)
-
-(define (scheme-add-macro name proc)
-  (set! scheme-global-environment
-        (cons (car scheme-global-environment)
-              (cons (cons name proc) (cdr scheme-global-environment)))))
-
-(define (scheme-error msg . args)
-  (error #f msg args))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (lst->vector l)
-  (let* ([n (length l)] [v (make-vector n)])
-    (let loop ([l l] [i 0])
-      (if (pair? l)
-          (begin
-            (vector-set! v i (car l))
-            (loop (cdr l) (+ i 1)))
-          v))))
-
-(define (vector->lst v)
-  (let loop ([l '()] [i (- (vector-length v) 1)])
-    (if (< i 0) l (loop (cons (vector-ref v i) l) (- i 1)))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define scheme-syntactic-keywords
-  '(quote quasiquote
-          unquote
-          unquote-splicing
-          lambda
-          if
-          set!
-          cond
-          =>
-          else
-          and
-          or
-          case
-          let
-          let*
-          letrec
-          begin
-          do
-          define
-          define-macro))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (push-frame frame env)
-  (if (null? frame) env (cons (cons (car env) frame) (cdr env))))
-
-(define (lookup-var name env)
-  (let loop1 ([chain (car env)] [up 0])
-    (if (null? chain)
-        name
-        (let loop2 ([chain chain] [up up] [frame (cdr chain)] [over 1])
-          (cond
-            [(null? frame) (loop1 (car chain) (+ up 1))]
-            [(eq? (car frame) name) (cons up over)]
-            [else (loop2 chain up (cdr frame) (+ over 1))])))))
-
-(define (macro? name env)
-  (assq name (cdr env)))
-
-(define (push-macro name proc env)
-  (cons (car env) (cons (cons name proc) (cdr env))))
-
-(define (lookup-macro name env)
-  (cdr (assq name (cdr env))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (variable x)
-  (unless (symbol? x)
-    (scheme-error "Identifier expected" x))
-  (when (memq x scheme-syntactic-keywords)
-    (scheme-error "Variable name can not be a syntactic keyword" x)))
-
-(define (shape form n)
-  (let loop ([form form] [n n] [l form])
-    (cond
-      [(<= n 0)]
-      [(pair? l) (loop form (- n 1) (cdr l))]
-      [else (scheme-error "Ill-constructed form" form)])))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (macro-expand expr env)
-  (apply (lookup-macro (car expr) env) (cdr expr)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-var expr env)
-  (variable expr)
-  (gen-var-ref (lookup-var expr env)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-self-eval expr env)
-  (gen-cst expr))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-quote expr env)
-  (shape expr 2)
-  (gen-cst (cadr expr)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-quasiquote expr env)
-  (comp-quasiquotation (cadr expr) 1 env))
-
-(define (comp-quasiquotation form level env)
-  (cond
-    [(= level 0) (scheme-comp form env)]
-    [(pair? form)
-     (cond
-       [(eq? (car form) 'quasiquote) (comp-quasiquotation-list form (+ level 1) env)]
-       [(eq? (car form) 'unquote)
-        (if (= level 1)
-            (scheme-comp (cadr form) env)
-            (comp-quasiquotation-list form (- level 1) env))]
-       [(eq? (car form) 'unquote-splicing)
-        (when (= level 1)
-          (scheme-error "Ill-placed 'unquote-splicing'" form))
-        (comp-quasiquotation-list form (- level 1) env)]
-       [else (comp-quasiquotation-list form level env)])]
-    [(vector? form) (gen-vector-form (comp-quasiquotation-list (vector->lst form) level env))]
-    [else (gen-cst form)]))
-
-(define (comp-quasiquotation-list l level env)
-  (if (pair? l)
-      (let ([first (car l)])
-        (if (= level 1)
-            (if (unquote-splicing? first)
-                (begin
-                  (shape first 2)
-                  (gen-append-form (scheme-comp (cadr first) env)
-                                   (comp-quasiquotation (cdr l) 1 env)))
-                (gen-cons-form (comp-quasiquotation first level env)
-                               (comp-quasiquotation (cdr l) level env)))
-            (gen-cons-form (comp-quasiquotation first level env)
-                           (comp-quasiquotation (cdr l) level env))))
-      (comp-quasiquotation l level env)))
-
-(define (unquote-splicing? x)
-  (if (pair? x) (if (eq? (car x) 'unquote-splicing) #t #f) #f))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-unquote expr env)
-  (scheme-error "Ill-placed 'unquote'" expr))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-unquote-splicing expr env)
-  (scheme-error "Ill-placed 'unquote-splicing'" expr))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-set! expr env)
-  (shape expr 3)
-  (variable (cadr expr))
-  (gen-var-set (lookup-var (cadr expr) env) (scheme-comp (caddr expr) env)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-lambda expr env)
-  (shape expr 3)
-  (let ([parms (cadr expr)])
-    (let ([frame (parms->frame parms)])
-      (let ([nb-vars (length frame)] [code (comp-body (cddr expr) (push-frame frame env))])
-        (if (rest-param? parms) (gen-lambda-rest nb-vars code) (gen-lambda nb-vars code))))))
-
-(define (parms->frame parms)
-  (cond
-    [(null? parms) '()]
-    [(pair? parms)
-     (let ([x (car parms)])
-       (variable x)
-       (cons x (parms->frame (cdr parms))))]
-    [else
-     (variable parms)
-     (list parms)]))
-
-(define (rest-param? parms)
-  (cond
-    [(pair? parms) (rest-param? (cdr parms))]
-    [(null? parms) #f]
-    [else #t]))
-
-(define (comp-body body env)
-
-  (define (letrec-defines vars vals body env)
-    (if (pair? body)
-
-        (let ([expr (car body)])
-          (cond
-            [(not (pair? expr)) (letrec-defines* vars vals body env)]
-            [(macro? (car expr) env)
-             (letrec-defines vars vals (cons (macro-expand expr env) (cdr body)) env)]
-            [else
-             (cond
-               [(eq? (car expr) 'begin) (letrec-defines vars vals (append (cdr expr) (cdr body)) env)]
-               [(eq? (car expr) 'define)
-                (let ([x (definition-name expr)])
-                  (variable x)
-                  (letrec-defines (cons x vars) (cons (definition-value expr) vals) (cdr body) env))]
-               [(eq? (car expr) 'define-macro)
-                (let ([x (definition-name expr)])
-                  (letrec-defines vars
-                                  vals
-                                  (cdr body)
-                                  (push-macro x (scheme-eval (definition-value expr)) env)))]
-               [else (letrec-defines* vars vals body env)])]))
-
-        (scheme-error "Body must contain at least one evaluable expression")))
-
-  (define (letrec-defines* vars vals body env)
-    (if (null? vars) (comp-sequence body env) (comp-letrec-aux vars vals body env)))
-
-  (letrec-defines '() '() body env))
-
-(define (definition-name expr)
-  (shape expr 3)
-  (let ([pattern (cadr expr)])
-    (let ([name (if (pair? pattern) (car pattern) pattern)])
-      (unless (symbol? name)
-        (scheme-error "Identifier expected" name))
-      name)))
-
-(define (definition-value expr)
-  (let ([pattern (cadr expr)])
-    (if (pair? pattern) (cons 'lambda (cons (cdr pattern) (cddr expr))) (caddr expr))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-if expr env)
-  (shape expr 3)
-  (let ([code1 (scheme-comp (cadr expr) env)] [code2 (scheme-comp (caddr expr) env)])
-    (if (pair? (cdddr expr))
-        (gen-if code1 code2 (scheme-comp (cadddr expr) env))
-        (gen-when code1 code2))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-cond expr env)
-  (comp-cond-aux (cdr expr) env))
-
-(define (comp-cond-aux clauses env)
-  (if (pair? clauses)
-      (let ([clause (car clauses)])
-        (shape clause 1)
-        (cond
-          [(eq? (car clause) 'else)
-           (shape clause 2)
-           (comp-sequence (cdr clause) env)]
-          [(not (pair? (cdr clause)))
-           (gen-or (scheme-comp (car clause) env) (comp-cond-aux (cdr clauses) env))]
-          [(eq? (cadr clause) '=>)
-           (shape clause 3)
-           (gen-cond-send (scheme-comp (car clause) env)
-                          (scheme-comp (caddr clause) env)
-                          (comp-cond-aux (cdr clauses) env))]
-          [else
-           (gen-if (scheme-comp (car clause) env)
-                   (comp-sequence (cdr clause) env)
-                   (comp-cond-aux (cdr clauses) env))]))
-      (gen-cst '())))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-and expr env)
-  (let ([rest (cdr expr)]) (if (pair? rest) (comp-and-aux rest env) (gen-cst #t))))
-
-(define (comp-and-aux l env)
-  (let ([code (scheme-comp (car l) env)] [rest (cdr l)])
-    (if (pair? rest) (gen-and code (comp-and-aux rest env)) code)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-or expr env)
-  (let ([rest (cdr expr)]) (if (pair? rest) (comp-or-aux rest env) (gen-cst #f))))
-
-(define (comp-or-aux l env)
-  (let ([code (scheme-comp (car l) env)] [rest (cdr l)])
-    (if (pair? rest) (gen-or code (comp-or-aux rest env)) code)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-case expr env)
-  (shape expr 3)
-  (gen-case (scheme-comp (cadr expr) env) (comp-case-aux (cddr expr) env)))
-
-(define (comp-case-aux clauses env)
-  (if (pair? clauses)
-      (let ([clause (car clauses)])
-        (shape clause 2)
-        (if (eq? (car clause) 'else)
-            (gen-case-else (comp-sequence (cdr clause) env))
-            (gen-case-clause (car clause)
-                             (comp-sequence (cdr clause) env)
-                             (comp-case-aux (cdr clauses) env))))
-      (gen-case-else (gen-cst '()))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-let expr env)
-  (shape expr 3)
-  (let ([x (cadr expr)])
-    (cond
-      [(symbol? x)
-       (shape expr 4)
-       (let ([y (caddr expr)])
-         (let ([proc (cons 'lambda (cons (bindings->vars y) (cdddr expr)))])
-           (scheme-comp (cons (list 'letrec (list (list x proc)) x) (bindings->vals y)) env)))]
-      [(pair? x)
-       (scheme-comp (cons (cons 'lambda (cons (bindings->vars x) (cddr expr))) (bindings->vals x))
-                    env)]
-      [else (comp-body (cddr expr) env)])))
-
-(define (bindings->vars bindings)
-  (if (pair? bindings)
-      (let ([binding (car bindings)])
-        (shape binding 2)
-        (let ([x (car binding)])
-          (variable x)
-          (cons x (bindings->vars (cdr bindings)))))
-      '()))
-
-(define (bindings->vals bindings)
-  (if (pair? bindings)
-      (let ([binding (car bindings)]) (cons (cadr binding) (bindings->vals (cdr bindings))))
-      '()))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-let* expr env)
-  (shape expr 3)
-  (let ([bindings (cadr expr)])
-    (if (pair? bindings)
-        (scheme-comp (list 'let (list (car bindings)) (cons 'let* (cons (cdr bindings) (cddr expr))))
-                     env)
-        (comp-body (cddr expr) env))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-letrec expr env)
-  (shape expr 3)
-  (let ([bindings (cadr expr)])
-    (comp-letrec-aux (bindings->vars bindings) (bindings->vals bindings) (cddr expr) env)))
-
-(define (comp-letrec-aux vars vals body env)
-  (if (pair? vars)
-      (let ([new-env (push-frame vars env)])
-        (gen-letrec (comp-vals vals new-env) (comp-body body new-env)))
-      (comp-body body env)))
-
-(define (comp-vals l env)
-  (if (pair? l) (cons (scheme-comp (car l) env) (comp-vals (cdr l) env)) '()))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-begin expr env)
-  (shape expr 2)
-  (comp-sequence (cdr expr) env))
-
-(define (comp-sequence exprs env)
-  (if (pair? exprs) (comp-sequence-aux exprs env) (gen-cst '())))
-
-(define (comp-sequence-aux exprs env)
-  (let ([code (scheme-comp (car exprs) env)] [rest (cdr exprs)])
-    (if (pair? rest) (gen-sequence code (comp-sequence-aux rest env)) code)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-do expr env)
-  (shape expr 3)
-  (let ([bindings (cadr expr)] [exit (caddr expr)])
-    (shape exit 1)
-    (let* ([vars (bindings->vars bindings)]
-           [new-env1 (push-frame '(#f) env)]
-           [new-env2 (push-frame vars new-env1)])
-      (gen-letrec
-       (list (gen-lambda (length vars)
-                         (gen-if (scheme-comp (car exit) new-env2)
-                                 (comp-sequence (cdr exit) new-env2)
-                                 (gen-sequence (comp-sequence (cdddr expr) new-env2)
-                                               (gen-combination (gen-var-ref '(1 . 1))
-                                                                (comp-vals (bindings->steps bindings)
-                                                                           new-env2))))))
-       (gen-combination (gen-var-ref '(0 . 1)) (comp-vals (bindings->vals bindings) new-env1))))))
-
-(define (bindings->steps bindings)
-  (if (pair? bindings)
-      (let ([binding (car bindings)])
-        (cons (if (pair? (cddr binding)) (caddr binding) (car binding))
-              (bindings->steps (cdr bindings))))
-      '()))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-define expr env)
-  (shape expr 3)
-  (let ([pattern (cadr expr)])
-    (let ([x (if (pair? pattern) (car pattern) pattern)])
-      (variable x)
-      (gen-sequence (gen-var-set (lookup-var x env)
-                                 (scheme-comp (if (pair? pattern)
-                                                  (cons 'lambda (cons (cdr pattern) (cddr expr)))
-                                                  (caddr expr))
-                                              env))
-                    (gen-cst x)))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-define-macro expr env)
-  (let ([x (definition-name expr)]) (gen-macro x (scheme-eval (definition-value expr)))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (comp-combination expr env)
-  (gen-combination (scheme-comp (car expr) env) (comp-vals (cdr expr) env)))
-
-;;------------------------------------------------------------------------------
-
-(define (gen-var-ref var)
-  (if (pair? var) (gen-rte-ref (car var) (cdr var)) (gen-glo-ref (scheme-global-var var))))
-
-(define (gen-rte-ref up over)
-  (case up
-    [(0) (gen-slot-ref-0 over)]
-    [(1) (gen-slot-ref-1 over)]
-    [else (gen-slot-ref-up-2 (gen-rte-ref (- up 2) over))]))
-
-(define (gen-slot-ref-0 i)
-  (case i
-    [(0) (lambda (rte) (vector-ref rte 0))]
-    [(1) (lambda (rte) (vector-ref rte 1))]
-    [(2) (lambda (rte) (vector-ref rte 2))]
-    [(3) (lambda (rte) (vector-ref rte 3))]
-    [else (lambda (rte) (vector-ref rte i))]))
-
-(define (gen-slot-ref-1 i)
-  (case i
-    [(0) (lambda (rte) (vector-ref (vector-ref rte 0) 0))]
-    [(1) (lambda (rte) (vector-ref (vector-ref rte 0) 1))]
-    [(2) (lambda (rte) (vector-ref (vector-ref rte 0) 2))]
-    [(3) (lambda (rte) (vector-ref (vector-ref rte 0) 3))]
-    [else (lambda (rte) (vector-ref (vector-ref rte 0) i))]))
-
-(define (gen-slot-ref-up-2 code)
-  (lambda (rte) (code (vector-ref (vector-ref rte 0) 0))))
-
-(define (gen-glo-ref i)
-  (lambda (rte) (scheme-global-var-ref i)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-cst val)
-  (case val
-    [(()) (lambda (rte) '())]
-    [(#f) (lambda (rte) #f)]
-    [(#t) (lambda (rte) #t)]
-    [(-2) (lambda (rte) -2)]
-    [(-1) (lambda (rte) -1)]
-    [(0) (lambda (rte) 0)]
-    [(1) (lambda (rte) 1)]
-    [(2) (lambda (rte) 2)]
-    [else (lambda (rte) val)]))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-append-form code1 code2)
-  (lambda (rte) (append (code1 rte) (code2 rte))))
-
-(define (gen-cons-form code1 code2)
-  (lambda (rte) (cons (code1 rte) (code2 rte))))
-
-(define (gen-vector-form code)
-  (lambda (rte) (lst->vector (code rte))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-var-set var code)
-  (if (pair? var) (gen-rte-set (car var) (cdr var) code) (gen-glo-set (scheme-global-var var) code)))
-
-(define (gen-rte-set up over code)
-  (case up
-    [(0) (gen-slot-set-0 over code)]
-    [(1) (gen-slot-set-1 over code)]
-    [else (gen-slot-set-n (gen-rte-ref (- up 2) 0) over code)]))
-
-(define (gen-slot-set-0 i code)
-  (case i
-    [(0) (lambda (rte) (vector-set! rte 0 (code rte)))]
-    [(1) (lambda (rte) (vector-set! rte 1 (code rte)))]
-    [(2) (lambda (rte) (vector-set! rte 2 (code rte)))]
-    [(3) (lambda (rte) (vector-set! rte 3 (code rte)))]
-    [else (lambda (rte) (vector-set! rte i (code rte)))]))
-
-(define (gen-slot-set-1 i code)
-  (case i
-    [(0) (lambda (rte) (vector-set! (vector-ref rte 0) 0 (code rte)))]
-    [(1) (lambda (rte) (vector-set! (vector-ref rte 0) 1 (code rte)))]
-    [(2) (lambda (rte) (vector-set! (vector-ref rte 0) 2 (code rte)))]
-    [(3) (lambda (rte) (vector-set! (vector-ref rte 0) 3 (code rte)))]
-    [else (lambda (rte) (vector-set! (vector-ref rte 0) i (code rte)))]))
-
-(define (gen-slot-set-n up i code)
-  (case i
-    [(0) (lambda (rte) (vector-set! (up (vector-ref rte 0)) 0 (code rte)))]
-    [(1) (lambda (rte) (vector-set! (up (vector-ref rte 0)) 1 (code rte)))]
-    [(2) (lambda (rte) (vector-set! (up (vector-ref rte 0)) 2 (code rte)))]
-    [(3) (lambda (rte) (vector-set! (up (vector-ref rte 0)) 3 (code rte)))]
-    [else (lambda (rte) (vector-set! (up (vector-ref rte 0)) i (code rte)))]))
-
-(define (gen-glo-set i code)
-  (lambda (rte) (scheme-global-var-set! i (code rte))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-lambda-rest nb-vars body)
-  (case nb-vars
-    [(1) (gen-lambda-1-rest body)]
-    [(2) (gen-lambda-2-rest body)]
-    [(3) (gen-lambda-3-rest body)]
-    [else (gen-lambda-n-rest nb-vars body)]))
-
-(define (gen-lambda-1-rest body)
-  (lambda (rte) (lambda a (body (vector rte a)))))
-
-(define (gen-lambda-2-rest body)
-  (lambda (rte) (lambda (a . b) (body (vector rte a b)))))
-
-(define (gen-lambda-3-rest body)
-  (lambda (rte) (lambda (a b . c) (body (vector rte a b c)))))
-
-(define (gen-lambda-n-rest nb-vars body)
-  (lambda (rte)
-    (lambda (a b c . d)
-      (let ([x (make-vector (+ nb-vars 1))])
-        (vector-set! x 0 rte)
-        (vector-set! x 1 a)
-        (vector-set! x 2 b)
-        (vector-set! x 3 c)
-        (let loop ([n nb-vars] [x x] [i 4] [l d])
-          (if (< i n)
-              (begin
-                (vector-set! x i (car l))
-                (loop n x (+ i 1) (cdr l)))
-              (vector-set! x i l)))
-        (body x)))))
-
-(define (gen-lambda nb-vars body)
-  (case nb-vars
-    [(0) (gen-lambda-0 body)]
-    [(1) (gen-lambda-1 body)]
-    [(2) (gen-lambda-2 body)]
-    [(3) (gen-lambda-3 body)]
-    [else (gen-lambda-n nb-vars body)]))
-
-(define (gen-lambda-0 body)
-  (lambda (rte) (lambda () (body rte))))
-
-(define (gen-lambda-1 body)
-  (lambda (rte) (lambda (a) (body (vector rte a)))))
-
-(define (gen-lambda-2 body)
-  (lambda (rte) (lambda (a b) (body (vector rte a b)))))
-
-(define (gen-lambda-3 body)
-  (lambda (rte) (lambda (a b c) (body (vector rte a b c)))))
-
-(define (gen-lambda-n nb-vars body)
-  (lambda (rte)
-    (lambda (a b c . d)
-      (let ([x (make-vector (+ nb-vars 1))])
-        (vector-set! x 0 rte)
-        (vector-set! x 1 a)
-        (vector-set! x 2 b)
-        (vector-set! x 3 c)
-        (let loop ([n nb-vars] [x x] [i 4] [l d])
-          (when (<= i n)
-            (vector-set! x i (car l))
-            (loop n x (+ i 1) (cdr l))))
-        (body x)))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-sequence code1 code2)
-  (lambda (rte)
-    (code1 rte)
-    (code2 rte)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-when code1 code2)
-  (lambda (rte) (if (code1 rte) (code2 rte) '())))
-
-(define (gen-if code1 code2 code3)
-  (lambda (rte) (if (code1 rte) (code2 rte) (code3 rte))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-cond-send code1 code2 code3)
-  (lambda (rte) (let ([temp (code1 rte)]) (if temp ((code2 rte) temp) (code3 rte)))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-and code1 code2)
-  (lambda (rte) (let ([temp (code1 rte)]) (if temp (code2 rte) temp))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-or code1 code2)
-  (lambda (rte) (let ([temp (code1 rte)]) (if temp temp (code2 rte)))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-case code1 code2)
-  (lambda (rte) (code2 rte (code1 rte))))
-
-(define (gen-case-clause datums code1 code2)
-  (lambda (rte key) (if (memv key datums) (code1 rte) (code2 rte key))))
-
-(define (gen-case-else code)
-  (lambda (rte key) (code rte)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-letrec vals body)
-  (let ([nb-vals (length vals)])
-    (case nb-vals
-      [(1) (gen-letrec-1 (car vals) body)]
-      [(2) (gen-letrec-2 (car vals) (cadr vals) body)]
-      [(3) (gen-letrec-3 (car vals) (cadr vals) (caddr vals) body)]
-      [else (gen-letrec-n nb-vals vals body)])))
-
-(define (gen-letrec-1 val1 body)
-  (lambda (rte)
-    (let ([x (vector rte #f)])
-      (vector-set! x 1 (val1 x))
-      (body x))))
-
-(define (gen-letrec-2 val1 val2 body)
-  (lambda (rte)
-    (let ([x (vector rte #f #f)])
-      (vector-set! x 1 (val1 x))
-      (vector-set! x 2 (val2 x))
-      (body x))))
-
-(define (gen-letrec-3 val1 val2 val3 body)
-  (lambda (rte)
-    (let ([x (vector rte #f #f #f)])
-      (vector-set! x 1 (val1 x))
-      (vector-set! x 2 (val2 x))
-      (vector-set! x 3 (val3 x))
-      (body x))))
-
-(define (gen-letrec-n nb-vals vals body)
-  (lambda (rte)
-    (let ([x (make-vector (+ nb-vals 1))])
-      (vector-set! x 0 rte)
-      (let loop ([x x] [i 1] [l vals])
-        (when (pair? l)
-          (vector-set! x i ((car l) x))
-          (loop x (+ i 1) (cdr l))))
-      (body x))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-macro name proc)
-  (lambda (rte) (scheme-add-macro name proc)))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (gen-combination oper args)
-  (case (length args)
-    [(0) (gen-combination-0 oper)]
-    [(1) (gen-combination-1 oper (car args))]
-    [(2) (gen-combination-2 oper (car args) (cadr args))]
-    [(3) (gen-combination-3 oper (car args) (cadr args) (caddr args))]
-    [else (gen-combination-n oper args)]))
-
-(define (gen-combination-0 oper)
-  (lambda (rte) ((oper rte))))
-
-(define (gen-combination-1 oper arg1)
-  (lambda (rte) ((oper rte) (arg1 rte))))
-
-(define (gen-combination-2 oper arg1 arg2)
-  (lambda (rte) ((oper rte) (arg1 rte) (arg2 rte))))
-
-(define (gen-combination-3 oper arg1 arg2 arg3)
-  (lambda (rte) ((oper rte) (arg1 rte) (arg2 rte) (arg3 rte))))
-
-(define (gen-combination-n oper args)
-  (lambda (rte)
-    (define (evaluate l rte)
-      (if (pair? l) (cons ((car l) rte) (evaluate (cdr l) rte)) '()))
-    (apply (oper rte) (evaluate args rte))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define (scheme-comp expr env)
-  (cond
-    [(symbol? expr) (comp-var expr env)]
-    [(not (pair? expr)) (comp-self-eval expr env)]
-    [(macro? (car expr) env) (scheme-comp (macro-expand expr env) env)]
-    [else
-     (cond
-       [(eq? (car expr) 'quote) (comp-quote expr env)]
-       [(eq? (car expr) 'quasiquote) (comp-quasiquote expr env)]
-       [(eq? (car expr) 'unquote) (comp-unquote expr env)]
-       [(eq? (car expr) 'unquote-splicing) (comp-unquote-splicing expr env)]
-       [(eq? (car expr) 'set!) (comp-set! expr env)]
-       [(eq? (car expr) 'lambda) (comp-lambda expr env)]
-       [(eq? (car expr) 'if) (comp-if expr env)]
-       [(eq? (car expr) 'cond) (comp-cond expr env)]
-       [(eq? (car expr) 'and) (comp-and expr env)]
-       [(eq? (car expr) 'or) (comp-or expr env)]
-       [(eq? (car expr) 'case) (comp-case expr env)]
-       [(eq? (car expr) 'let) (comp-let expr env)]
-       [(eq? (car expr) 'let*) (comp-let* expr env)]
-       [(eq? (car expr) 'letrec) (comp-letrec expr env)]
-       [(eq? (car expr) 'begin) (comp-begin expr env)]
-       [(eq? (car expr) 'do) (comp-do expr env)]
-       [(eq? (car expr) 'define) (comp-define expr env)]
-       [(eq? (car expr) 'define-macro) (comp-define-macro expr env)]
-       [else (comp-combination expr env)])]))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-;; Compatibility -- In order to use mutable pairs, this will
-;; need to be adjusted slightly.
-
-(define scheme-global-variables '())
-
-(struct MutablePair (first second) #:mutable)
-
-(define (scheme-global-var name)
-  (let ([x (assq name scheme-global-variables)])
-    (if x
-        (cdr x)
-        (let ([y (MutablePair name '())]) ;; cons -> MutablePair
-          (set! scheme-global-variables (cons (cons name y) scheme-global-variables))
-          y))))
-
-(define (scheme-global-var-ref i)
-  (MutablePair-second i))
-
-(define (scheme-global-var-set! i val)
-  (set-MutablePair-second! i val)
-  '())
-
-; (define scheme-global-variables '())
-
-(define (def-proc name value)
-  (scheme-global-var-set! (scheme-global-var name) value))
-
-(def-proc 'not (lambda (x) (not x)))
-(def-proc 'boolean? boolean?)
-(def-proc 'eqv? eqv?)
-(def-proc 'eq? eq?)
-(def-proc 'equal? equal?)
-(def-proc 'pair? (lambda (obj) (pair? obj)))
-(def-proc 'cons (lambda (x y) (cons x y)))
-(def-proc 'car (lambda (x) (car x)))
-(def-proc 'cdr (lambda (x) (cdr x)))
-
-;; Compatibility - getting removed
-; (def-proc 'set-car! set-car!)
-; (def-proc 'set-cdr! set-cdr!)
-
-(def-proc 'caar caar)
-(def-proc 'cadr cadr)
-(def-proc 'cdar cdar)
-(def-proc 'cddr cddr)
-(def-proc 'caaar caaar)
-(def-proc 'caadr caadr)
-(def-proc 'cadar cadar)
-(def-proc 'caddr caddr)
-(def-proc 'cdaar cdaar)
-(def-proc 'cdadr cdadr)
-(def-proc 'cddar cddar)
-(def-proc 'cdddr cdddr)
-(def-proc 'caaaar caaaar)
-(def-proc 'caaadr caaadr)
-(def-proc 'caadar caadar)
-(def-proc 'caaddr caaddr)
-(def-proc 'cadaar cadaar)
-(def-proc 'cadadr cadadr)
-(def-proc 'caddar caddar)
-(def-proc 'cadddr cadddr)
-(def-proc 'cdaaar cdaaar)
-(def-proc 'cdaadr cdaadr)
-(def-proc 'cdadar cdadar)
-(def-proc 'cdaddr cdaddr)
-(def-proc 'cddaar cddaar)
-(def-proc 'cddadr cddadr)
-(def-proc 'cdddar cdddar)
-(def-proc 'cddddr cddddr)
-(def-proc 'null? (lambda (x) (null? x)))
-(def-proc 'list? list?)
-(def-proc 'list list)
-(def-proc 'length length)
-(def-proc 'append append)
-(def-proc 'reverse reverse)
-(def-proc 'list-ref list-ref)
-(def-proc 'memq memq)
-(def-proc 'memv memv)
-(def-proc 'member member)
-(def-proc 'assq assq)
-(def-proc 'assv assv)
-(def-proc 'assoc assoc)
-(def-proc 'symbol? symbol?)
-(def-proc 'symbol->string symbol->string)
-(def-proc 'string->symbol string->symbol)
-(def-proc 'number? number?)
-
-; (def-proc 'complex? complex?)
-; (def-proc 'real? real?)
-; (def-proc 'rational? rational?)
-(def-proc 'integer? integer?)
-; (def-proc 'exact? exact?)
-; (def-proc 'inexact? inexact?)
-
-;;(def-proc '=                              =)
-;;(def-proc '<                              <)
-;;(def-proc '>                              >)
-;;(def-proc '<=                             <=)
-;;(def-proc '>=                             >=)
-;;(def-proc 'zero?                          zero?)
-;;(def-proc 'positive?                      positive?)
-;;(def-proc 'negative?                      negative?)
-;;(def-proc 'odd?                           odd?)
-;;(def-proc 'even?                          even?)
-(def-proc 'max max)
-(def-proc 'min min)
-;;(def-proc '+                              +)
-;;(def-proc '*                              *)
-;;(def-proc '-                              -)
-(def-proc '/ /)
-(def-proc 'abs abs)
-;;(def-proc 'quotient                       quotient)
-;;(def-proc 'remainder                      remainder)
-;;(def-proc 'modulo                         modulo)
-; (def-proc 'gcd gcd)
-; (def-proc 'lcm lcm)
-;;(def-proc 'numerator                      numerator)
-;;(def-proc 'denominator                    denominator)
-; (def-proc 'floor floor)
-; (def-proc 'ceiling ceiling)
-; (def-proc 'truncate truncate)
-; (def-proc 'round round)
-;;(def-proc 'rationalize                    rationalize)
-; (def-proc 'exp exp)
-; (def-proc 'log log)
-; (def-proc 'sin sin)
-; (def-proc 'cos cos)
-; (def-proc 'tan tan)
-; (def-proc 'asin asin)
-; (def-proc 'acos acos)
-; (def-proc 'atan atan)
-; (def-proc 'sqrt sqrt)
-; (def-proc 'expt expt)
-;;(def-proc 'make-rectangular               make-rectangular)
-;;(def-proc 'make-polar                     make-polar)
-;;(def-proc 'real-part                      real-part)
-;;(def-proc 'imag-part                      imag-part)
-;;(def-proc 'magnitude                      magnitude)
-;;(def-proc 'angle                          angle)
-; (def-proc 'exact->inexact inexact)
-; (def-proc 'inexact->exact exact)
-(def-proc 'number->string number->string)
-(def-proc 'string->number string->number)
-(def-proc 'char? char?)
-; (def-proc 'char=? char=?)
-; (def-proc 'char<? char<?)
-; (def-proc 'char>? char>?)
-; (def-proc 'char<=? char<=?)
-; (def-proc 'char>=? char>=?)
-; (def-proc 'char-ci=? char-ci=?)
-; (def-proc 'char-ci<? char-ci<?)
-; (def-proc 'char-ci>? char-ci>?)
-; (def-proc 'char-ci<=? char-ci<=?)
-; (def-proc 'char-ci>=? char-ci>=?)
-; (def-proc 'char-alphabetic? char-alphabetic?)
-; (def-proc 'char-numeric? char-numeric?)
-; (def-proc 'char-whitespace? char-whitespace?)
-; (def-proc 'char-lower-case? char-lower-case?)
-; (def-proc 'char->integer char->integer)
-; (def-proc 'integer->char integer->char)
-; (def-proc 'char-upcase char-upcase)
-; (def-proc 'char-downcase char-downcase)
-(def-proc 'string? string?)
-; (def-proc 'make-string make-string)
-(def-proc 'string string)
-(def-proc 'string-length string-length)
-(def-proc 'string-ref string-ref)
-; (def-proc 'string-set! string-set!)
-(def-proc 'string=? string=?)
-(def-proc 'string<? string<?)
-(def-proc 'string>? string>?)
-(def-proc 'string<=? string<=?)
-(def-proc 'string>=? string>=?)
-(def-proc 'string-ci=? string-ci=?)
-(def-proc 'string-ci<? string-ci<?)
-(def-proc 'string-ci>? string-ci>?)
-(def-proc 'string-ci<=? string-ci<=?)
-(def-proc 'string-ci>=? string-ci>=?)
-(def-proc 'substring substring)
-(def-proc 'string-append string-append)
-(def-proc 'vector? vector?)
-(def-proc 'make-vector make-vector)
-(def-proc 'vector vector)
-(def-proc 'vector-length vector-length)
-(def-proc 'vector-ref vector-ref)
-(def-proc 'vector-set! vector-set!)
-(def-proc 'procedure? procedure?)
-(def-proc 'apply apply)
-(def-proc 'map map)
-; (def-proc 'for-each for-each)
-;;(def-proc 'call-with-current-continuation call-with-current-continuation)
-; (def-proc 'call-with-input-file call-with-input-file)
-; (def-proc 'call-with-output-file call-with-output-file)
-; (def-proc 'input-port? input-port?)
-; (def-proc 'output-port? output-port?)
-; (def-proc 'current-input-port current-input-port)
-; (def-proc 'current-output-port current-output-port)
-; (def-proc 'open-input-file open-input-file)
-; (def-proc 'open-output-file open-output-file)
-; (def-proc 'close-input-port close-input-port)
-; (def-proc 'close-output-port close-output-port)
-; (def-proc 'eof-object? eof-object?)
-; (def-proc 'read read)
-; (def-proc 'read-char read-char)
-; (def-proc 'peek-char peek-char)
-; (def-proc 'write write)
-(def-proc 'display display)
-(def-proc 'newline newline)
-; (def-proc 'write-char write-char)
-
-;; TODO: Make this work!
-; (define (run-benchmark)
-;   (let* ([count (read)]
-;          [input1 (read)]
-;          [output (read)]
-;          [s2 (number->string count)]
-;          [s1 ""]
-;          [name "scheme"])
-;     (run-r7rs-benchmark (string-append name ":" s2)
-;                         count
-;                         (lambda () (scheme-eval (hide count input1)))
-;                         (lambda (result) (equal? result output)))))
-
-;; - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
-
-(define program
-  '(let ()
-
-     (define (sort-list obj pred)
-
-       (define (loop l)
-         (if (and (pair? l) (pair? (cdr l))) (split l '() '()) l))
-
-       (define (split l one two)
-         (if (pair? l) (split (cdr l) two (cons (car l) one)) (merge (loop one) (loop two))))
-
-       (define (merge one two)
-         (cond
-           [(null? one) two]
-           [(pred (car two) (car one)) (cons (car two) (merge (cdr two) one))]
-           [else (cons (car one) (merge (cdr one) two))]))
-
-       (loop obj))
-
-     (sort-list '("one" "two"
-                        "three"
-                        "four"
-                        "five"
-                        "six"
-                        "seven"
-                        "eight"
-                        "nine"
-                        "ten"
-                        "eleven"
-                        "twelve"
-                        "thirteen"
-                        "fourteen"
-                        "fifteen"
-                        "sixteen"
-                        "seventeen"
-                        "eighteen"
-                        "nineteen"
-                        "twenty"
-                        "twentyone"
-                        "twentytwo"
-                        "twentythree"
-                        "twentyfour"
-                        "twentyfive"
-                        "twentysix"
-                        "twentyseven"
-                        "twentyeight"
-                        "twentynine"
-                        "thirty")
-                string<?)))
-
-(assert! (equal? (scheme-eval program)
-                 '("eight" "eighteen"
-                           "eleven"
-                           "fifteen"
-                           "five"
-                           "four"
-                           "fourteen"
-                           "nine"
-                           "nineteen"
-                           "one"
-                           "seven"
-                           "seventeen"
-                           "six"
-                           "sixteen"
-                           "ten"
-                           "thirteen"
-                           "thirty"
-                           "three"
-                           "twelve"
-                           "twenty"
-                           "twentyeight"
-                           "twentyfive"
-                           "twentyfour"
-                           "twentynine"
-                           "twentyone"
-                           "twentyseven"
-                           "twentysix"
-                           "twentythree"
-                           "twentytwo"
-                           "two")))
-
-(require "steel/time/time.scm"
-         (for-syntax "steel/time/time.scm"))
-
-(define (run)
-
-  (let loop ([i 0])
-    ; (when (< i 100000)
-    (when (< i 1)
-      (begin
-        ; (displayln i)
-        (assert! (equal? (scheme-eval program)
-                         '("eight" "eighteen"
-                                   "eleven"
-                                   "fifteen"
-                                   "five"
-                                   "four"
-                                   "fourteen"
-                                   "nine"
-                                   "nineteen"
-                                   "one"
-                                   "seven"
-                                   "seventeen"
-                                   "six"
-                                   "sixteen"
-                                   "ten"
-                                   "thirteen"
-                                   "thirty"
-                                   "three"
-                                   "twelve"
-                                   "twenty"
-                                   "twentyeight"
-                                   "twentyfive"
-                                   "twentyfour"
-                                   "twentynine"
-                                   "twentyone"
-                                   "twentyseven"
-                                   "twentysix"
-                                   "twentythree"
-                                   "twentytwo"
-                                   "two")))
-        (loop (+ i 1))))))
-
-(time! (run))
diff --git a/r7rs-benchmarks/simplex.scm b/r7rs-benchmarks/simplex.scm
deleted file mode 100644
index 6362875bb..000000000
--- a/r7rs-benchmarks/simplex.scm
+++ /dev/null
@@ -1,262 +0,0 @@
-;;; SIMPLEX -- Simplex algorithm.
-; #lang r7rs
-; (import (scheme base)
-;         (only (racket base) version))
-; (define (this-scheme-implementation-name)
-;   (string-append "racket-" (version) "/r7rs"))
-
-; (import (scheme base)
-;         (scheme read)
-;         (scheme write)
-;         (scheme time))
-
-; (require "steel/mutable-vectors")
-
-(define vector-ref mut-vector-ref)
-; (define vector-set! mutable-vector-set!)
-; (define vector-length mut-vec-len)
-; (define (make-vector n)
-;   (apply mutable-vector (map (lambda (x) 0) (range 0 n))))
-
-(define vector-length mut-vec-len)
-(define vector mutable-vector)
-
-(define (positive? x)
-  (> x 0))
-
-(define (negative? x)
-  (< x 0))
-
-(define-syntax do
-  (syntax-rules ()
-    [(do ((var init step ...) ...) (test expr ...) command ...)
-     (letrec* ([loop
-                (lambda (var ...)
-                  (if test
-                      (begin
-                        expr ...)
-                      (begin
-                        command ...
-                        (loop (do "step" var step ...) ...))))])
-              (loop init ...))]
-    [(do "step" x) x]
-    [(do "step" x y) y]))
-
-(define (matrix-rows a)
-  (vector-length a))
-(define (matrix-columns a)
-  (vector-length (vector-ref a 0)))
-(define (matrix-ref a i j)
-  (vector-ref (vector-ref a i) j))
-(define (matrix-set! a i j x)
-  (vector-set! (vector-ref a i) j x))
-
-(define (complain)
-  (error #f "This shouldn't happen"))
-
-(define (simplex a m1 m2 m3)
-  ;(define *epsilon* 1e-6)
-  (define *epsilon* 0.000001)
-  (unless (and (>= m1 0) (>= m2 0) (>= m3 0) (= (matrix-rows a) (+ m1 m2 m3 2)))
-    (complain))
-  (let* ([m12 (+ m1 m2 1)]
-         [m (- (matrix-rows a) 2)]
-         [n (- (matrix-columns a) 1)]
-         ; [nl1 n]
-         [l1 (make-vector n)]
-         [l2 (make-vector m)]
-         [l3 (make-vector m2)]
-         [nl1 n]
-         [iposv (make-vector m)]
-         [izrov (make-vector n)]
-         [ip 0]
-         [kp 0]
-         [bmax 0.0]
-         [one? #f]
-         [pass2? #t])
-
-    (define (simp1 mm abs?)
-      (set! kp (vector-ref l1 0))
-      (set! bmax (matrix-ref a mm kp))
-      (do ((k 1 (+ k 1)))
-          ((>= k nl1))
-          (begin
-            (when (positive? (if abs?
-                                 (- (abs (matrix-ref a mm (vector-ref l1 k))) (abs bmax))
-                                 (- (matrix-ref a mm (vector-ref l1 k)) bmax)))
-              (begin
-                (set! kp (vector-ref l1 k))
-                (set! bmax (matrix-ref a mm (vector-ref l1 k))))))))
-    (define (simp2)
-      (set! ip 0)
-      (let ([q1 0.0] [flag? #f])
-        (do ((i 0 (+ i 1)))
-            ((= i m))
-            (if flag?
-                (when (< (matrix-ref a (vector-ref l2 i) kp) (- *epsilon*))
-                  (let ([q (/ (- (matrix-ref a (vector-ref l2 i) 0))
-                              (matrix-ref a (vector-ref l2 i) kp))])
-                    (cond
-                      [(< q q1)
-                       (set! ip (vector-ref l2 i))
-                       (set! q1 q)]
-                      [(= q q1)
-                       (let ([qp 0.0] [q0 0.0])
-                         (let loop ([k 1])
-                           (when (<= k n)
-                             (begin
-                               (set! qp (/ (- (matrix-ref a ip k)) (matrix-ref a ip kp)))
-                               (set! q0
-                                     (/ (- (matrix-ref a (vector-ref l2 i) k))
-                                        (matrix-ref a (vector-ref l2 i) kp)))
-                               (when (= q0 qp)
-                                 (loop (+ k 1))))))
-                         (when (< q0 qp)
-                           (set! ip (vector-ref l2 i))))])))
-                (when (< (matrix-ref a (vector-ref l2 i) kp) (- *epsilon*))
-                  (set! q1
-                        (/ (- (matrix-ref a (vector-ref l2 i) 0))
-                           (matrix-ref a (vector-ref l2 i) kp)))
-                  (set! ip (vector-ref l2 i))
-                  (set! flag? #t))))))
-    (define (simp3 one?)
-      (let ([piv (/ (matrix-ref a ip kp))])
-        (do ((ii 0 (+ ii 1)))
-            ((= ii (+ m (if one? 2 1))))
-            (unless (= ii ip)
-              (matrix-set! a ii kp (* piv (matrix-ref a ii kp)))
-              (do ((kk 0 (+ kk 1)))
-                  ((= kk (+ n 1)))
-                  (unless (= kk kp)
-                    (matrix-set! a
-                                 ii
-                                 kk
-                                 (- (matrix-ref a ii kk)
-                                    (* (matrix-ref a ip kk) (matrix-ref a ii kp))))))))
-        (do ((kk 0 (+ kk 1)))
-            ((= kk (+ n 1)))
-            (unless (= kk kp)
-              (matrix-set! a ip kk (* (- piv) (matrix-ref a ip kk)))))
-        (matrix-set! a ip kp piv)))
-    (do ((k 0 (+ k 1))) ((= k n)) (vector-set! l1 k (+ k 1)) (vector-set! izrov k k))
-    (do ((i 0 (+ i 1)))
-        ((= i m))
-        (when (negative? (matrix-ref a (+ i 1) 0))
-          (complain))
-        (vector-set! l2 i (+ i 1))
-        (vector-set! iposv i (+ n i)))
-    (do ((i 0 (+ i 1))) ((= i m2)) (vector-set! l3 i #t))
-    (when (positive? (+ m2 m3))
-      (do ((k 0 (+ k 1)))
-          ((= k (+ n 1)))
-          (do ((i (+ m1 1) (+ i 1)) (sum 0.0 (+ sum (matrix-ref a i k))))
-              ((> i m) (matrix-set! a (+ m 1) k (- sum)))))
-      (let loop ()
-        (simp1 (+ m 1) #f)
-        (cond
-          [(<= bmax *epsilon*)
-           (cond
-             [(< (matrix-ref a (+ m 1) 0) (- *epsilon*)) (set! pass2? #f)]
-             [(<= (matrix-ref a (+ m 1) 0) *epsilon*)
-              (let loop ([ip1 m12])
-                (if (<= ip1 m)
-                    (cond
-                      [(= (vector-ref iposv (- ip1 1)) (+ ip n -1))
-                       (simp1 ip1 #t)
-                       (cond
-                         [(positive? bmax)
-                          (set! ip ip1)
-                          (set! one? #t)]
-                         [else (loop (+ ip1 1))])]
-                      [else (loop (+ ip1 1))])
-                    (do ((i (+ m1 1) (+ i 1)))
-                        ((>= i m12))
-                        (when (vector-ref l3 (- i (+ m1 1)))
-                          (do ((k 0 (+ k 1)))
-                              ((= k (+ n 1)))
-                              (matrix-set! a i k (- (matrix-ref a i k))))))))]
-             [else
-              (simp2)
-              (if (zero? ip) (set! pass2? #f) (set! one? #t))])]
-          [else
-           (simp2)
-           (if (zero? ip) (set! pass2? #f) (set! one? #t))])
-        (when one?
-          (set! one? #f)
-          (simp3 #t)
-          (cond
-            [(>= (vector-ref iposv (- ip 1)) (+ n m12 -1))
-             (let loop ([k 0])
-               (cond
-                 [(and (< k nl1) (not (= kp (vector-ref l1 k)))) (loop (+ k 1))]
-                 [else
-                  (set! nl1 (- nl1 1))
-                  (do ((is k (+ is 1))) ((>= is nl1)) (vector-set! l1 is (vector-ref l1 (+ is 1))))
-                  (matrix-set! a (+ m 1) kp (+ (matrix-ref a (+ m 1) kp) 1.0))
-                  (do ((i 0 (+ i 1)))
-                      ((= i (+ m 2)))
-                      (matrix-set! a i kp (- (matrix-ref a i kp))))]))]
-            [(and (>= (vector-ref iposv (- ip 1)) (+ n m1))
-                  (vector-ref l3 (- (vector-ref iposv (- ip 1)) (+ m1 n))))
-             (vector-set! l3 (- (vector-ref iposv (- ip 1)) (+ m1 n)) #f)
-             (matrix-set! a (+ m 1) kp (+ (matrix-ref a (+ m 1) kp) 1.0))
-             (do ((i 0 (+ i 1))) ((= i (+ m 2))) (matrix-set! a i kp (- (matrix-ref a i kp))))])
-          (let ([t (vector-ref izrov (- kp 1))])
-            (vector-set! izrov (- kp 1) (vector-ref iposv (- ip 1)))
-            (vector-set! iposv (- ip 1) t))
-          (loop))))
-
-    (and pass2?
-         (let loop ()
-           (simp1 0 #f)
-           (cond
-             [(positive? bmax)
-              (simp2)
-              (cond
-                [(zero? ip) #t]
-                [else
-                 (simp3 #f)
-                 (let ([t (vector-ref izrov (- kp 1))])
-                   (vector-set! izrov (- kp 1) (vector-ref iposv (- ip 1)))
-                   (vector-set! iposv (- ip 1) t))
-                 (loop)])]
-             [else (list iposv izrov)])))))
-
-(define (test input)
-  (simplex (vector (vector 0.0 1.0 1.0 3.0 -0.5)
-                   (vector 740.0 -1.0 0.0 -2.0 0.0)
-                   (vector 0.0 0.0 -2.0 0.0 7.0)
-                   (vector 0.5 0.0 -1.0 1.0 -2.0)
-                   (vector 9.0 -1.0 -1.0 -1.0 -1.0)
-                   (vector 0.0 0.0 0.0 0.0 0.0))
-           2
-           1
-           1))
-
-(assert! (equal? (list (vector 4 1 3 2) (vector 0 5 7 6)) (test 740.0)))
-
-(let loop ([i 0])
-  ; (when (< i 1000000)
-  (when (< i 10000)
-    (begin
-      ; (displayln i)
-      (assert! (equal? (list (vector 4 1 3 2) (vector 0 5 7 6)) (test 740.0)))
-
-      (loop (+ i 1)))))
-
-; 1000000
-; 740.0
-; (#(4 1 3 2) #(0 5 7 6))
-
-; (define (run-benchmark)
-;   (let* ((count (read))
-;          (input1 (read))
-;          (output (read))
-;          (s2 (number->string count))
-;          (s1 "")
-;          (name "simplex"))
-;     (run-r7rs-benchmark
-;      (string-append name ":" s2)
-;      count
-;      (lambda () (test (hide count input1)))
-;      (lambda (result) (equal? result output)))))
diff --git a/r7rs-benchmarks/triangl.scm b/r7rs-benchmarks/triangl.scm
deleted file mode 100644
index d17f1ee8c..000000000
--- a/r7rs-benchmarks/triangl.scm
+++ /dev/null
@@ -1,107 +0,0 @@
-;;; TRIANGL -- Board game benchmark.
-
-; (import (scheme base) (scheme read) (scheme write) (scheme time))
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-; (require "steel/mutable-vectors")
-
-(define-syntax do
-  (syntax-rules ()
-    [(do ((var init step ...) ...) (test expr ...) command ...)
-     (letrec* ([loop
-                (lambda (var ...)
-                  (if test
-                      (begin
-                        expr ...)
-                      (begin
-                        command ...
-                        (loop (do "step" var step ...) ...))))])
-              (loop init ...))]
-    [(do "step" x) x]
-    [(do "step" x y) y]))
-
-(define (list->vector lst)
-  (apply mutable-vector lst))
-
-; (define list->vector list->mutable-vector)
-(define vector->list mutable-vector->list)
-(define vector-ref mut-vector-ref)
-; (define vector-set! mutable-vector-set!)
-
-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-
-(define *board* (list->vector '(1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1)))
-
-(define *sequence* (list->vector '(0 0 0 0 0 0 0 0 0 0 0 0 0 0)))
-
-; (displayln *sequence*)
-
-(define *a*
-  (list->vector
-   '(1 2 4 3 5 6 1 3 6 2 5 4 11 12 13 7 8 4 4 7 11 8 12 13 6 10 15 9 14 13 13 14 15 9 10 6 6)))
-
-(define *b*
-  (list->vector '(2 4 7 5 8 9 3 6 10 5 9 8 12 13 14 8 9 5 2 4 7 5 8 9 3 6 10 5 9 8 12 13 14 8 9 5 5)))
-
-(define *c*
-  (list->vector
-   '(4 7 11 8 12 13 6 10 15 9 14 13 13 14 15 9 10 6 1 2 4 3 5 6 1 3 6 2 5 4 11 12 13 7 8 4 4)))
-
-(define *answer* '())
-
-(define (attempt i depth)
-  (cond
-    [(= depth 14)
-     (set! *answer* (cons (cdr (vector->list *sequence*)) *answer*))
-     #t]
-    [(and (= 1 (vector-ref *board* (vector-ref *a* i)))
-          (= 1 (vector-ref *board* (vector-ref *b* i)))
-          (= 0 (vector-ref *board* (vector-ref *c* i))))
-     (vector-set! *board* (vector-ref *a* i) 0)
-     (vector-set! *board* (vector-ref *b* i) 0)
-     (vector-set! *board* (vector-ref *c* i) 1)
-     (vector-set! *sequence* depth i)
-     (do ((j 0 (+ j 1)) (depth (+ depth 1))) ((or (= j 36) (attempt j depth)) #f))
-     (vector-set! *board* (vector-ref *a* i) 1)
-     (vector-set! *board* (vector-ref *b* i) 1)
-     (vector-set! *board* (vector-ref *c* i) 0)
-     #f]
-    [else #f]))
-
-(define (test i depth)
-  (set! *answer* '())
-  (attempt i depth)
-  (car *answer*))
-
-; 50
-; 22
-; 1
-; (22 34 31 15 7 1 20 17 25 6 5 13 32)
-
-; (displayln (test 22 1))
-
-(let loop ([i 0])
-  ; (when (< i 50)
-  (when (< i 1)
-    (begin
-      ; (displayln i)
-      ; (assert! (equal? (list (vector 4 1 3 2) (vector 0 5 7 6)) (test 740.0)))
-      (displayln (test 22 1))
-
-      (loop (+ i 1)))))
-
-; (define (run-benchmark)
-;   (let* ((count (read))
-;          (input1 (read))
-;          (input2 (read))
-;          (output (read))
-;          (s3 (number->string count))
-;          (s2 (number->string input2))
-;          (s1 (number->string input1))
-;          (name "triangl"))
-;     (run-r7rs-benchmark
-;      (string-append name ":" s1 ":" s2 ":" s3)
-;      count
-;      (lambda () (test (hide count input1) (hide count input2)))
-;      (lambda (result) (equal? result output)))))
diff --git a/self_hosted/case.rkt b/self_hosted/case.rkt
deleted file mode 100644
index 60c89434b..000000000
--- a/self_hosted/case.rkt
+++ /dev/null
@@ -1,118 +0,0 @@
-(define-syntax case-lambda
-  (syntax-rules ()
-    ((case-lambda)
-     (lambda args
-       (error "CASE-LAMBDA without any clauses.")))
-    ((case-lambda 
-      (?a1 ?e1 ...) 
-      ?clause1 ...)
-     (lambda args
-       (let ((l (length args)))
-         (case-lambda "CLAUSE" args l 
-           (?a1 ?e1 ...)
-           ?clause1 ...))))
-    ((case-lambda "CLAUSE" ?args ?l 
-      ((?a1 ...) ?e1 ...))
-     (if (= ?l (length '(?a1 ...)))
-         (apply (lambda (?a1 ...) ?e1 ...) ?args)
-         (error! "Arity mismatch")
-         
-         ))
-    ((case-lambda "CLAUSE" ?args ?l 
-      ((?a1 ...) ?e1 ...) 
-      ?clause1 ...)
-     (if (= ?l (length '(?a1 ...)))
-         (apply (lambda (?a1 ...) ?e1 ...) ?args)
-         (case-lambda "CLAUSE" ?args ?l 
-           ?clause1 ...)))
-    ((case-lambda "CLAUSE" ?args ?l
-      ((?a1 . ?ar) ?e1 ...) 
-      ?clause1 ...)
-     (case-lambda "IMPROPER" ?args ?l 1 (?a1 . ?ar) (?ar ?e1 ...) 
-       ?clause1 ...))
-    ((case-lambda "CLAUSE" ?args ?l 
-      (?a1 ?e1 ...)
-      )
-     (let ((?a1 ?args))
-       ?e1 ...))
-    ((case-lambda "CLAUSE" ?args ?l)
-     (error "Wrong number of arguments to CASE-LAMBDA."))
-    ((case-lambda "IMPROPER" ?args ?l ?k ?al ((?a1 . ?ar) ?e1 ...)
-      ?clause1 ...)
-     (case-lambda "IMPROPER" ?args ?l (+ ?k 1) ?al (?ar ?e1 ...) 
-      ?clause1 ...))
-    ((case-lambda "IMPROPER" ?args ?l ?k ?al (?ar ?e1 ...) 
-      ?clause1 ...)
-     (if (>= ?l ?k)
-         (apply (lambda ?al ?e1 ...) ?args)
-         (case-lambda "CLAUSE" ?args ?l 
-           ?clause1 ...)))))
-
-; (define-syntax case-lambda
-;   (syntax-rules ()
-;     ((case-lambda)
-;      (lambda args
-;        (error "CASE-LAMBDA without any clauses.")))
-;     ((case-lambda 
-;       (?a1 ?e1 ...) 
-;       ?clause1 ...)
-;      (lambda args
-;        (let ((l (length args)))
-;          (case-lambda "CLAUSE" args l 
-;            (?a1 ?e1 ...)
-;            ?clause1 ...))))
-;     ;; TODO: Fix ... conditions
-;     ((case-lambda "CLAUSE" ?args ?l 
-;       ((?a1 ...) ?e1 ...) 
-;       ?clause1 ...)
-;      (if (= ?l (length '(?a1 ...)))
-;          (apply (lambda (?a1 ...) ?e1 ...) ?args)
-;          (case-lambda "CLAUSE" ?args ?l 
-;            ?clause1 ...)))
-;     ((case-lambda "CLAUSE" ?args ?l
-;       ((?a1 . ?ar) ?e1 ...) 
-;       ?clause1 ...)
-;      (case-lambda "IMPROPER" ?args ?l 1 (?a1 . ?ar) (?ar ?e1 ...) 
-;        ?clause1 ...))
-;     ((case-lambda "CLAUSE" ?args ?l 
-;       (?a1 ?e1 ...))
-;      (let ((?a1 ?args))
-;        ?e1 ...))
-;     ((case-lambda "CLAUSE" ?args ?l 
-;       (?a1 ?e1 ...)
-;       ?clause1 ...)
-;      (let ((?a1 ?args))
-;        ?e1 ...))
-;     ((case-lambda "CLAUSE" ?args ?l)
-;      (error "Wrong number of arguments to CASE-LAMBDA."))
-;     ((case-lambda "IMPROPER" ?args ?l ?k ?al ((?a1 . ?ar) ?e1 ...)
-;       ?clause1 ...)
-;      (case-lambda "IMPROPER" ?args ?l (+ ?k 1) ?al (?ar ?e1 ...) 
-;       ?clause1 ...))
-;     ((case-lambda "IMPROPER" ?args ?l ?k ?al (?ar ?e1 ...) 
-;       ?clause1 ...)
-;      (if (>= ?l ?k)
-;          (apply (lambda ?al ?e1 ...) ?args)
-;          (case-lambda "CLAUSE" ?args ?l 
-;            ?clause1 ...)))))
-
-(define greet
-    (case-lambda
-      [(name) (string-append "Hello, " name)]
-      [(given surname) (string-append "Hello, " (string-append given (string-append " " surname)))]))
-
-(greet "John")
-(greet "John" "Smith")
-; (greet "John" "Smith" "Extra")
-
-(define plus
-    (case-lambda 
-        (() 0)
-        ((x) x)
-        ((x y) (+ x y))
-        ((x y z) (+ (+ x y) z))
-        (args (apply + args))))
-
-(plus)
-(plus 1)
-(plus 1 2 3)
\ No newline at end of file
diff --git a/self_hosted/clos.rkt b/self_hosted/clos.rkt
deleted file mode 100644
index 99f448b8d..000000000
--- a/self_hosted/clos.rkt
+++ /dev/null
@@ -1,250 +0,0 @@
-;; ---------------------------- Class Object definitions --------------------------------------------
-
-(struct Class-Object (name parents interfaces fields methods))
-(struct Interface (name methods))
-(struct Class-Instance (class-object fields))
-
-
-(define (list-subset? left right)
-  (hashset-subset? (list->hashset left)
-                (list->hashset right)))
-
-;; Classes contain:
-;; A name, which is required to be a symbol (string should also work, but for now a symbol simplifies this)
-;; The parents are a list of class objects -> we don't want classes pointing to arbitrary objects
-;; The fields are represented by a list of symbols, to refer to using the get-slot method
-;; The methods in theory could be anything, as long as they're functions.
-;;
-;; Here we don't restrict the hash map of symbol -> function, but rather will restrict it on the
-;; function when adding the methods.
-(define/contract (Class name parents interfaces fields methods)
-  (->/c symbol? (listof Class-Object?) (listof Interface?) (listof symbol?) hash? Class-Object?)
-  (unless (list-subset?
-           ;; Collect the list of required methods for the given interfaces
-           (transduce interfaces
-                      (flat-mapping Interface-methods)
-                      (into-list))
-           ;; Extract the methods that have been defined concretely on this class at construction
-           (hash-keys->list methods))
-    (error! "Not all required methods are implemented for the given interfaces"))
-
-  (Class-Object
-   name
-   parents
-   interfaces
-   ;; Explicitly go collect the fields to flatten into this class given the
-   ;; class hierarchy
-   (combine-local-and-parent-fields fields parents)
-   methods))
-
-(define (Make-Class 
-               name 
-               #:fields (fields '())  
-               #:methods (methods '())
-               #:parents (parents '()) 
-               #:interfaces (interfaces '()))
-    (Class name parents interfaces fields methods))
-
-
-(define (contains-duplicates? lst)
-  (not
-   (equal? (hashset-length (apply hashset lst))
-            (length lst))))
-
-;; Flatten the incoming list
-(define (flatten lst) (transduce lst (flattening) (into-list)))
-
-(define (collect-fields list-of-class-objects)
-  (transduce list-of-class-objects
-             (flat-mapping Class-Object-fields)
-             (into-list)))
-
-(define (combine-local-and-parent-fields local-fields list-of-class-objects)
-  (let ((appended (append
-                   local-fields
-                   (collect-fields list-of-class-objects))))
-    (if (contains-duplicates? appended)
-        (error! "Class field is unresolvable")
-        appended)))
-
-
-
-;; -----------------------------------------------------------------------------------------------------
-
-
-;; Add a method to a class
-;; This can also occur in the root definition of the object in the hash, but the contract
-;; won't be checked there at the moment TODO
-(define/contract (define-method class-object name method)
-  (->/c Class-Object? symbol? function? any/c)
-  (let ((methods (Class-Object-methods class-object)))
-    (set-Class-Object-methods! class-object (hash-insert methods name method))))
-
-(define (resolve-parent-method class-object name)
-  (let ((possible-methods (map (lambda (x) (get-method x name)) (Class-Object-parents class-object))))
-    (if (equal? 1 (length possible-methods))
-        (car possible-methods)
-        (error! "Unable to resolve the method on the class instance"))))
-
-;; Attempt to resolve the method on the class object via the class hierarchy
-;; This checks the current class object, and then attempt to resolve the method upwards, returning the first
-;; one that it finds. If there are multiple candidates, we bail and error out since we can't determine
-;; which method we intended to call.
-(define/contract (get-method class-object name)
-  (->/c Class-Object? symbol? function?)
-  (let ((local-method (-> class-object
-                          (Class-Object-methods)
-                          (hash-try-get name))))
-    ;; If _this_ class object contains the method, then we return this method
-    ;; This way we always select the correct method in the class hierarchy
-    (if local-method
-        local-method
-        ;; Otherwise, attempt to resolve the method on the parents
-        ;; For now, methods are just a hashmap from name -> method
-        (resolve-parent-method class-object name))))
-
-;; Attempt to resolve the method on the parent class to this class objects
-(define/contract (get-super-method class-object name)
-  (->/c Class-Object? symbol? function?)
-  (resolve-parent-method class-object name))
-
-(define/contract (position? lst value)
-  (->/c list? any/c integer?)
-  (define list-length (length lst))
-  (define (loop lst idx)
-    (cond
-      [(= idx list-length) => (error! "Value not a member of the list")]
-      [(equal? value (list-ref lst idx)) => idx]
-      [else => (loop lst (+ idx 1))]))
-  (loop lst 0))
-
-;; Map the given field name to an index in the class' slot
-(define/contract (%get-slot-idx class-object field-name)
-  (->/c Class-Object? symbol? integer?)
-  (-> class-object
-      (Class-Object-fields)
-      (position? field-name)))
-
-;; This returns whatever value is found in the slot
-;; This _could_ be any value. TODO: find a way to bind a contract to a slot
-(define/contract (get-slot class-instance field-name)
-  (->/c Class-Instance? symbol? any/c)
-  (mut-vector-ref (Class-Instance-fields class-instance)
-                  (%get-slot-idx (Class-Instance-class-object class-instance) field-name)))
-
-;; Sets the slot in the class instance found a `field-name` to `value`
-;; TODO: make the contract be dependent to have the result match the value's contract
-(define/contract (set-slot! class-instance field-name value)
-  (->/c Class-Instance? symbol? any/c any/c)
-  (vector-set!
-   (Class-Instance-fields class-instance)
-   ;; Get the slot index -> maps the field name to the index in the vector
-   (%get-slot-idx (Class-Instance-class-object class-instance) field-name)
-   value))
-
-;; Instances should be represented in memory (for now) just as tagged vectors
-;; Each of the fields will be zero'd out
-(define/contract (%allocate-instance class-object)
-  (->/c Class-Object? Class-Instance?)
-  ;; We can just use a normal vector here, not a mutable vector
-  (Class-Instance
-          ;; Reference to the class object here
-          class-object
-          ;; Fields as a mutable vector
-          ;; Name resolution should be done via %get-slot method
-          (apply mutable-vector (map (lambda (x) void)
-                                     (Class-Object-fields class-object)))))
-
-;; Get the method on the class object denoted by the method name
-;; and call it given the arguments here
-;; TODO: figure out contracts for multi arity functions
-(define (call class-instance method-name . args)
-  (apply (get-method (Class-Instance-class-object class-instance) method-name)
-         ;; The instance is always an implicit first argument, and as such gets
-         ;; cons onto the first of the arguments to call the function
-         (cons class-instance args)))
-
-;; Same as above, calls the method on the nearest parent object
-(define (call-super class-instance method-name . args)
-  (apply (get-super-method (Class-Instance-class-object class-instance) method-name)
-         (cons class-instance args)))
-
-(define/contract (class-instance-name class-instance)
-  (->/c Class-Instance? symbol?)
-  (Class-Object-name (Class-Instance-class-object class-instance)))
-
-;; TODO -> check if object implements interface
-;; (define/contract (class-implements-Interface? class-instance interface)
-;;   (->/c Class-Object? Interface? boolean?)
-;;   (member? interface
-;;
-
-;; ------------------- Examples --------------------------
-
-;; Base object for everything in the class hierarchy
-(define Object (Class 'Object
-                      '()
-                      '()
-                      '()
-                      (hash 'println
-                            (lambda (self)
-                              (displayln (-> "#<"
-                                             (string-append
-                                              (symbol->string (class-instance-name self)))
-                                             (string-append ">")))))))
-
-;; Define the class object for Animal
-;; Is a child of the Object base class
-(define Animal (Class 'Animal
-                      (list Object)
-                      '()
-                      '(name color weight)
-                      (hash
-                       'get-weight (lambda (self) (get-slot self 'weight)))))
-
-;; Dog inherits from Animal, adds on the 'good-boy? field
-(define Dog (Class 'Dog
-                   (list Animal)
-                   '()
-                   '(good-boy?)
-                   (hash)))
-
-;; TODO: Once keyword arguments are a thing, classes could be defined like so:
-;; (define Dog (Class #:name 'Dog
-;;                    #:parents (list Animal)
-;;                    #:interfaces '()
-;;                    #:fields '(good-boy?)
-;;                    #:methods (hash)))
-
-
-;; Allocates a new instance of a dog - here all of the fields are default to #<void>
-(define sherman (%allocate-instance Dog))
-;; Set the weight to be 25 -> this is set in the instance, and all fields are flattened on construction
-(set-slot! sherman 'weight 25)
-;; This will traverse upwards on the methods to find the method
-(call sherman 'println)
-;; This should find the method on the parent class
-(call sherman 'get-weight)
-;; Explicitly call the method on the super
-(call-super sherman 'get-weight)
-;; Setting a slot since the default allocation of the instance sets everything to void
-(set-slot! sherman 'good-boy? #true)
-
-(define Stinky (Interface 'Stinky '(smelly icky)))
-
-(define Worm (Class 'Worm
-                    (list Dog)
-                    (list Stinky)
-                    '()
-                    (hash
-                     'smelly (lambda (self) "Smelly!")
-                     'icky (lambda (self) "Icky!"))))
-
-
-(define New-Worm (Make-Class 'Worm
-                    #:parents (list Dog)
-                    #:interfaces (list Stinky)
-                    #:methods 
-                      (hash
-                        'smelly (lambda (self) "Smelly!")
-                        'icky (lambda (self) "Icky!"))))
\ No newline at end of file
diff --git a/self_hosted/compiler.rkt b/self_hosted/compiler.rkt
deleted file mode 100644
index 8e5efd5f1..000000000
--- a/self_hosted/compiler.rkt
+++ /dev/null
@@ -1,654 +0,0 @@
-; #lang racket
-
-; (require "match.rkt" (for-syntax "match.rkt"))
-
-(require "steel/option")
-
-;; ---------------- Vendored std::option ----------------
-;; -- TODO -> fix bug with importing option
-;; Looks like theres an issue where None gets bound to void for some reason
-;; Most likely having to do with declaring nested structs
-
-
-(define-syntax try! 
-  (syntax-rules ()
-    [(try! expr)
-     (begin
-       (if (None? expr)
-           (return! expr)
-           (unwrap-some expr)))]))
-
-;; -----------------------------------------------------------
-
-
-;; Add support for mutable structs
-(struct Instruction (op-code payload-size contents))
-
-;; --------- Local Variable -----------
-
-(define (LocalVariable name captured? struct-offset syntax-object)
-  (mutable-vector 'LocalVariable name captured? struct-offset syntax-object))
-
-(define (LocalVariable-name self) (mut-vector-ref self 1))
-(define (LocalVariable-captured? self) (mut-vector-ref self 2))
-(define (LocalVariable-struct-offset self) (mut-vector-ref self 3))
-(define (LocalVariable-syntax-object self) (mut-vector-ref self 4))
-
-(define (set-captured! self)
-  (vector-set! 2 #t))
-
-;; ---------- Upvalue -------------
-
-(define (UpValue index local? ident)
-  (mutable-vector 'UpValue index local? ident))
-
-(define (UpValue-index self) (mut-vector-ref self 1))
-(define (UpValue-local? self) (mut-vector-ref self 2))
-(define (Upvalue-ident self) (mut-vector-ref self 3))
-
-;; --------- Variable Data ------------
-
-;; Mutable struct
-(define (VariableData locals enclosing)
-  (mutable-vector
-   ;; Name
-   'VariableData
-   ;; locals (mutable-vector)
-   locals
-   ;; upvalues
-   (mutable-vector)
-   ;; enclosing => default (None)
-   enclosing))
-
-;; Getter for locals
-(define (VariableData-locals self)
-  (mut-vector-ref self 1))
-
-;; Getter for upvalues
-(define (VariableData-upvalues self)
-  (mut-vector-ref self 2))
-
-;; Pointer to the enclosing variable
-(define/contract (VariableData-enclosing self)
-  (->/c mutable-vector? Option?)
-  (mut-vector-ref self 3))
-
-;; push a local to the VariableData struct
-(define (push-local! self local)
-  (vector-push! (VariableData-locals self) local))
-
-;; Mark a local at the index as captured
-(define (mark-captured! self index)
-  (set-captured!
-   (mut-vector-ref
-    (VariableData-locals self)
-    index)))
-
-;; Get the position (from the back) of the value that satisfies `func` 
-(define (position-from-back vec func)
-  ;; Get the last index of the vector
-  (define last-index (- (mut-vec-len vec) 1))
-  (when (< last-index 0)
-    (return! (None)))
-  (define (looper vec idx)
-    (cond
-      ;; If we're outside of the range of the vector, return None
-      [(< idx 0) => (None)]
-      [(func (mut-vector-ref vec idx)) => (Some idx)]
-      [else => (looper vec (- idx 1))]))
-  (looper vec last-index))
-
-;; Get the position (from the front) of the value that satisfies `func`
-(define (position-from-front vec func)
-  (define vec-length (mut-vec-len vec))
-  (define (loop vec idx)
-    (cond
-      [(= idx vec-length) => (None)]
-      [(func (mut-vector-ref vec idx)) => (Some idx)]
-      [else => (loop vec (+ idx 1))]))
-  (loop vec 0))
-
-; (define (position-from-front vec func)
-;     (define vec-length (mut-vec-len vec))
-;     (define (loop vec idx)
-;         (cond
-;             [(= idx vec-length) => (None)]
-;             [(func (mut-vector-ref vec idx)) => (Some (mut-vector-ref vec idx))]
-;             [else => (loop vec (+ idx 1))]))
-;     (loop vec 0))
-
-;; Get the first value from the back that satisfies the position
-(define (find-from-back vec func)
-  ;; Get the last index of the vector
-  (define last-index (- (mut-vec-len vec) 1))
-  (when (< last-index 0)
-    (return! (None)))
-  (define (looper vec idx)
-    (cond
-      ;; If we're outside of the range of the vector, return None
-      [(< idx 0) => (None)]
-      [(func (mut-vector-ref vec idx)) => (Some (mut-vector-ref vec idx))]
-      [else => (looper vec (- idx 1))]))
-  (looper vec last-index))
-
-
-
-; (-> VariableData? string? Option?)
-(define (resolve-local self ident)
-  (let ((idx (map-option
-              (position-from-back
-               (VariableData-locals self)
-               (lambda (x) (equal? (symbol->string ident) (LocalVariable-name x))))
-              (lambda (x) (- (mut-vec-len (VariableData-locals self)) 1 x))))
-        (var (find-from-back
-              (VariableData-locals self) (lambda (x) (equal? (LocalVariable-name x) (symbol->string ident))))))
-
-    ;   (display "Resolving ")
-    ;   (displayln ident)
-    ;   (displayln (VariableData-locals self))
-    ;   (displayln (unwrap-some idx))
-    ;   (displayln (unwrap-some var))
-
-    ;; Just bail out if these are Nones
-    (when (None? idx) (return! idx))
-    (when (None? var) (return! var))
-
-    ;; return the sum of the index and the offset
-    (Some (+ (unwrap-some idx) (LocalVariable-struct-offset (unwrap-some var))))))
-
-(define (add-upvalue self index local? ident)
-  (define i (position-from-front
-             (VariableData-upvalues self)
-             (lambda (x) (and
-                          (equal? (UpValue-index x) index)
-                          (equal? (UpValue-local? x) local?)))))
-  (cond
-    [(Some? i) => (unwrap-some i)]
-    [else =>
-          (-> self
-              (VariableData-upvalues)
-              (vector-push! (UpValue index local? ident)))
-
-          (mut-vec-len (VariableData-upvalues self))]))
-
-;; TODO
-;; this behavior doesn't match yet
-(define (resolve-upvalue self ident)
-
-  (when (None? (VariableData-enclosing self))
-    (return! (None)))
-
-  (define local
-    (-> self
-        (VariableData-enclosing)
-        (map-option (lambda (x) (resolve-local x ident)))
-        (flatten-option)))
-
-  (cond [(Some? local)
-         => (let ((var-offset (-> self
-                                  (VariableData-enclosing) ;; Option<VariableData>
-                                  (unwrap-some) ;; VariableData
-                                  (VariableData-locals) ;; Vec<LocalVariable>
-                                  (find-from-back (lambda (x) (equal? (LocalVariable-name x) (symbol->string ident)))) ;; Option<LocalVariable>
-                                  (map-option LocalVariable-struct-offset) ;; Option<Int>
-                                  (unwrap-or 0))))
-
-              ;; Mark this captured in the parent
-              (-> self
-                  (VariableData-enclosing)
-                  (unwrap-some)
-                  (mark-captured! (- (unwrap-some local) var-offset)))
-
-              (Some (add-upvalue (unwrap-some local) #true ident)))]
-        [else
-         => (let ((upvalue (-> self
-                               (VariableData-enclosing)
-                               (map-option (lambda (x) (resolve-upvalue x ident)))
-                               (flatten-option))))
-              (if (Some? upvalue)
-                  (Some (add-upvalue (unwrap-some upvalue) #false ident))
-                  (None)))]))
-
-;; --------- Code Generator ------------
-
-(struct CodeGenerator (
-                       instructions
-                       constant-map
-                       defining-context
-                       depth
-                       variable-data
-                       let-context
-                       stack-offset
-                       top-level-define
-                       rooted
-                       ))
-
-;; Push directly on to the instruction set
-(define (push! self x)
-  (vector-push! (CodeGenerator-instructions self) x))
-
-;; Get the length of the underlying instruction set
-(define (instructions-len self)
-  (mut-vec-len (CodeGenerator-instructions self)))
-
-;; Generate a new code generator
-(define (CodeGenerator::new constant-map)
-  (CodeGenerator
-   (mutable-vector)
-   constant-map
-   void
-   0
-   (None)
-   #false
-   0
-   #false
-   #false))
-
-;; Generate a new code generator from body instructions
-;; Explicitly for recursive calls
-(define (CodeGenerator::new-from-body-instructions 
-         constant-map
-         instructions
-         depth
-         variable-data
-         defining-context)
-  (CodeGenerator
-   instructions
-   constant-map
-   defining-context
-   depth
-   variable-data
-   #false
-   0
-   #false
-   #false))
-
-;; (-> CodeGenerator? int? int?)
-;; Updates the payload of the instruction at index
-(define (update-payload! self index new-payload)
-  (let ((instructions (CodeGenerator-instructions self))
-        (old-instruction (mut-vector-ref (CodeGenerator-instructions self) index)))
-    (vector-set! instructions index (set-Instruction-payload-size! old-instruction new-payload))))
-
-;; TODO -> have this share the same body as the above
-(define (update-contents! self index new-contents)
-  (let ((instructions (CodeGenerator-instructions self))
-        (old-instruction (mut-vector-ref (CodeGenerator-instructions self) index)))
-    (vector-set! instructions index (set-Instruction-contents! old-instruction new-contents))))
-
-
-;; TODO - implement collecting locals from the lambda function
-;; should also verify that there are no duplicate function arguments
-
-;; TODO -> this just default filters out the '. from the arguments list, and it shouldn't do this
-;; really needs to just drain the second from the last argument
-(define (collect-locals-from-function lambda-function)
-  (let ((locals (filter (lambda (x) (not (equal? '. x))) (cadr lambda-function))))
-    (when (not (equal? (length locals) (hashset-length (list->hashset locals))))
-      (error! "Bad Syntax: lambda function cannot have duplicate argument names: " lambda-function))
-
-    (apply
-     mutable-vector
-     (map
-      (lambda (x) (LocalVariable (symbol->string x) #false 0 x))
-      (reverse locals)))))
-
-(define (add-or-get constant-map value)
-  (let ((idx (position-from-front constant-map (lambda (x) (equal? x value)))))
-    (cond [(Some? idx) => (unwrap-some idx)]
-          [else
-           =>
-           (let ((idx (mut-vec-len constant-map)))
-             (vector-push! constant-map value)
-             idx)])))
-
-;; Check if anything in the list satisfies the predicate
-(define (list-any? list pred)
-  (cond [(empty? list) => #f]
-        [(pred (car list)) => #t]
-        [else => (list-any? (cdr list) pred)]))
-
-;; TODO -> this is not particularly valid, but it'll work for now
-;; This just checks for the presence of any '.', but it really needs to
-;; make sure its in the correct position
-(define (multi-arity-function? function-expr)
-  (list-any? (cadr function-expr) (lambda (x) (equal? '. x))))
-
-; (define (normalize))
-
-(define (visit-lambda-function self expr)
-  (displayln "Visiting lambda")
-
-  (let ((idx (instructions-len self)))
-    (push! self (Instruction 'SCLOSURE 0 '()))
-
-    ;; Detect if this is a multi arity function somehow
-    (push! self (Instruction 'PASS (if (multi-arity-function? expr) 1 0) '()))
-
-    ;; If we're a let context and not rooted, insert this instruction
-    ;; not sure exactly why its necessary, but we're just matching the existing
-    ;; behavior
-    (push! self (Instruction 'PASS
-                             (if (and
-                                  (CodeGenerator-let-context self)
-                                  (not (CodeGenerator-rooted self)))
-                                 1
-                                 0)
-                             '()))
-
-    (let* ((variable-data (VariableData
-                           (collect-locals-from-function expr)
-                           (CodeGenerator-variable-data self)))
-           (child-generator (CodeGenerator::new-from-body-instructions
-                             (CodeGenerator-constant-map self)
-                             (mutable-vector)
-                             (+ 1 (CodeGenerator-depth self))
-                             (Some variable-data)
-                             (if (or (CodeGenerator-top-level-define self)
-                                     (CodeGenerator-let-context self))
-                                 (CodeGenerator-defining-context self)
-                                 (None)))))
-
-      ;; Compile the body of the lambda function
-      (compile child-generator (caddr expr))
-
-      (push! self
-             (Instruction 'NDEFS
-                          (mut-vec-len (VariableData-upvalues variable-data)) '()))
-
-      ;; Fill out the upvalue information
-      (transduce (VariableData-upvalues variable-data)
-                 (into-for-each
-                  (lambda (upvalue)
-                    (push! self
-                           (Instruction
-                            (if (UpValue-local? upvalue) 'FILLLOCALUPVALUE 'FILLUPVALUE))
-                           (UpValue-index upvalue '())))))
-
-      (push! child-generator
-             (Instruction 'POP (mut-vec-len (VariableData-locals variable-data)) '()))
-
-      ;; TODO -> defining-context tail call stuff
-
-      (transduce (VariableData-locals variable-data)
-                 (into-for-each
-                  (lambda (local)
-                    (push! self
-                           (Instruction
-                            'CLOSEUPVALUE
-                            (if (LocalVariable-captured? local) 1 0)
-                            (LocalVariable-syntax-object local))))))
-
-      ;; TODO -> convert last usages here
-
-      (vector-append!
-       (CodeGenerator-instructions self)
-       (CodeGenerator-instructions child-generator))
-
-      (let ((closure-body-size (- (instructions-len self) idx))
-            (arity (length (filter (lambda (x) (not (equal? '. x))) (cadr expr)))))
-
-        (push! self (Instruction 'ECLOSURE arity '()))
-
-        ;; Store the body size
-        (update-payload! self idx closure-body-size)))))
-
-(define (constant? expr)
-  (or
-   (boolean? expr)
-   (number? expr)
-   (string? expr)
-   (char? expr)))
-
-(define (specialize-constant self expr)
-  (push! self
-         (Instruction
-          'PUSHCONST
-          (add-or-get (CodeGenerator-constant-map self) expr)
-          expr)))
-
-(define (visit-atom self expr)
-  (let ((idx (-> self
-                 (CodeGenerator-variable-data)
-                 (map-option (lambda (x) (resolve-local x expr)))
-                 (flatten-option))))
-    (cond [(Some? idx)
-           =>
-           (push! self (Instruction 'READLOCAL (unwrap-some idx) expr))]
-          [else =>
-                (let ((idx (-> self
-                               (CodeGenerator-variable-data)
-                               (map-option (lambda (x) (resolve-upvalue x expr)))
-                               (flatten-option))))
-                  (cond [(Some? idx)
-                         =>
-                         (push! self (Instruction 'READUPVALUE (unwrap-some idx) expr))]
-                        [else
-                         =>
-                         (push! self (Instruction 'PUSH 0 expr))]))])))
-
-;; The core of visiting atoms and sets
-(define (visit-atom-combinator self expr local-op upvalue-op global-op)
-  (let ((idx (-> self
-                 (CodeGenerator-variable-data)
-                 (map-option (lambda (x) (resolve-local x expr)))
-                 (flatten-option))))
-    (cond [(Some? idx)
-           => (push! self (Instruction local-op (unwrap-some idx) expr))]
-          [else =>
-                (let ((idx (-> self
-                               (CodeGenerator-variable-data)
-                               (map-option (lambda (x) (resolve-upvalue x expr)))
-                               (flatten-option))))
-                  (cond [(Some? idx)
-                         => (push! self (Instruction upvalue-op (unwrap-some idx) expr))]
-                        [else
-                         => (push! self (Instruction global-op 0 expr))]))])))
-
-(define (visit-atom self expr)
-  (visit-atom-combinator self expr 'READLOCAL 'READUPVALUE 'PUSH))
-
-(define (visit-set self expr)
-  (compile self (cdr expr))
-  (visit-atom-combinator self (cadr expr) 'SETLOCAL 'SETUPVALUE 'SET))
-
-
-(define (visit-define self expr)
-  (let* ((sidx (instructions-len self))
-         (defining-context (cadr expr))
-         (adjusted-self (-> self
-                            (set-CodeGenerator-defining-context! defining-context)
-                            (set-CodeGenerator-top-level-define! #true))))
-
-    ;; Start the definition
-    (push! self (Instruction 'SDEF 0 '()))
-
-    ;; Update the contents to now point to this new context
-    (update-contents! self sidx defining-context)
-
-    ;; Compile the body of this define
-    (compile self (caddr expr))
-
-    (let ((defn-body-size (- (instructions-len self) sidx)))
-      (push! self (Instruction 'EDEF 0 '()))
-      (update-payload! self sidx defn-body-size)
-      (push! self (Instruction 'BIND 0 (cadr expr)))
-      (push! self (Instruction 'VOID 0 '())))))
-
-(define (visit-if self expr)
-  (displayln "Visiting if")
-  (let ((test-expr (cadr expr))
-        (then-expr (caddr expr))
-        (else-expr (cadddr expr)))
-    ;; Load in the test condition
-    (compile self test-expr)
-    ;; Push in the if instructions
-    (push! self (Instruction 'IF (+ 2 (instructions-len self)) '()))
-    ;; save spot of the jump instruction, fill in after
-    (let ((idx (instructions-len self)))
-      ;; Dummy value
-      (push! self (Instruction 'JMP 0 '()))
-      ;; Emit instructions for the then
-      (compile self then-expr)
-      (push! self (Instruction 'JMP 0 '()))
-      (let ((false-start (instructions-len self)))
-        ;; emit instructions for else expression
-        (compile self else-expr)
-        (let ((j3 (instructions-len self)))
-          (update-payload! self idx false-start)
-          (update-payload! self (- false-start 1) j3))))))
-
-(define (visit-list self expr)
-
-  (displayln "Visiting function application")
-
-  ;; TODO -> all this stuff about let contexts and tail call offsets
-  ;; and defining_contexts before
-  ;; This can be address later once its cleaned up in the real compiler
-  (let ((pop-len (length (cdr expr))))
-
-    (transduce (cdr expr)
-               (into-for-each (lambda (sub-expr)
-                                ; (displayln "Compiling argument")
-                                (compile self sub-expr))))
-
-    (compile self (car expr))
-    (push! self (Instruction 'FUNC pop-len (car expr)))))
-
-; (let ((body-begin (instructions-len self)))
-;     (compile (self (car expr)))
-;     (let ((body-end (instructions-len self)))
-;         ;; TODO tail call offset stuff here
-
-;         (push! self (Instruction 'FUNC pop-len (car expr)))))))
-
-
-(define (visit-return self expr)
-  (compile self (cdr expr))
-  (push! (Instruction 'POP 0 '())))
-
-(define (visit-quote self expr)
-  (push! 'PUSHCONST (add-or-get (CodeGenerator-constant-map self) expr) expr))
-
-
-;; TODO - zip range instead of doing the set! on each iteration
-;; keep it simple
-(define (visit-begin self expr)
-  (cond [(empty? (cdr expr)) => (push! (Instruction 'VOID 0 '()))]
-        [else
-         =>
-         (let ((offset (CodeGenerator-stack-offset self)))
-           (transduce (cdr expr)
-                      (into-for-each
-                       (lambda (x)
-                         (compile (set-CodeGenerator-stack-offset! self offset) x)
-                         (set! offset (+ 1 offset))))))]))
-
-;; (-> CodeGenerator? (listof? expr))
-(define (compile self expr)
-  (cond
-    [(symbol? expr) => (visit-atom self expr)]
-    [(constant? expr) => (specialize-constant self expr)]
-    [(list? expr)
-     (let ((sym (car expr)))
-       (cond [(equal? sym 'define) => (visit-define self expr)]
-             ;; (begin <expr> ...)
-             [(equal? sym 'begin) => (visit-begin self expr)]
-             ;; ('if test then else)
-             [(equal? sym 'if) => (visit-if self expr)]
-             ;; (lambda (<ident> ... . <ident>) <expr> ...)
-             [(equal? sym 'lambda) => (visit-lambda-function self expr)]
-             ;; (set! <ident> <expr>)
-             [(equal? sym 'set!) => (visit-set self expr)]
-             [else => (visit-list self expr)]))]
-    [else (displayln "Unknown case")]))
-
-
-(define (inject-heap-save-to-pop self)
-  (let ((len (instructions-len self))
-        (instructions (CodeGenerator-instructions self)))
-    (unless (< len 4)
-      (let ((edef (mut-vector-ref instructions (- len 4)))
-            (bind (mut-vector-ref instructions (- len 3)))
-            (void-instr (mut-vector-ref instructions (- len 2)))
-            (pop (mut-vector-ref instructions (- len 1))))
-        (when (and (equal? (Instruction-op-code edef) 'EDEF)
-                   (equal? (Instruction-op-code bind) 'BIND)
-                   (equal? (Instruction-op-code void-instr) 'VOID)
-                   (equal? (Instruction-op-code pop) 'POP))
-          (update-payload! self (- len 1) 1))))))
-
-
-;; Write compiler that can compile this to bytecode
-; (define test-program '(define foo (if #true 10 20)))
-
-(define program
-  '(
-    ; (define test (lambda (x) (+ x 10)))
-    ; (define applesauce (lambda (y) (+ y (test y))))
-    ; (define multi-arity (lambda (x . y) y))
-    (define hello-world (lambda () (displayln "Hello world!")))
-    ; (multi-arity 1 2 3 4 5)
-
-    (hello-world)
-    ))
-
-(define *Constant-map* (mutable-vector))
-; (define *Compiler*)
-
-;; (-> CodeGenerator expr Vec<Instruction>)
-(define (compile-top-level self program)
-  (compile self program)
-  (push! self (Instruction 'POP 0 '()))
-  (inject-heap-save-to-pop self)
-  (CodeGenerator-instructions self))
-
-(define (compile-exprs exprs constant-map)
-  (transduce
-   exprs
-   (mapping (lambda (x) (compile-top-level (CodeGenerator::new constant-map) x)))
-   (into-list)))
-
-(define *instructions* (compile-exprs program *Constant-map*))
-
-;; (-> void)
-(define (pretty-print-instructions instructions)
-  (displayln "------------------------------")
-  (transduce
-   instructions
-   (mapping struct->list)
-   (into-for-each displayln)))
-
-;; Iterator over the generated instructions and print the result
-(transduce *instructions* (into-for-each pretty-print-instructions))
-
-(displayln "---------------Constant Map---------------")
-(displayln *Constant-map*)
-
-; (transduce *instructions* (mapping struct->list) (into-for-each displayln))
-
-; (pretty-print-instructions)
-; (displayln *Constant-map*)
-
-(define (write-to-file file-name constant-map instructions)
-  (let ((file-handle (open-output-file file-name)))
-    (write-line! file-handle 'ConstantMap)
-    (write-line! file-handle constant-map)
-    (write-line! file-handle 'Instructions)
-    (transduce instructions
-               (into-for-each
-                (lambda (instruction-set) 
-                  (write-line! file-handle 'Expression)
-                  (transduce
-                   instruction-set
-                   (mapping struct->list)
-                   (into-for-each
-                    (lambda (instruction)
-                      (write-line! file-handle instruction)))))))))
-
-
-(write-to-file "test.txt" *Constant-map* *instructions*)
-
-;; Write the instructions down to the file
-
-
diff --git a/self_hosted/contract-old.rkt b/self_hosted/contract-old.rkt
deleted file mode 100644
index f2577e81f..000000000
--- a/self_hosted/contract-old.rkt
+++ /dev/null
@@ -1,397 +0,0 @@
-(provide
-    make-function-contract
-    bind-contract-to-function
-    FlatContract
-    FlatContract-predicate
-    FunctionContract)
-
-(new-make-struct FlatContract (predicate name))
-
-;; Alias the name for clarity
-(define make-flat-contract FlatContract)
-
-;; Contract Attachment - use this for understanding where something happened
-(new-make-struct ContractAttachmentLocation (type name))
-
-;; Function Contract - keep track of preconditions and post conditions, where the contract was attached,
-;; and a pointer to the parent contract. Can probably replace parent with just a list of the parents since it can be shared
-;; directly
-(new-make-struct FunctionContract (pre-conditions 
-                               post-condition 
-                               contract-attachment-location 
-                               parent))
-
-(new-make-struct DependentPair (argument-name arguments thunk thunk-name))
-
-(new-make-struct 
-    DependentContract 
-        (arg-positions 
-         pre-conditions post-condition
-         contract-attachment-location
-         parent))
-
-(new-make-struct ContractViolation (error-message))
-
-(new-make-struct ContractedFunction (contract function name))
-
-(define (contract->string contract)
-    (cond [(FlatContract? contract) => (symbol->string (FlatContract-name contract))]
-          [(FunctionContract? contract) => 
-            (to-string
-                "(->" (apply 
-                            to-string
-                            (transduce (FunctionContract-pre-conditions contract)
-                                 (mapping contract->string)
-                                 (into-list)))
-
-                       (contract->string (FunctionContract-post-condition contract))
-                ")")]
-          [else => (error! "Unexpected value found in contract:" contract)]))
-
-
-(define (split-last lst)
-    (define (loop accum lst)
-        (if (empty? (cdr lst))
-            (list (reverse accum) (car lst))
-            (loop (cons (car lst) accum) (cdr lst))))
-    (loop '() lst))
-
-(define make-function-contract
-    (lambda conditions
-        (displayln split-last)
-
-        ;; TODO: consider moving this into a primitive
-        
-
-        (let ((split (split-last conditions)))
-            (FunctionContract (first split) (second split) void void))))
-
-
-
-
-
-(define (apply-flat-contract flat-contract arg)
-    (if ((FlatContract-predicate flat-contract) arg)
-        #true
-        (ContractViolation 
-            (to-string
-                "Contract violation: found in the application of a flat contract for" 
-                        (FlatContract-name flat-contract) 
-                        ": the given input:" arg 
-                        "resulted in a contract violation"))))
-
-
-
-
-
-(define (apply-parents parent name function arguments span)
-    (if (void? parent)
-        #true
-        (begin
-            (displayln "Applying parent contract")
-            (apply-function-contract (ContractedFunction-contract parent)
-                                        name 
-                                        function 
-                                        arguments
-                                        span)
-            
-            (apply-parents (FunctionContract-parent parent) name function arguments span))))
-
-;; Call a contracted function
-(define (apply-contracted-function contracted-function arguments span)
-
-    (define span (if span span '(0 0)))
-
-    (displayln "Applying contracted function")
-    (displayln contracted-function)
-    (let ((parent (FunctionContract-parent 
-                    (ContractedFunction-contract contracted-function))))
-        (when parent
-            (apply-parents 
-                parent 
-                (ContractedFunction-name contracted-function) 
-                (ContractedFunction-function contracted-function) 
-                arguments 
-                span)))
-
-    ; (apply-parents (FunctionContract-parent 
-        ; (ContractedFunction-contract contracted-function)))
-    (apply-function-contract (ContractedFunction-contract contracted-function)
-                             (ContractedFunction-name contracted-function)
-                             (ContractedFunction-function contracted-function)
-                             arguments
-                             span))
-
-
-(define (verify-preconditions self-contract arguments name span)
-    (transduce 
-        arguments
-        (zipping (FunctionContract-pre-conditions self-contract))
-        (enumerating)
-        (mapping 
-            (lambda (x)
-                (let ((i (first x))
-                      (arg (first (second x)))
-                      (contract (second (second x))))
-
-                    (cond [(FlatContract? contract)
-                            => 
-                                (displayln "Applying flat contract in pre condition")
-
-                                (let ((result (apply-flat-contract contract arg)))
-                                    (displayln result)
-                                    (displayln (FunctionContract-contract-attachment-location self-contract))
-                                    (if (ContractViolation? result)
-                                        (error-with-span span 
-                                            "This function call caused an error"
-                                            "- it occured in the domain position:" i ", with the contract: " (contract->string contract) (ContractViolation-error-message result) ", blaming " 
-                                                (ContractAttachmentLocation-name
-                                                    (FunctionContract-contract-attachment-location self-contract)) 
-                                            "(callsite)")
-                                        arg))]
-                          [(FunctionContract? contract)
-                            =>
-                                (displayln "Wrapping contract")
-                                (if (ContractedFunction? arg)
-                                    (let ((pre-parent (ContractedFunction-contract arg)))
-                                        (let ((parent (FunctionContract
-                                                            (FunctionContract-pre-conditions pre-parent)
-                                                            (FunctionContract-post-condition pre-parent)
-                                                            (ContractAttachmentLocation 
-                                                                'DOMAIN
-                                                                (ContractedFunction-name arg))
-                                                            void)))
-                                            (let ((fc (FunctionContract 
-                                                            (FunctionContract-pre-conditions contract)
-                                                            (FunctionContract-post-condition contract)
-                                                            (ContractAttachmentLocation
-                                                                'DOMAIN
-                                                                (ContractedFunction-name arg))
-                                                            parent)))
-
-                                                (bind-contract-to-function fc arg name span))))
-                                    (bind-contract-to-function contract arg name span))]
-                        [else => (error! "Unexpected value in pre conditions: " contract)]
-                                    
-                                    ))))
-        (into-list)))
-
-; (verify-preconditions 
-;     (make-function-contract 
-;         (FlatContract int? 'int?) 
-;         (FlatContract int? 'int?)
-;         (FlatContract boolean? 'boolean?))
-
-;     '(10 20)
-;     'test-function)
-
-(define (apply-function-contract contract name function arguments span)
-    ;; Check that each of the arguments abides by the 
-    (let ((validated-arguments (verify-preconditions contract arguments name span)))
-        (displayln "Calling apply - Applying function")
-        (displayln function)
-        (displayln validated-arguments)
-        (let ((output (apply function validated-arguments))
-            (self-contract contract)
-            (self-contract-attachment-location (FunctionContract-contract-attachment-location contract))
-            (contract (FunctionContract-post-condition contract)))
-            (cond [(FlatContract? contract)
-                    => 
-                    (displayln "applying flat contract in post condition")
-                    
-                    (let ((result (apply-flat-contract contract output)))
-                        (if (ContractViolation? result)
-                            (let ((blame-location 
-                                    (if (void? self-contract-attachment-location)
-                                        name
-                                        self-contract-attachment-location)))
-
-                                (displayln self-contract-attachment-location)
-
-                                (cond [(void? blame-location) => 
-                                        (error-with-span
-                                            span
-                                            "this function call resulted in an error - occured in the range position of this contract: " 
-                                            (contract->string self-contract) (ContractViolation-error-message result) "blaming: None - broke its own contract")]
-
-                                      [else => 
-                                        (error-with-span
-                                                span
-                                                "this function call resulted in an error - occurred in the range position of this contract: " 
-                                                (contract->string self-contract) (ContractViolation-error-message result) "blaming: "
-                                                blame-location)
-                                      
-                                      ]
-
-                                    ;   [(equal? (ContractAttachmentLocation-type blame-location) 'DOMAIN)
-                                    ;     =>
-                                    ;     (displayln "occurred in the domain position")
-                                    ;     (error-with-span
-                                    ;         span 
-                                    ;         "this function call resulted in an error - occurred in the range position of this contract: " 
-                                    ;         (contract->string self-contract) (ContractViolation-error-message result) "blaming: "
-                                    ;         blame-location)]
-
-                                    ;   [(equal? (ContractAttachmentLocation-type blame-location) 'RANGE)
-                                    ;     =>
-                                    ;     (error-with-span
-                                    ;         span
-                                    ;         "this function call resulted in an error - occurred in the range position of this contract: " 
-                                    ;         (contract->string self-contract) (ContractViolation-error-message result) "blaming: "
-                                    ;         blame-location)]
-
-                                    ;   [else => (error! "Unexpected value found when assigning blame")]
-                                      
-                                      
-                                      ))
-                                
-                            output))]
-                    [(FunctionContract? contract)
-                    => (if (ContractedFunction? output)
-                                (let ((pre-parent (ContractedFunction-contract output)))
-                                    (let ((parent (FunctionContract
-                                                        (FunctionContract-pre-conditions pre-parent)
-                                                        (FunctionContract-post-condition pre-parent)
-                                                        (ContractedFunction-name output)
-                                                        void)))
-                                        (let ((fc (FunctionContract 
-                                                        (FunctionContract-pre-conditions contract)
-                                                        (FunctionContract-post-condition contract)
-                                                        (ContractAttachmentLocation
-                                                            'RANGE
-                                                            (ContractedFunction-name output))
-                                                        parent)))
-                                            (bind-contract-to-function fc output name span))))
-                                (bind-contract-to-function contract output name span))]
-                    [else => (error! "Unhandled value in post condition: " contract)]))))
-
-(define (bind-contract-to-function contract function name . span)
-    (define post-condition (FunctionContract-post-condition contract))
-    ; (displayln (FunctionContract-pre-conditions contract))
-    ; (displayln (FunctionContract-post-condition contract))
-    (displayln name)
-    (let ((updated-preconditions
-            (transduce 
-                (FunctionContract-pre-conditions contract)
-                (mapping (lambda (c)
-                            (cond [(FlatContract? c) => c]
-                                  [(FunctionContract? c) =>
-                                    (FunctionContract
-                                        (FunctionContract-pre-conditions c)
-                                        (FunctionContract-post-condition c)
-                                        (ContractAttachmentLocation 'DOMAIN name)
-                                        (FunctionContract-parent c))]
-                                  [else => (error "Unexpected value found in bind-contract-to-function" c)])))
-                (into-list)))
-
-          (updated-postcondition
-            (cond [(FlatContract? post-condition) => post-condition]
-                  [(FunctionContract? post-condition) =>
-                    (FunctionContract
-                        (FunctionContract-pre-conditions post-condition)
-                        (FunctionContract-post-condition post-condition)
-                        (ContractAttachmentLocation 'RANGE name)
-                        (FunctionContract-parent post-condition))]
-                    [else => (error "Unexpected value found in bind-contract-to-function" post-condition)])))
-
-        (displayln "Binding contract to function")
-        (displayln updated-preconditions)
-        (displayln updated-postcondition)
-        (let ((contracted-function 
-                    (ContractedFunction
-                        (FunctionContract 
-                            updated-preconditions 
-                            updated-postcondition 
-                            (ContractAttachmentLocation 'TOPLEVEL name) 
-                            void)
-                        function name)))
-            
-            (lambda args
-                (displayln args)
-                (apply-contracted-function contracted-function args 
-                    (if span (car span) (current-function-span)))))))
-
-
-
-
-(define test-function
-    (bind-contract-to-function 
-        (make-function-contract
-            (FlatContract int? 'int?)
-            (FlatContract int? 'int?)
-            (FlatContract boolean? 'boolean?))
-        (lambda (x y) (equal? (+ x y) 10))
-        'test-function))
-
-(test-function 5 5)
-; (test-function "applesauce" 5)
-
-; (test-function "hello world" 10)
-
-; (define foo
-;     (lambda (x) 
-;         (if (= x 100)
-;             x
-;             (foo (+ x 1)))))
-
-; (define bar
-;     (lambda (x) 
-;         (if (= x 100)
-;             x
-;             (foo (+ x 1)))))
-
-; ; (set! foo foo)
-
-; (set! foo
-;     (bind-contract-to-function
-;         (make-function-contract
-;             (FlatContract int? 'int?)
-;             (FlatContract int? 'int?))
-;         foo
-;         'foo))
-
-
-; (set! bar
-;     (bind-contract-to-function
-;         (make-function-contract
-;             (FlatContract int? 'int?)
-;             (FlatContract int? 'int?))
-;         bar
-;         'bar))
-
-
-; (define blagh 
-;     (bind-contract-to-function
-;         (make-function-contract
-;             (make-function-contract (FlatContract even? 'even?) (FlatContract odd? 'odd?))
-;             (FlatContract even? 'even?)
-;             (FlatContract even? 'even?))
-;         (lambda (func y) (+ 1 (func y)))
-;         'blagh))
-
-; (blagh (lambda (x) (+ x 2)) 2)
-
-
-; (define (any? x) #true)
-; (define level1 
-;     (bind-contract-to-function
-;         (make-function-contract
-;             (make-function-contract (FlatContract int? 'int?)))
-;         (lambda () (lambda () 10.2))
-;         'level1))
-
-; (define level2
-;     (bind-contract-to-function
-;         (make-function-contract
-;             (make-function-contract (FlatContract number? 'number?)))
-;         (lambda () (level1))
-;         'level2))
-
-; (define level3
-;     (bind-contract-to-function
-;         (make-function-contract
-;             (make-function-contract (FlatContract any? 'any?)))
-;         (lambda () (level2))
-;         'level3))
-
-; ((level3))
\ No newline at end of file
diff --git a/self_hosted/contracts.rkt b/self_hosted/contracts.rkt
deleted file mode 100644
index 3876f4a42..000000000
--- a/self_hosted/contracts.rkt
+++ /dev/null
@@ -1,32 +0,0 @@
-(define/contract (applesauce x y z)
-    (->/c int? int? int? int?)
-    (+ x y z))
-
-(define/contract (dummy foo bar)
-  (->/c string? integer? (->/c string? string?))
-  (list (int->string bar) foo))
-
-;; Function (Listof String)
-(define/contract (test lst)
-    (->/c (listof string?) (listof string?))
-    lst)
-
-;; Function(Any) -> Listof(Any)
-(lambda (x) (list x))
-
-;; Function(Any, Number) -> Listof( Any, Number)
-(lambda (x y) (list x (+ 1 y)))
-
-(lambda (x y z) (+ x y z)) ;; Function( (int, int, int) -> int )
-
-;; Function ( unknown int ) -> ListOf[ { string, unknown } ]
-;; Lists should be default Listof { any }
-;; But they should be updated to include more information as it gets collected
-;; ListOf can be a contract binding to limit the type information
-;; But by default, it can be _anything_, and therefore inference should just
-;; continue to be the union of anything that gets added to it - in this case, 
-;; list is called concretely with an int and any. Therefore the inferred type should be
-;; List of string and any
-(lambda (foo bar) (list (int->string bar) foo))
-
-; (applesauce 10 20 "hello world") ;; Type Error => "hello world" is a string, expected int
diff --git a/self_hosted/core.rkt b/self_hosted/core.rkt
deleted file mode 100644
index 9b0d1bc81..000000000
--- a/self_hosted/core.rkt
+++ /dev/null
@@ -1,42 +0,0 @@
-(provide
-    list
-    cons
-    range
-    empty
-    car
-    first
-    cdr
-    rest
-    list-ref
-    apply)
-
-
-(define %list list)
-(define list %list)
-
-(define %cons cons)
-(define cons %cons)
-
-(define %range range)
-(define range %range)
-
-(define %empty? empty)
-(define empty %empty)
-
-(define %car car)
-(define car %car)
-
-(define %first first)
-(define first %first)
-
-(define %cdr cdr)
-(define cdr %cdr)
-
-(define %rest rest)
-(define rest %rest)
-
-(define %list-ref list-ref)
-(define list-ref %list-ref)
-
-(define %apply apply)
-(define apply %apply)
\ No newline at end of file
diff --git a/self_hosted/default.rkt b/self_hosted/default.rkt
deleted file mode 100644
index 1ddf80825..000000000
--- a/self_hosted/default.rkt
+++ /dev/null
@@ -1,76 +0,0 @@
-
-;; Default arguments themselves need to be resolves at run time somehow.
-;; The expression for the argument should be moved inside the body, and then at runtime
-;; We dispatch on the arguments that are present in order
-; (define (test [apple <expr>] [bananas <expr>])
-;     ...)
-
-; (test) ;; '()
-; (test 10) ;; '(10)
-; (test 10 20) ;; '(10 20)
-
-;; This should translate to something like this:
-; (define (test . rest)
-;     ;; Bind apple to the rest of the argument
-;     (let ((apple (if (try-list-ref rest 0) 
-;                      (list-ref rest 0) 
-;                      <expr>))
-;           (bananas 
-;             (if (try-list-ref rest 1)
-;                 (list-ref rest 1)
-;                 <expr>)))
-;           body))
-
-(define (enumerate start accum lst)
-  (if (empty? lst)
-      (reverse accum)
-      (enumerate (+ start 1)
-                 (cons (list (car lst) start)
-                       accum)
-                 (cdr lst))))
-
-(define (%lambda% args body)
-    (let (
-          (non-default-bindings (filter (lambda (x) (not (pair? x))) args))
-          (bindings
-            (transduce
-                ;; Now we have attached the index of the list
-                ;; To the iteration
-                (enumerate 0 '() args)
-                ;; extract out the arguments that have a default associated
-                ;; So from the argument list like so:
-                ;; (a b [c <expr>] [d <expr>])
-                ;; We will get out ([c <expr>] [d <expr>])
-                (filtering (lambda (x) (pair? (car x))))
-                ;; Map to the let form of (binding expr)
-                (mapping (lambda (x)
-                    ;; ( (x, expr), index )
-                    ;; TODO: clean this up
-                    (let ((var-name (car (car x)))
-                          (expr (car (cdr (car x))))
-                          (index (car (cdr x))))
-                          `(,var-name (let ((,var-name (try-list-ref !!dummy-rest-arg!! ,index)))
-                                            (if ,var-name ,var-name ,expr))))))
-                (into-list))))
-        ;; TODO: Yes I understand this violates the macro writers bill of rights
-        ;; that being said I'm only doing this as a proof of concept anyway so it can be rewritten
-        ;; to be simpler and put the weight on the compiler later
-        (if (equal? (length args) (length non-default-bindings))
-            `(lambda ,args ,body)
-            ; (displayln "hello world")
-            `(lambda (,@non-default-bindings . !!dummy-rest-arg!!)
-                (let (,@bindings) ,body))
-            ;     ,(if bindings
-            ;         `(let (,@bindings) ,body)
-            ;         body))
-                    
-                    
-                    
-                    )))
-        
-
-
-            
-
-
-(%lambda% '(x y [z "applesauce"]) '(list x y z))
diff --git a/self_hosted/defmacro.rkt b/self_hosted/defmacro.rkt
deleted file mode 100644
index 45bb9951c..000000000
--- a/self_hosted/defmacro.rkt
+++ /dev/null
@@ -1,97 +0,0 @@
-;; TODO: write functions that extract defmacros, turn them into functions that operate on syntax by rewriting them
-;; Evaluate them in a closed world vm - emit back the code that they generate. Run this step in the compilation process.
-
-;; Accepts a defmacro expression and emits a define expression
-(define (rewrite-defmacro define-expr)
-  (cons 'define (cdr define-expr)))
-
-;; Check if the given value is in fact a def macro expression
-(define (defmacro? expression)
-  (and (list? expression) (equal? 'defmacro (car expression))))
-
-;; Returns the name of the defmacro to assist with calling
-(define (extract-macro-name defmacro)
-  (car (cdr defmacro)))
-
-(define (accumulate lst left right predicate)
-  (cond [(empty? lst) => (list (reverse left) (reverse right))]
-        [(predicate (car lst)) => (accumulate (cdr lst) (cons (car lst) left) right predicate)]
-        [else => (accumulate (cdr lst) left (cons (car lst) right) predicate)]))
-
-;; Split a list into two distinct versions based on the predicate
-;; The left list contains all true values
-(define (partition-list lst predicate)
-    (accumulate lst '() '() predicate))
-
-(define program '((defmacro identity (lambda (x) x))
-                  (defmacro other-identity (lambda (x) x))
-                  (defmacro repeat-to-list (lambda (x) (list x x x x x x)))
-                  (defmacro make-struct (lambda (struct-name fields)
-                                          (cons 'begin
-                                                (map (lambda (field)
-                                                       (list 'define
-                                                             (concat-symbols struct-name '- (car field))
-                                                             (list 'lambda
-                                                                   '(this)
-                                                                   (list 'vector-ref 'this (car (cdr field))))))
-                                               (enumerate 0 '() fields)))))
-
-                  (identity 10)
-                  (identity 20)
-                  (other-identity 30)
-                  (define (identity-function x) x)))
-
-(define helpers '(
-                   (define (enumerate start accum lst)
-                    (if (empty? lst)
-                        (reverse accum)
-                        (enumerate (+ start 1)
-                                   (cons (list (car lst) start)
-                                         accum)
-                                   (cdr lst))))
-
-                   ))
-
-
-;; This is going to be our engine
-(define *engine* (Engine::new))
-(run! *engine* helpers)
-
-
-(define partitioned-program (partition-list program defmacro?))
-
-;; corresponds to our macro definitions
-(define defmacro-list (map rewrite-defmacro (list-ref partitioned-program 0)))
-;; The rest of the program excluding the macros
-(define program-list (list-ref partitioned-program 1))
-;; The set of available macros
-(define defmacro-name-set (transduce defmacro-list
-                                     (mapping extract-macro-name)
-                                     (into-hashset)))
-
-;; Registers the functions in our engine
-;; In order to eval a macro expansion, we just have to call the function and extract the output
-(run! *engine* defmacro-list)
-
-
-; ;; Goes into the environment, and calls the given symbol with the arguments passed in as a list
-; ;; This is a bit spooky, but this effectively gives us an evaluation environment for macros
-; (call-function-in-env *engine* 'identity (list
-;                                           '(define x 10)))
-
-
-(define (expand-macros expression macro-set engine)
-  (cond [(symbol? expression) => expression]
-        [(empty? expression) => expression]
-        [(list? expression) =>
-                            (if (hashset-contains? macro-set (car expression))
-                                (begin
-                                  (displayln (cdr expression))
-                                  (expand-macros
-                                   (call-function-in-env engine (car expression) (cdr expression))
-                                   macro-set
-                                   engine))
-                                (map (lambda (expr) (expand-macros expr macro-set engine)) expression))]
-        [else => expression]))
-
-
diff --git a/self_hosted/engine.rkt b/self_hosted/engine.rkt
deleted file mode 100644
index 9d484769b..000000000
--- a/self_hosted/engine.rkt
+++ /dev/null
@@ -1,71 +0,0 @@
-
-
-(define program '(
-
-
-
-(define-syntax ->/c
-  (syntax-rules ()
-    [(->/c r)
-     (make-function/c (make/c r 'r))]
-    [(->/c a b)
-     (make-function/c (make/c a 'a) (make/c b 'b))]
-    [(->/c a b c)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c))]
-    [(->/c a b c d)
-     (make-function/c (make/c a 'a) (make/c b 'b)
-                      (make/c c 'c) (make/c d 'd))]
-    [(->/c a b c d e)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e))]
-    [(->/c a b c d e f)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e) (make/c f 'f))]
-    [(->/c a b c d e f g)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e) (make/c f 'f)
-                      (make/c g 'g))]
-    [(->/c a b c d e f g h)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e) (make/c f 'f)
-                      (make/c g 'g) (make/c h 'h))]
-    [(->/c a b c d e f g h i)
-     (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-                      (make/c d 'd) (make/c e 'e) (make/c f 'f)
-                      (make/c g 'g) (make/c h 'h) (make/c i 'i))]))
-
-;; Macro for basic usage of contracts
-(define-syntax define/contract
-  (syntax-rules ()
-    [(define/contract (name args ...)
-       contract
-       body ...)
-     (define name (bind/c contract (lambda (args ...) body ...) 'name))]
-    [(define/contract name contract expr)
-     (define name ((bind/c
-                      (make-function/c (make/c contract 'contract))
-                      (lambda () expr))))]))
-
-    (define/contract (applesauce x y z)
-        (->/c int? int? int? int?)
-        (+ x y z))
-
-    (define/contract (dummy foo bar)
-      (->/c string? integer? (->/c string? string?))
-      (list (int->string bar) foo))
-
-    ; (define/contract (bananas x y)
-    ;     (->/c string? int? int?)
-    ;     (displayln x)
-    ;     (+ y 20))
-))
-
-(expand! program)
-
-; (define *engine* (Engine::new))
-
-;; Evaluate the program, and interact with the runtime
-; (run! *engine* program)
-
-; (get-value *engine* "applesauce")
-; (get-value *engine* "bananas")
diff --git a/self_hosted/import-unit-test.scm b/self_hosted/import-unit-test.scm
deleted file mode 100644
index d67763010..000000000
--- a/self_hosted/import-unit-test.scm
+++ /dev/null
@@ -1,3 +0,0 @@
-(require "unit-test.rkt" (for-syntax "unit-test.rkt"))
-
-(check-equal? "test" 10 10)
\ No newline at end of file
diff --git a/self_hosted/import.rkt b/self_hosted/import.rkt
deleted file mode 100644
index 624599430..000000000
--- a/self_hosted/import.rkt
+++ /dev/null
@@ -1 +0,0 @@
-(require "contract.rkt")
\ No newline at end of file
diff --git a/self_hosted/interpreter.rkt b/self_hosted/interpreter.rkt
deleted file mode 100644
index cde91affa..000000000
--- a/self_hosted/interpreter.rkt
+++ /dev/null
@@ -1,12 +0,0 @@
-(define (evaluate expr)
-    (let ((func (car expr)))
-        (cond [(equal? func 'if) 
-                => 
-                    (if (evaluate (second expr))
-                        (evaluate (third expr))
-                        (evaluate (fourth expr)))]
-        
-        
-        )
-
-)
\ No newline at end of file
diff --git a/self_hosted/main.rkt b/self_hosted/main.rkt
deleted file mode 100644
index b586c117d..000000000
--- a/self_hosted/main.rkt
+++ /dev/null
@@ -1,21 +0,0 @@
-(require "other.rkt" ;; Normal import
-         (for-syntax "other.rkt") ;; Explicitly for the macros
-        ;  "match.rkt"
-        ;  (for-syntax "match.rkt")
-         )
-
-(define (black-box x) x)
-
-(dummy (black-box #t) (black-box #f))
-
-
-; (dummy2 (black-box #t)
-;     (hello-world))
-; (hello-world)
-
-;; -> 
-; (test "Matches patterns with constants mixed in"
-; (displayln 
-;     (match! (list 1 2 3 4 5)
-;         ((?x 2 ?y 4 ?z) (+ ?x ?y ?z))))
-    ;   (+ 1 3 5))
\ No newline at end of file
diff --git a/self_hosted/match.rkt b/self_hosted/match.rkt
deleted file mode 100644
index 8a10d8a95..000000000
--- a/self_hosted/match.rkt
+++ /dev/null
@@ -1,553 +0,0 @@
-;; Sets of useful ideas for things
-;; #lang racket
-
-;; ------------------- match functions ----------------------
-
-;; Tells me if this is a free variable (for now)
-(define (var? x)
-  (and (symbol? x)
-       (starts-with? (symbol->string x) "?")))
-
-(define (ignore? x)
-  (equal? x '_))
-
-(define (many? x)
-  (and (symbol? x)
-       (let ((str (symbol->string x)))
-         (and (starts-with? str "?")
-              (ends-with? str "...")))))
-
-
-(define (equal-or-insert hm key value)
-  (define existing-value (hash-try-get hm key))
-  (if existing-value
-      (if (equal? existing-value value)
-          hm
-          #f
-          ;; (error! "Duplicate bindings found for variable: " key)
-          )
-      (hash-insert hm key value)))
-
-(define (collect-until-last-p input collected)
-  (if (null? (cdr input))
-      (list (car input) collected)
-      (collect-until-last-p (cdr input) (cons (car input) collected))))
-
-
-(define (collect-until-last input)
-  (collect-until-last-p input '()))
-
-
-;; Bindings or #false if there is not a match
-(define (match-p pattern input bindings)
-  (cond
-    ;; If its a struct, immediately do the conversion
-    ;; TODO bug arity check is not happening here
-    [(and (list? pattern) (struct? input)) (match-p pattern (struct->list input) bindings)]
-    [(and (list? pattern)
-          (not (null? pattern))
-          (many? (car pattern)))
-     (if (null? (cdr pattern))
-         (equal-or-insert bindings (car pattern) input)
-         (let ((collected (collect-until-last input)))
-           (define remainder (car collected))
-           (define collected-list (reverse (car (cdr collected))))
-           (if (null? (cdr (cdr pattern)))
-               (let ((remainder-bound
-                      (equal-or-insert bindings
-                                       (car (cdr pattern)) remainder)))
-                 (equal-or-insert remainder-bound (car pattern) collected-list))
-               #f)))]
-    [(var? pattern) (equal-or-insert bindings pattern input)]
-    [(ignore? pattern) bindings]
-    [(atom? pattern) (if (equal? pattern input) bindings #f)]
-    [(null? pattern) (if (null? input) bindings #f)]
-    [(null? input) #f]
-    [(and (list? pattern) (not (list? input))) #f]
-    [else
-     (define remaining (match-p (cdr pattern) (cdr input) bindings))
-     (if remaining
-         (match-p (car pattern) (car input) remaining)
-         #f)]))
-
-(define (match pattern input)
-  (match-p pattern input (hash)))
-
-
-;; ---------------- tests --------------------
-
-;; Pretty print for testing purposes
-(define (test name input expected)
-  (if (equal? input expected)
-      (begin
-        (display "> ")
-        (display name)
-        (display " ... ")
-        (display-color "OK" 'green)
-        (newline))
-      (begin
-        (display "> ")
-        (display name)
-        (display " ... ")
-        (display-color "FAILED" 'red)
-        (newline)
-        (display "    Expected: ")
-        (display expected)
-        (display ", Found ")
-        (displayln input))))
-
-(displayln "--------------------- match tests ----------------------")
-
-;; Matches a pattern explicitly
-(test "Simple match" 
-      (match '?x '(1 2 3 4))
-      (hash '?x '(1 2 3 4)))
-
-;; If the pattern match fails, return false
-(test "Pattern match fails returns false"
-      (match '(10 2 ?z 5) '(1 2 3 4))
-      #f)
-
-;; If the pattern fails because we didn't match exactly, bail
-(test "Pattern fails because constants don't match exactly"
-      (match '(1 2 3 4 5) '(1 2 3 4))
-      #f)
-
-;; Should fail
-(test "Lengths unequal fails"
-      (match '(?x ?y ?z 4 5) '(1 2 3 4))
-      #f)
-
-;; Should succeed with x y z bound to 1 2 3
-(test "Successful pattern match on simple list"
-      (match '(?x ?y ?z 4 5) '(1 2 3 4 5))
-      (hash '?x 1 '?y 2 '?z 3))
-
-;; Should succed with x y z bound to 1 2 3
-(test "Nested patterns match"
-      (match '(?x (?y ?z)) '(1 '(2 3)))
-      (hash '?x 1 '?y 2 '?z 3))
-
-;; Also should work
-(test "Deep nested pattern"
-      (match '(?x (?y (?z (?applesauce ?bananas))))
-        '(1 (2 (3 (4 5)))))
-      (hash '?x 1 '?y 2 '?z 3 '?applesauce 4 '?bananas 5))
-
-
-;; Also should work
-(test "Deep nested pattern with list matching"
-      (match '(?x (?y (?z (?applesauce ?bananas))))
-        '(1 (2 (3 (4 (1 2 3 4 5))))))
-      (hash '?x 1 '?y 2 '?z 3 '?applesauce 4 '?bananas '(1 2 3 4 5)))
-
-
-;; Match the bindings
-(test "Pattern variables once bound retain their value"
-      (match '(?x ?y ?x) '(1 2 1))
-      (hash '?x 1 '?y 2))
-
-;; Should fail since x doesn't match what was there at first
-(test "Matching fails when variable has two different values"
-      (match '(?x ?y ?x) '(1 2 3))
-      #f)
-
-;; Shouldn't fail, should ignore whatever is in the second position
-(test "Wildcard ignores the matching at that position"
-      (match '(?x _ 3) '(1 (1 2 3) 3))
-      (hash '?x 1))
-
-;; a => 1
-;; x => '(2 3 4 5)
-(test "Basic ellipses matching works"
-      (match '(?a ?x...) '(1 2 3 4 5))
-      (hash '?a 1 '?x... '(2 3 4 5)))
-
-
-(test "Ellipses matches to empty list"
-      (match '(?first ?rest...) '(1))
-      (hash '?first 1 '?rest... '()))
-
-
-(test "Ellipses matches until next value"
-      (match '(?first ?rest... ?last) '(1 2 3 4 5))
-      (hash '?first 1 '?rest... '(2 3 4) '?last 5))
-
-; TODO this should error out as illegal pattern
-(test "Ellipses does not match multiple characters at the end"
-      (match '(?first ?rest... ?second-last ?last) '(1 2 3 4 5 6))
-      #f
-      ; (hash '?first 1 '?rest... '(2 3 4) '?last 5 '?last 6)
-      )
-
-(test "Ellipses with nested pattern"
-      (match '(?x (?y ?z (?foo ?bar...))) '(1 (2 3 (4 5 6 7 8 9 10))))
-      (hash '?x 1 '?y 2 '?z 3 '?foo 4 '?bar... '(5 6 7 8 9 10)))
-
-
-(test "Empty pattern matches empty list"
-      (match '() '())
-      (hash))
-
-(test "Empty pattern fails on non empty list"
-      (match '() '(1 2 3))
-      #f)
-
-(test "Single variable with empty list"
-      (match '?x '())
-      (hash '?x '()))
-
-(test "Constant matches constant"
-      (match (list 1 2 3) (list 1 2 3))
-      (hash))
-
-(test "List pattern does not match constant"
-      (match (list 1 2 3 4 5) 10)
-      #f)
-
-(test "Constant pattern does not match list"
-      (match 10 (list 1 2 3 4 5))
-      #f)
-
-(test "Wildcard passes"
-      (match '_ (list 1 2 3 4 5))
-      (hash))
-
-
-;; ----------------- match! syntax --------------------
-
-
-(define-syntax syntax->pattern
-  (syntax-rules ()
-    [(syntax->pattern (var1))
-     '(var1)]
-    [(syntax->pattern (var1 var2 ...))
-       (cons 'var1 (syntax->pattern (var2 ...)))]
-    [(syntax->pattern var)
-     'var]))
-
-;; TODO -> rename the variables to have an extra binding on them
-;; when the get used in the let 
-(define-syntax syntax-pattern->lets
-  (syntax-rules ()
-    [(syntax-pattern->lets ((var1)) bindings body)
-     (syntax-pattern->lets (var1) bindings body)]
-    [(syntax-pattern->lets ((var1 ...) rest ...) bindings body)
-     (syntax-pattern->lets (var1 ...) bindings
-                           (syntax-pattern->lets (rest ...) bindings body))]
-    [(syntax-pattern->lets (var1) bindings body)
-     ;; TODO
-     (syntax-const-if var1 body
-                      (let ((var1 (hash-try-get bindings 'var1)))
-                        body))]
-    [(syntax-pattern->lets (var1 var2 ...) bindings body)
-     (syntax-const-if var1
-                      (syntax-pattern->lets (var2 ...) bindings body)
-                      (let ((var1 (hash-try-get bindings 'var1)))
-                        (syntax-pattern->lets (var2 ...) bindings body)))]
-    [(syntax-pattern->lets () bindings body)
-     body]
-    [(syntax-pattern->lets var bindings body)
-     (syntax-const-if var body
-                      (let ((var (hash-try-get bindings 'var)))
-                        body))]))
-
-
-
-;; TODO add case for the remaining - when there is no else case given
-;; and it should just error out
-(define-syntax match-dispatch
-  (syntax-rules (else)
-    ;; Explicitly giving an else case
-    [(match-dispatch expr [else e1 ...])
-     (begin e1 ...)]
-    ;; Generic recursive case
-    [(match-dispatch expr [p1 e2 ...] c1 ...)
-     (let ((match? (match (syntax->pattern p1) expr)))
-       (if match?
-           (syntax-pattern->lets p1 match? (begin e2 ...))
-           (match-dispatch expr c1 ...)))]
-    ;; When there isn't an else case given, the last case
-    ;; Should include a failure mode
-    [(match-dispatch expr (p1 e2 ...))
-     (let ((match? (match (syntax->pattern p1) expr)))
-       (if match?
-           (syntax-pattern->lets p1 match? (begin e2 ...))
-           (error! "Unable to match expression: " expr " to any of the given patterns")))]))
-
-
-(define-syntax match!
-  (syntax-rules ()
-    [(match expr pat)
-     (let ((evald-expr expr))
-       (match-dispatch evald-expr pat))]
-    [(match expr pats ...)
-     (let ((evald-expr expr))
-       (match-dispatch evald-expr pats ...))]))
-
-
-;; --------------------- match! tests ------------------------
-
-(displayln "--------------------- match! tests ----------------------")
-
-(test "Matches constant patterns"
-      (match! (list 1 2 3 4 5)
-              ((1 2 3 4 5) 'case1))
-      'case1)
-
-
-(test "Matches patterns with constants mixed in"
-      (match! (list 1 2 3 4 5)
-              ((?x 2 ?y 4 ?z) (+ ?x ?y ?z)))
-      (+ 1 3 5))
-
-(test "Dispatches on first of multiple matching patterns"
-      (match! (list 1 2 3 4 5)
-              (?x 'case1)
-              ((?a ?b ?c ? d ?e) 'case2))
-      'case1)
-
-(test "Constants match"
-      (match! 10
-              (10 'case1))
-      'case1)
-
-(test "Successfully takes the else case on no match"
-      (match! (list 1 (list 2 (list 3)))
-              ((?x ?y ?z) 'case1)
-              (24 'case2)
-              (else 'case3))
-      'case3)
-
-
-(test "Custom map implementation succeeds"
-      ((lambda ()
-         (define (budget-map func lst)
-           (define (loop lst accum)
-             (match! lst
-                     (() accum)
-                     ((?x ?xs...)
-                      (loop ?xs...
-                            (cons (func ?x) accum)))))
-           (reverse (loop lst '())))
-         (budget-map (fn (x) (+ x 1)) (list 1 2 3 4 5))))
-      '(2 3 4 5 6))
-
-(test "Empty list matches empty list"
-      (match! '()
-              (() 'found-empty-list!)
-              ((?x ?xs...) 'found-list!))
-      'found-empty-list!)
-
-(test "Nested patterns match with bindings"
-      (match! (list (list 1 2) 3 (list 4 (list 5 6)))
-              (((?a 2) ?b (?c (5 6))) (+ ?a ?b ?c)))
-      (+ 1 3 4))
-
-
-(define-syntax begin-scope
-  (syntax-rules ()
-    ((begin-scope body ...)
-     ((fn () body ...)))))
-
-(test "Struct matching"
-      (begin-scope
-         (struct Apples (a b c))
-         (match! (Apples 10 30 50)
-                 ((Apples ?x ?y ?z) (+ ?x ?y ?z))))
-      (+ 10 30 50))
-
-
-(test "Nested struct matching"
-      (begin-scope
-        (struct Apples (a b c))
-        (match! (Apples (Apples (Apples 10 30 50) 1 2) 3 4)
-                ((Apples (Apples (Apples ?x ?y ?z) _ _) _ _)
-                 (+ ?x ?y ?z))))
-      (+ 10 30 50))
-
-
-(struct Add (l r))
-(struct Sub (l r))
-(struct Num (n))
-(struct String (s))
-
-(define (calculate expr)
-  (match! expr
-          ((Num ?n) ?n)
-          ((Sub ?l ?r) (- (calculate ?l) (calculate ?r)))
-          ((Add ?l ?r) (+ (calculate ?l) (calculate ?r)))))
-
-;; TODO -> add pass that rewrites special forms on the way down
-;; that way an identifier that _is_ a special form will not be registered as one - just blanket
-;; rewrite anything like that
-(match! '(define x 10)
-      ((define x 10) "matched")
-      (else 'didnt-match))
-
-;; TODO provide stack trace on errors for debug builds
-;; collecting stack trace should just be:
-;; Go to function stack: Print out last executing functions with their spans
-;; Map spans to file + call site - print out underneath the function information
-;; Will help with errors inside functions, the callstack will tell me where things actually
-;; went wrong
-
-
-;; (displayln (calculate (Add (Add (Num 10) (Num 25)) (Sub (Num 100) (Num 300)))))
-
-; (struct Some (type inner))
-; (struct None (type))
-
-
-; (struct tuple (inner))
-; (displayln (t
-
-
-; (struct Tuple (inner))
-
-; (define-syntax tuple
-;   (syntax-rules ()
-;     [(tuple arg ...) (Tuple (vector arg ...))]))
-
-
-
-; (displayln (tuple 1 2 3 4 5))
-
-
-
-
-; (define-syntax case-lambda
-;   (syntax-rules ()
-;     ((case-lambda)
-;      (lambda args
-;        (error "CASE-LAMBDA without any clauses.")))
-;     ((case-lambda 
-;       (?a1 ?e1 ...) 
-;       ?clause1 ...)
-;      (lambda args
-;        (let ((l (length args)))
-;          (case-lambda "CLAUSE" args l 
-;            (?a1 ?e1 ...)
-;            ?clause1 ...))))
-;     ((case-lambda "CLAUSE" ?args ?l 
-;       ((?a1 ...) ?e1 ...) 
-;       ?clause1 ...)
-;      (if (= ?l (length '(?a1 ...)))
-;          (apply (lambda (?a1 ...) ?e1 ...) ?args)
-;          (case-lambda "CLAUSE" ?args ?l 
-;            ?clause1 ...)))
-;     ((case-lambda "CLAUSE" ?args ?l
-;       ((?a1 . ?ar) ?e1 ...) 
-;       ?clause1 ...)
-;      (case-lambda "IMPROPER" ?args ?l 1 (?a1 . ?ar) (?ar ?e1 ...) 
-;        ?clause1 ...))
-;     ((case-lambda "CLAUSE" ?args ?l 
-;       (?a1 ?e1 ...)
-;       ?clause1 ...)
-;      (let ((?a1 ?args))
-;        ?e1 ...))
-;     ((case-lambda "CLAUSE" ?args ?l)
-;      (error "Wrong number of arguments to CASE-LAMBDA."))
-;     ((case-lambda "IMPROPER" ?args ?l ?k ?al ((?a1 . ?ar) ?e1 ...)
-;       ?clause1 ...)
-;      (case-lambda "IMPROPER" ?args ?l (+ ?k 1) ?al (?ar ?e1 ...) 
-;       ?clause1 ...))
-;     ((case-lambda "IMPROPER" ?args ?l ?k ?al (?ar ?e1 ...) 
-;       ?clause1 ...)
-;      (if (>= ?l ?k)
-;          (apply (lambda ?al ?e1 ...) ?args)
-;          (case-lambda "CLAUSE" ?args ?l 
-;            ?clause1 ...)))))
-  
-; (define plus
-;       (case-lambda 
-;             (() 0)
-;             ((x) x)
-;             ((x y) (+ x y))
-;             ((x y z) (+ (+ x y) z))
-;             (args (apply + args))))
-
-; (plus)                     
-; (plus 1)                   
-; (plus 1 2 3)
-
-
-;; (test "Matching duplicate names fails"
-;;       (match! (list 1 2 3 4 5)
-;;               ((?x ?x ?x ?x ?x) 'should-fail))
-;;       #f)
-
-
-;; match struct
-;; given a value, destruct it into each variables positions
-
-;; (struct Apple ())
-;; (struct Banana ())
-;; (struct Fruit ())
-;; (struct Burger ())
-
-;; (displayln (struct-ref (Apple) 2))
-
-
-;; (define (which-struct? s)
-;;   (cond [(Apple? s) 'Apple]
-;;         [(Banana? s) 'Banana]
-;;         [(Fruit? s) 'Fruit]
-;;         [else 'Unknown]))
-
-;; (displayln (which-struct? (Apple)))
-;; (displayln (which-struct? (Banana)))
-;; (displayln (which-struct? (Fruit)))
-;; (displayln (which-struct? (Burger)))
-
-;; When its a struct, we want to pop off the first pattern
-;; Keywords inside quotes expressions do not work properly
-; (displayln (match (quote (Apple y z)) '(x y z)))
-
-
-;; (displayln (match '(?x y z) (list 10 'y 'z)))
-
-
-; '(Apple 1 2 3)
-
-;; (struct Applesauce (a b c))
-
-;; (define (struct-pattern->indices pat)
-;;       (define (loop pat accum seed)
-;;             (if (null? pat)
-;;                   accum
-;;                   (let ((next-index (+ 1 seed)))
-;;                         (loop (cdr pat) (cons next-index accum) next-index))))
-;;       (reverse (loop (cdr pat) '() -1)))
-
-;; (displayln (struct-pattern->indices '(Applesauce ?x ?y z)))
-;; (displayln (struct-pattern->indices '(Unit-Struct)))
-
-
-;; (displayln (struct->list (Applesauce 10 45 90)))
-
-;; (displayln
-;;  (match '(Applesauce ?x ?y ?z)
-;;    (struct->list (Applesauce (Applesauce 10 20 30) 45 90))))
-
-
-;; (displayln
-;;  (match! (Applesauce (Applesauce 10 20 30) 2 3)
-;;          ((Applesauce (Applesauce ?x ?y ?z) 2 3) (+ ?x ?y ?z))
-;;          (else 'no-match)))
-
-;; (define-syntax match-struct
-;;   (syntax-rules ()
-;;     [(match-struct struct-name pattern expr)
-;;      (if ((datum->syntax struct-name?) expr)
-;;          (match (cdr pattern) (struct->list expr)))]))
-
-
-; (define (match-struct pattern struct bindings)
-      
-
-
-; )
-
-
-;; (define (match-wrapper pattern expr
diff --git a/self_hosted/meta.rkt b/self_hosted/meta.rkt
deleted file mode 100644
index 91a074b02..000000000
--- a/self_hosted/meta.rkt
+++ /dev/null
@@ -1,85 +0,0 @@
-(define program '(
-
-    (define-syntax when
-        (syntax-rules ()
-            [(when a b ...)
-                (if a (begin b ...) void)]))
-
-    (define-syntax cond
-        (syntax-rules (else =>)
-            [(cond [else => e1 ...])
-                (begin e1 ...)]
-            [(cond [else e1 ...])
-                (begin e1 ...)]
-            [(cond [e1 e2 ...])
-                (when e1 e2 ...)]
-            [(cond [e1 => e2 ...] c1 ...)
-                (if e1
-                    (begin e2 ...)
-                    (cond c1 ...))]
-            [(cond [e1 e2 ...] c1 ...)
-                (if e1
-                    (begin e2 ...)
-                    (cond c1 ...))]))
-    
-    (define (foo x) 
-        (cond [(equal? x 10) => 27]
-              [else => 100]))
-
-    (foo 10)
-    
-))
-
-;; Yoink out the macros, do any reader expansions
-;; Then move on with the program, returning whats left
-(expand! program) ;; => '((define foo (lambda (x) ...)))
-
-
-;; If functions are pure, run those and save their results
-;; Have a way to determine _if_ the function is pure
-
-(define (list-any? list pred)
-    (cond [(empty? list) => #f]
-          [(pred (car list)) => #t]
-          [else => (list-any? (cdr list) pred)]))
-
-;; Walk the tree -> does it contain a function from the given set?
-;; If so, bail out and return true as soon as its discovered
-(define (contains-set? expr)
-    (function-call-checker (lambda (x) (equal? x 'set!)) expr))
-
-(define (function-call-checker pred expr)
-    (displayln expr)
-    (cond
-        [(list? expr)
-         (let ((sym (car expr)))
-            (cond ;; (set! <ident> <expr>)
-                  [(pred sym) => #t]
-                  [else => (list-any? expr contains-set?)]))]
-        [else #f]))
-
-; (run! *my-engine* other-program)
-
-
-(define test-program
-    '(define function-with-set 
-        (lambda (x) 
-            (let ((z 100) (y 200))
-                (set! z x)
-                (+ x y z)))))
-
-(contains-set?  test-program)
-
-
-
-
-;; TODO: add reader macros passes to this as well
-;; Marks primitives with contracts as well...
-;; Multi arity functions with contracts probably doesn't work very well
-;; Core macros can be pre processed and cached in the binary
-
-;; Add handle to the current context?
-;; Eval should also be possible... It would need to be compiled down to
-;; Bytecode directly inside the interpreter
-;; Do this by exposing the symbol map and make a new instance of the compiler
-;; This requires re architecting the current implementation
diff --git a/self_hosted/other.rkt b/self_hosted/other.rkt
deleted file mode 100644
index 14d2e419c..000000000
--- a/self_hosted/other.rkt
+++ /dev/null
@@ -1,14 +0,0 @@
-(provide __temp__ (for-syntax dummy)) 
-
-(define (hello-world) (displayln "hello-world!"))
-(define __temp__ 10)
-
-(define-syntax dummy
-  (syntax-rules ()
-    [(dummy a b ...)
-     (if a (begin (hello-world) b ...) void)]))
-
-(define-syntax dummy2
-  (syntax-rules ()
-    [(dummy2 a b ...)
-     (if a (begin b ...) void)]))
\ No newline at end of file
diff --git a/self_hosted/printing.rkt b/self_hosted/printing.rkt
deleted file mode 100644
index 46fa884ae..000000000
--- a/self_hosted/printing.rkt
+++ /dev/null
@@ -1,30 +0,0 @@
-
-
-
-
-(define/contract (struct-name s)
-  (->/c custom-struct? symbol?)
-  (mut-vector-ref s 1))
-
-
-; (define (displayln . rest)
-;   (transduce rest
-;              (into-for-each (lambda (x) (display " "))))
-;   (newline))
-
-; (displayln "hello" "world" "this" "is" "multiple" "values")
-
-
-(define (println x)
-  (displayln 
-    (if (custom-struct? x)
-      (string-append "#<"
-                     (string-append
-                      (symbol->string (struct-name x))
-                     ">"))
-      x)))
-
-
-(struct Applesauce (a b c))
-
-(println (Applesauce 1 2 3))
diff --git a/self_hosted/program.rkt b/self_hosted/program.rkt
deleted file mode 100644
index 6ac0aff6e..000000000
--- a/self_hosted/program.rkt
+++ /dev/null
@@ -1,11 +0,0 @@
-; (define foo 
-;         (lambda (x) 
-;             (+ (if #t x 20) 
-;                 x 
-;                 (begin 10 20 30 
-;                     (set! x 30)))))
-
-
-(define hello-world (lambda () (displayln "hello world!")))
-
-(hello-world)
\ No newline at end of file
diff --git a/self_hosted/provide.rkt b/self_hosted/provide.rkt
deleted file mode 100644
index a724bb0d5..000000000
--- a/self_hosted/provide.rkt
+++ /dev/null
@@ -1,12 +0,0 @@
-; #lang racket
-
-(provide get-apple mutate-apple)
-
-(define apple (lambda () 10))
-
-(define (get-apple) apple)
-
-(define (mutate-apple)
-    (set! apple (lambda () 100)))
-
-(struct Applesauce (a b c) #:mutable)
\ No newline at end of file
diff --git a/self_hosted/require.rkt b/self_hosted/require.rkt
deleted file mode 100644
index 76137c125..000000000
--- a/self_hosted/require.rkt
+++ /dev/null
@@ -1,21 +0,0 @@
-; #lang racket
-
-; (require "provide.rkt")
-
-;; TODO: if _all_ modules just get loaded and prefixed with their name, we should be okay
-;; and subsequently, if modules in loaded modules get prefixed with 
-(require "unit-test.rkt" 
-         (for-syntax "unit-test.rkt"))
-
-; (displayln list)
-
-; (displayln ((get-apple)))
-; (mutate-apple)
-; (displayln ((get-apple)))
-
-; (Applesauce 1 2 3)
-
-(test-module
-    (check-equal? "Applesauce bananas" 
-                  (+ 10 20 30) 
-                  (+ 10 20 30)))
diff --git a/self_hosted/struct.rkt b/self_hosted/struct.rkt
deleted file mode 100644
index 3d3b68adc..000000000
--- a/self_hosted/struct.rkt
+++ /dev/null
@@ -1,79 +0,0 @@
-;; Enumerate the given list starting at index `start`
-(define (enumerate start accum lst)
-  (if (empty? lst)
-      (reverse accum)
-      (enumerate (+ start 1)
-                 (cons (list (car lst) start)
-                       accum)
-                 (cdr lst))))
-
-(define (hash->list hm)
-  (transduce (transduce hm (into-list))
-             (mapping (lambda (pair)
-                        ;; If we have a symbol as a key, that means we need to quote it before
-                        ;; we put it back into the map
-                        (if (symbol? (car pair))
-                            ;; TODO: @Matt - this causes a parser error
-                            ;; (cons `(quote ,(car x)) (cdr x))
-                            (cons (list 'quote (car pair)) (cdr pair))
-                            pair)))
-             (flattening)
-             (into-list)))
-
-
-(define (test-make-struct struct-name fields . options)
-
-  (define field-count (length fields))
-
-  (when (not (list? fields))
-    (error! "make-struct expects a list of field names, found " fields))
-
-  (when (not (symbol? struct-name))
-    (error! "make-struct expects an identifier as the first argument, found " struct-name))
-
-  (when (odd? (length options))
-    (error! "make-struct options are malformed - each option requires a value"))
-
-  (let ((options-map (apply hash options)))
-    `(begin
-        (define ,struct-name 'unintialized)
-        (define ,(concat-symbols struct-name '?) 'uninitialized)
-        ,@(map (lambda (field) `(define ,(concat-symbols struct-name '- field) 'uninitialized)) fields)
-        ,@(map (lambda (field) `(define ,(concat-symbols 'set- struct-name '- field '!) 'unintialized)) fields)
-
-
-        (let ((prototypes (make-struct-type struct-name ,field-count)))
-          (let ((constructor-proto (list-ref 0 prototypes))
-                (predicate-proto (list-ref 1 prototypes))
-                (getter-proto (list-ref 2 prototypes))
-                (setter-proto (list-ref 3 prototypes)))
-
-              ,(new-make-constructor struct-name)
-              ,(new-make-predicate struct-name fields)
-              ,@(new-make-getters struct-name fields)
-              ,@(new-make-setters struct-name fields)
-))
-        
-        )))
-
-
-(define (new-make-predicate struct-name fields)
-  `(set! ,(concat-symbols struct-name '?) predicate-proto))
-
-(define (new-make-constructor struct-name)
-  `(set! ,struct-name constructor-proto))
-
-
-(define (new-make-getters struct-name fields)
-  (map (lambda (field)
-          `(set! ,(concat-symbols struct-name '- (car field))
-              (lambda (this) (getter-proto this ,(list-ref field 1)))))
-       (enumerate 0 '() fields)))
-
-(define (new-make-setters struct-name fields)
-  (map (lambda (field)
-          `(set! ,(concat-symbols 'set- struct-name '- (car field) '!)
-              (lambda (this value) (setter-proto this ,(list-ref field 1) value))))
-       (enumerate 0 '() fields)))
-
-(test-make-struct 'Applesauce '(a b c))
\ No newline at end of file
diff --git a/self_hosted/structs.rkt b/self_hosted/structs.rkt
deleted file mode 100644
index 0ced208bb..000000000
--- a/self_hosted/structs.rkt
+++ /dev/null
@@ -1,20 +0,0 @@
-(provide
- struct-name
- struct-transparent?
- struct-printer)
-
-(define/contract (struct-name s)
-  (->/c custom-struct? symbol?)
-  (mut-vector-ref s 1))
-
-(define/contract (struct-transparent? s)
-  (->/c custom-struct? boolean?)
-  (hash-try-get (mut-vector-ref s 2) ':transparent))
-
-(define/contract (struct-printer s)
-  (->/c custom-struct? (or/c function? boolean?))
-  (hash-try-get (mut-vector-ref s 2) ':printer))
-
-;; TODO: Make the core environment built up over the course of the macros
-;; wrap core to make sure that the core things don't get overwritten
-;; And put each of the modules in their own modules, exposing the syntax correctly as well
\ No newline at end of file
diff --git a/self_hosted/syntax-rules.rkt b/self_hosted/syntax-rules.rkt
deleted file mode 100644
index d42983b63..000000000
--- a/self_hosted/syntax-rules.rkt
+++ /dev/null
@@ -1,109 +0,0 @@
-
-
-(struct SyntaxRules (name syntaxes patterns) #:transparent)
-
-(define (check-first expression symbol)
-    (equal? (first expression) symbol))
-
-(define (define-syntax? expression) (check-first expression 'define-syntax))
-
-(define (syntax-rules? lst) (check-first lst 'syntax-rules))
-
-(define (syntax-rules->struct name lst)
-    (SyntaxRules name (second lst) (rest (rest lst))))
-
-(define test-syntax-rules 
-    (syntax-rules->struct 'or
-        '(syntax-rules ()
-            [(or) #f]
-            [(or x) x]
-            [(or x y) (let ([z x])
-                        (if z z y))]
-            [(or x y ...) (or x (or y ...))])))
-
-
-;; ----- Matcher -----
-
-(define (var? x)
-  (and (symbol? x)
-       (starts-with? (symbol->string x) "?")))
-
-(define (ignore? x)
-  (equal? x '_))
-
-(define (many? x)
-  (and (symbol? x)
-       (let ((str (symbol->string x)))
-         (and (starts-with? str "?")
-              (ends-with? str "...")))))
-
-
-(define (equal-or-insert hm key value)
-  (define existing-value (hash-try-get hm key))
-  (if existing-value
-      (if (equal? existing-value value)
-          hm
-          #f)
-      (hash-insert hm key value)))
-
-(define (hash-get-or-else hm key value)
-    (define found (hash-try-get hm key))
-    (if found found value))
-
-(define (collect-until-last-p input collected)
-  (if (null? (cdr input))
-      (list (car input) collected)
-      (collect-until-last-p (cdr input) (cons (car input) collected))))
-
-
-(define (collect-until-last input)
-  (collect-until-last-p input '()))
-
-
-;; Bindings or #false if there is not a match
-(define (match-p pattern input bindings)
-  (cond [(and (list? pattern)
-              (not (null? pattern))
-              (many? (car pattern)))
-         (if (null? (cdr pattern))
-             (equal-or-insert bindings (car pattern) input)
-             (let ((collected (collect-until-last input)))
-               (define remainder (car collected))
-               (define collected-list (reverse (car (cdr collected))))
-               (if (null? (cdr (cdr pattern)))
-                   (let ((remainder-bound
-                          (equal-or-insert bindings
-                                           (car (cdr pattern)) remainder)))
-                     (equal-or-insert remainder-bound (car pattern) collected-list))
-                   #f)))]
-        [(var? pattern) (equal-or-insert bindings pattern input)]
-        [(ignore? pattern) bindings]
-        [(atom? pattern) (if (equal? pattern input) bindings #f)]
-        [(null? pattern) (if (null? input) bindings #f)]
-        [(null? input) #f]
-        [(and (list? pattern) (not (list? input))) #f]
-        [else
-         (define remaining (match-p (cdr pattern) (cdr input) bindings))
-         (if remaining
-             (match-p (car pattern) (car input) remaining)
-             #f)]))
-
-(define (match pattern input)
-  (match-p pattern input (hash)))
-
-
-(define (contains? pred? lst)
-    (cond [(empty? lst) #f]
-          [(pred? (car lst)) #t]
-          [else (contains? pred? (cdr lst))]))
-
-
-(define (replace-bindings bindings expression)
-    (cond [(atom? expression) (hash-get-or-else bindings expression expression)]
-          [(list? expression) => (map (lambda (x) (replace-bindings bindings x)) expression)]
-          [else => (error! "Something went wrong in replace bindings")]))
-
-(define (collect-free-vars pattern syntax)
-    (cond [(symbol? pattern) (if (contains? (lambda (x) (equal? x pattern)) syntax) '() (list pattern))]
-          [(list? pattern) (transduce pattern (flat-mapping (lambda (x) (collect-free-vars x syntax))) (into-list))]
-          [else => (error! "Something went from in collect-free-vars")]))
diff --git a/self_hosted/transducers/expanded.rkt b/self_hosted/transducers/expanded.rkt
deleted file mode 100644
index 61291f70f..000000000
--- a/self_hosted/transducers/expanded.rkt
+++ /dev/null
@@ -1,211 +0,0 @@
-(begin
-      (define ___reduced-options___
-        (hash))
-      (define reduced
-        (quote
-          unintialized))
-      (define reduced?
-        (quote
-          uninitialized))
-      (define reduced-val
-        (quote
-          uninitialized))
-      (define set-reduced-val!
-        (quote
-          unintialized))
-      (let ((prototypes (make-struct-type
-             (quote
-               reduced)
-             2)))
-        (let ((constructor-proto (list-ref prototypes 0))
-            (predicate-proto (list-ref prototypes 1))
-            (getter-proto (list-ref prototypes 2))
-            (setter-proto (list-ref prototypes 3)))
-          (begin
-                (set! reduced
-                  (λ (val)
-                    (constructor-proto
-                       ___reduced-options___
-                       val)))
-                (set! reduced? predicate-proto)
-                (set! reduced-val
-                  (λ (this)
-                    (getter-proto this 1)))
-                (set! set-reduced-val!
-                  (λ (this value)
-                    (setter-proto this 1 value)))
-                void))))
-
-(define unreduce
-  reduced-val)
-
-(define ensure-reduced
-  (λ (x)
-    (if (reduced? x) x (reduced x))))
-
-(define preserving-reduced
-  (λ (reducer)
-    (λ (a b)
-      (let ((return (reducer a b)))
-        (if (reduced? return) (reduced return) return)))))
-
-(define list-reduce
-  (λ (f identity lst)
-    (if (null? lst)
-      identity
-      (let ((v (f identity (car lst))))
-        (if (reduced? v)
-          (unreduce v)
-          (list-reduce f v (cdr lst)))))))
-
-(begin
-      (define ___<Nothing>-options___
-        (hash))
-      (define <Nothing>
-        (quote
-          unintialized))
-      (define <Nothing>?
-        (quote
-          uninitialized))
-      (let ((prototypes (make-struct-type
-             (quote
-               <Nothing>)
-             1)))
-        (let ((constructor-proto (list-ref prototypes 0))
-            (predicate-proto (list-ref prototypes 1))
-            (getter-proto (list-ref prototypes 2))
-            (setter-proto (list-ref prototypes 3)))
-          (begin
-                (set! <Nothing>
-                  (λ ()
-                    (constructor-proto
-                       ___<Nothing>-options___)))
-                (set! <Nothing>? predicate-proto)
-                void))))
-
-(define nothing
-  (<Nothing>))
-
-(define nothing?
-  <Nothing>?)
-
-(define ensure-reduced
-  (λ (x)
-    (if (reduced? x) x (reduced x))))
-
-(define preserving-reduced
-  (λ (f)
-    (λ (a b)
-      (let ((return (f a b)))
-        (if (reduced? return) (reduced return) return)))))
-
-(define rcons
-  (λ args
-    ; (displayln "Calling rcons!")
-    (let ((l (length args)))
-      (if (= l (length (quote ())))
-        (apply (λ () (quote ())) args)
-        (if (= l (length (quote (lst))))
-          (apply (λ (lst) (reverse lst)) args)
-          (if (= l (length (quote (lst x))))
-            (apply (λ (lst x) (cons x lst)) args)
-            (error! "Arity mismatch")))))))
-
-; (define reverse-rcons
-;   (λ args
-;     (let ((l (length args)))
-;       (if (= l (length (quote ())))
-;         (apply (λ () (quote ())) args)
-;         (if (= l (length (quote (lst))))
-;           (apply (λ (lst) lst) args)
-;           (if (= l (length (quote (lst x))))
-;             (apply (λ (lst x) (cons x lst)) args)
-;             (error! "Arity mismatch")))))))
-
-; (define rcount
-;   (λ args
-;     (let ((l (length args)))
-;       (if (= l (length (quote ())))
-;         (apply (λ () 0) args)
-;         (if (= l (length (quote (result))))
-;           (apply (λ (result) result) args)
-;           (if (= l (length (quote (result input))))
-;             (apply (λ (result input) (+ 1 result)) args)
-;             (error! "Arity mismatch")))))))
-
-; (define rany
-;   (λ (pred)
-;     (λ args
-;       (let ((l (length args)))
-;         (if (= l (length (quote ())))
-;           (apply (λ () #false) args)
-;           (if (= l (length (quote (result))))
-;             (apply (λ (result) result) args)
-;             (if (= l (length (quote (result input))))
-;               (apply
-;                  (λ (result input)
-;                    (let ((test (pred input)))
-;                      (if test (reduced test) #false)))
-;                  args)
-;               (error! "Arity mismatch"))))))))
-
-; (define revery
-;   (λ (pred)
-;     (λ args
-;       (let ((l (length args)))
-;         (if (= l (length (quote ())))
-;           (apply (λ () #true) args)
-;           (if (= l (length (quote (result))))
-;             (apply (λ (result) result) args)
-;             (if (= l (length (quote (result input))))
-;               (apply
-;                  (λ (result input)
-;                    (let ((test (pred input)))
-;                      (if (if result test #false)
-;                        test
-;                        (reduced #false))))
-;                  args)
-;               (error! "Arity mismatch"))))))))
-
-(define list-transduce
-  (λ args
-    (displayln args)
-    (let ((l (length args)))
-      (if (= l (length (quote (xform f coll))))
-        (apply
-           (λ (xform f coll)
-             (displayln f)
-             (displayln (multi-arity? f))
-             (displayln list-transduce)
-             (list-transduce xform f (f) coll))
-           args)
-        (if (= l (length (quote (xform f init coll))))
-          (apply
-             (λ (xform f init coll)
-               (let ((xf (xform f)))
-                 (let ((result (list-reduce xf init coll)))
-                   (xf result))))
-             args)
-          (error! "Arity mismatch"))))))
-
-(define tmap
-  (λ (f)
-    (λ (reducer)
-      (λ args
-        (let ((l (length args)))
-          (if (= l (length (quote ())))
-            (apply (λ () (reducer)) args)
-            (if (= l (length (quote (result))))
-              (apply (λ (result) (reducer result)) args)
-              (if (= l (length (quote (result input))))
-                (apply
-                   (λ (result input)
-                     (reducer result (f input)))
-                   args)
-                (error! "Arity mismatch")))))))))
-;; λ > 
-
-
-
-
-(list-transduce (tmap (lambda (x) (+ x 1))) rcons (list 0 1 2 3))
\ No newline at end of file
diff --git a/self_hosted/unit-test.rkt b/self_hosted/unit-test.rkt
deleted file mode 100644
index 9ec81fac7..000000000
--- a/self_hosted/unit-test.rkt
+++ /dev/null
@@ -1,87 +0,0 @@
-(provide
-    test
-    (for-syntax check-equal?)
-    (for-syntax check-err)
-    (for-syntax test-module))
-
-(define *SUCCESS-COUNT* 0)
-(define *FAILURE-COUNT* 0)
-
-;; Failed tests
-(define *failures* '())
-
-(define (mark-success)
-    (set! *SUCCESS-COUNT* (+ *SUCCESS-COUNT* 1)))
-
-(define (mark-failed name)
-    (set! *FAILURE-COUNT* (+ *FAILURE-COUNT* 1))
-    (set! *failures* (cons name *failures*)))
-
-(define (print-success name) 
-    (display "test > ")
-    (display name)
-    (display " ... ")
-    (display-color "Ok" 'green)
-    (newline))
-
-(define (print-failure name)
-    (display "test > ")
-    (display name)
-    (display " ... ")
-    (display-color "FAILED" 'red)
-    (newline))
-
-(define-syntax check-equal?
-    (syntax-rules ()
-        [(check-equal? name input expected)
-            (with-handler (lambda (err) (mark-failed name)
-                                        (print-failure name) 
-                                        (displayln err))
-                (test name input expected))]))
-
-(define-syntax check-err?
-    (syntax-rules ()
-        [(check-equal? name input expected)
-            (with-handler (lambda (err) (mark-success)
-                                        (print-success name))
-                (test name input expected))]))
-
-;; Check the equality, and otherwise do some nice printing of the result
-(define (test name input expected)
-  (if (equal? input expected)
-      (begin
-        (mark-success)
-        (print-success name))
-      (begin
-        (mark-failed name)
-        (print-failure name)
-        (display "    Expected: ")
-        (display expected)
-        (display ", Found ")
-        (displayln input))))
-
-(define-syntax test-module
-    (syntax-rules ()
-        [(test-module name expr ...)
-                (begin 
-                    (display "###### Running tests for module ") (display name) (displayln " ######")
-                    (begin expr ...)
-                    (display "Test result: ") (display *SUCCESS-COUNT*) (display " passed; ") (display *FAILURE-COUNT*) (displayln " failed;")
-                    (display "Failures: ") (displayln *failures*)
-                    )]
-        [(test-module expr ...)
-            (begin expr ...)]))
-
-; (test-module
-;     (check-equal? "Checks that the expressions make sense" 
-;                   (+ 10 20 30) 
-;                   (+ 10 20 30))
-
-;     (check-err? "This should fail (in a good way)!" 
-;                 (error! "Throwing an error") 
-;                 (+ 10 20 30))
-
-;     (check-equal? "This should fail" 
-;                   (+ 10 20) 
-;                   (+ 30 40)))
-
diff --git a/self_hosted/vector.rkt b/self_hosted/vector.rkt
deleted file mode 100644
index 9b4e4fd80..000000000
--- a/self_hosted/vector.rkt
+++ /dev/null
@@ -1,24 +0,0 @@
-(require "steel/option")
-
-; (define (position-from-back vec func)
-;     ;; Get the last index of the vector
-;     (define last-index (- (mut-vec-len vec) 1))
-;     (when (< last-index 0) 
-;           (return! (None)))
-;     (define (looper vec idx)
-;         (cond 
-;             ;; If we're outside of the range of the vector, return None
-;             [(< idx 0) => (None)]
-;             [(func (mut-vector-ref vec idx)) => (Some idx)]
-;             [else => (looper vec (- idx 1))]))
-;     (looper vec last-index))
-
-; (displayln None)
-
-; (define test (mutable-vector 1 2 3 4 5))
-
-; (displayln
-;     (unwrap-some (position-from-back test (lambda (x) (equal? x 3)))))
-
-; (displayln
-;     (unwrap-some (position-from-back test (lambda (x) (equal? x 5)))))
\ No newline at end of file
diff --git a/src/lib.rs b/src/lib.rs
deleted file mode 100644
index 7a81e728e..000000000
--- a/src/lib.rs
+++ /dev/null
@@ -1,383 +0,0 @@
-extern crate steel;
-extern crate steel_derive;
-extern crate steel_repl;
-
-use steel::steel_vm::engine::Engine;
-use steel_doc::walk_dir;
-use steel_repl::repl::repl_base;
-
-use std::path::PathBuf;
-use std::process;
-use std::{error::Error, fs};
-
-use clap::Parser;
-
-/// Steel Interpreter
-#[derive(Parser, Debug)]
-#[clap(author, version, about, long_about = None)]
-pub struct Args {
-    /// What action to perform on this file, the absence of a subcommand indicates that the given file (if any)
-    /// will be run as the entrypoint
-    #[clap(subcommand)]
-    action: Option<EmitAction>,
-
-    /// The existence of this argument indicates whether we want to run the repl, or interpret this file
-    default_file: Option<PathBuf>,
-
-    /// Arguments to the input file
-    arguments: Vec<String>,
-}
-
-#[derive(clap::Subcommand, Debug)]
-enum EmitAction {
-    /// Output a debug display of the fully transformed bytecode
-    Bytecode { default_file: Option<PathBuf> },
-    /// Print a debug display of the fully expanded AST
-    Ast { default_file: Option<PathBuf> },
-    /// Enter the repl with the given file loaded
-    Interactive {
-        default_file: Option<PathBuf>,
-        arguments: Vec<String>,
-    },
-    /// Tests the module - only tests modules which provide values
-    Test { default_file: Option<String> },
-    /// Generate the documentation for a file
-    Doc { default_file: Option<PathBuf> },
-    /// Experimental
-    Compile { file: PathBuf },
-}
-
-pub fn run(clap_args: Args) -> Result<(), Box<dyn Error>> {
-    let mut vm = Engine::new();
-
-    // let mut vm = Engine::top_level_load_from_bootstrap(include_bytes!(concat!(
-    //     env!("OUT_DIR"),
-    //     "/bootstrap.bin"
-    // )));
-
-    vm.register_value("std::env::args", steel::SteelVal::ListV(vec![].into()));
-
-    match clap_args {
-        Args {
-            default_file: None,
-            action: None,
-            ..
-        } => {
-            repl_base(vm)?;
-            Ok(())
-        }
-
-        Args {
-            default_file: Some(path),
-            action: None,
-            arguments,
-        } => {
-            vm.register_value(
-                "std::env::args",
-                steel::SteelVal::ListV(
-                    arguments
-                        .into_iter()
-                        .map(|x| steel::SteelVal::StringV(x.into()))
-                        .collect(),
-                ),
-            );
-
-            let contents = fs::read_to_string(&path)?;
-            let res = vm.compile_and_run_raw_program_with_path(&contents, path.clone());
-
-            if let Err(e) = res {
-                e.emit_result(path.to_str().unwrap(), &contents);
-                // process::exit(1);
-
-                return Err(Box::new(e));
-            }
-
-            Ok(())
-        }
-
-        Args {
-            default_file: None,
-            action: Some(EmitAction::Test { default_file }),
-            ..
-        } => {
-            let file_or_current_dir: String = default_file.unwrap_or(".".to_string());
-            if let Some(path) = PathBuf::from(file_or_current_dir).to_str() {
-                let mut vm = Engine::new();
-                vm.register_value(
-                    "std::env::args",
-                    steel::SteelVal::ListV(vec![path.to_string().into()].into()),
-                );
-                let test_script = include_str!("../cogs/test-runner.scm");
-                if let Err(e) = vm.run(test_script) {
-                    e.emit_result(path, &test_script);
-                    return Err(Box::new(e));
-                }
-            }
-            Ok(())
-        }
-        Args {
-            default_file: None,
-            action: Some(EmitAction::Doc {
-                default_file: Some(path),
-            }),
-            ..
-        } => {
-            // todo!()
-
-            let mut writer = std::io::BufWriter::new(std::io::stdout());
-
-            walk_dir(&mut writer, path, &mut vm)?;
-
-            Ok(())
-
-            // todo!()
-        }
-
-        Args {
-            default_file: None,
-            action:
-                Some(EmitAction::Bytecode {
-                    default_file: Some(path),
-                }),
-            ..
-        } => {
-            let contents = fs::read_to_string(&path)?;
-
-            let program = vm.emit_raw_program(&contents, path.clone());
-
-            match program {
-                Ok(program) => {
-                    vm.debug_print_build(path.to_str().unwrap().to_string(), program)
-                        .unwrap();
-                }
-                Err(e) => e.emit_result(path.to_str().unwrap(), &contents),
-            }
-
-            Ok(())
-        }
-
-        Args {
-            default_file: None,
-            action: Some(EmitAction::Ast {
-                default_file: Some(path),
-            }),
-            ..
-        } => {
-            let contents = fs::read_to_string(path.clone())?;
-
-            let res = vm.emit_fully_expanded_ast_to_string(&contents, Some(path.clone()));
-
-            match res {
-                Ok(ast) => println!("{ast}"),
-                Err(e) => e.emit_result(path.to_str().unwrap(), &contents),
-            }
-
-            Ok(())
-        }
-
-        Args {
-            default_file: None,
-            action:
-                Some(EmitAction::Interactive {
-                    default_file: Some(path),
-                    arguments: _,
-                }),
-            ..
-        } => {
-            let core_libraries = &[steel::stdlib::PRELUDE];
-
-            for core in core_libraries {
-                let res = vm.compile_and_run_raw_program(core);
-                if let Err(e) = res {
-                    eprintln!("{e}");
-                    return Ok(());
-                }
-            }
-
-            let contents =
-                fs::read_to_string(&path).expect("Something went wrong reading the file");
-            let res = vm.compile_and_run_raw_program_with_path(&contents, path.clone());
-
-            if let Err(e) = res {
-                e.emit_result(path.to_str().unwrap(), &contents);
-            }
-
-            repl_base(vm)?;
-            Ok(())
-        }
-
-        Args {
-            default_file: None,
-            action: Some(EmitAction::Compile { file }),
-            ..
-        } => {
-            println!("---- Warning: This is an experimental feature ----");
-
-            let entrypoint =
-                fs::read_to_string(&file).expect("Something went wrong reading the file");
-
-            // Something went wrong - TODO: Raise the error correctly
-            let non_interactive_program =
-                Engine::create_non_interactive_program_image(&entrypoint, file).unwrap();
-
-            let mut temporary_output = PathBuf::from("steel_target/src");
-
-            if !temporary_output.exists() {
-                std::fs::create_dir_all(&temporary_output).unwrap();
-            } else {
-                // Clean up I guess?
-                std::fs::remove_dir_all(&temporary_output).unwrap();
-                std::fs::create_dir_all(&temporary_output).unwrap();
-            }
-
-            temporary_output.push("program.bin");
-
-            // This probably needs to get stashed in some temporary target directory?
-            non_interactive_program.write_bytes_to_file(&temporary_output);
-
-            temporary_output.pop();
-
-            let rust_entrypoint = r#"
-fn main() {
-    let program = steel::steel_vm::engine::NonInteractiveProgramImage::from_bytes(include_bytes!("program.bin"));
-
-    steel::steel_vm::engine::Engine::execute_non_interactive_program_image(program);
-}
-            "#;
-
-            temporary_output.push("main.rs");
-
-            std::fs::write(&temporary_output, rust_entrypoint).unwrap();
-
-            temporary_output.pop();
-            temporary_output.pop();
-
-            temporary_output.push("Cargo.toml");
-
-            let toml_file = r#"
-[package]
-name = "steel-executable"
-authors = [""]
-edition = "2021"
-license = "MIT OR Apache-2.0"
-version = "0.1.0"
-
-[workspace]
-
-
-[dependencies]
-steel-core = { git = "https://github.com/mattwparas/steel.git", features = ["web", "sqlite", "dylibs"] }
-
-[profile.release]
-debug = false
-lto = true
-            "#;
-
-            // IF DEVELOPING: Uncomment this
-            //             let toml_file = r#"
-            // [package]
-            // name = "steel-executable"
-            // authors = ["mattwparas <matthewparas2020@u.northwestern.edu>"]
-            // edition = "2021"
-            // license = "MIT OR Apache-2.0"
-            // version = "0.1.0"
-
-            // [workspace]
-
-            // [dependencies]
-            // steel-core = { path = "", features = ["web", "sqlite", "dylibs"] }
-
-            // [profile.release]
-            // debug = false
-            // lto = true
-            //             "#;
-
-            std::fs::write(&temporary_output, toml_file).unwrap();
-
-            std::process::Command::new("cargo")
-                .current_dir("steel_target")
-                .arg("build")
-                .arg("--release")
-                .spawn()
-                .unwrap()
-                .wait()
-                .unwrap();
-
-            Ok(())
-        }
-
-        _ => {
-            repl_base(vm)?;
-            Ok(())
-        }
-    }
-}
-
-pub fn finish(result: Result<(), std::io::Error>) -> ! {
-    let code = match result {
-        Ok(()) => 0,
-        Err(e) => {
-            eprintln!(
-                "{}: {}",
-                std::env::args().next().unwrap_or_else(|| "steel".into()),
-                e
-            );
-            1
-        }
-    };
-
-    process::exit(code);
-}
-
-#[test]
-fn test_runner() {
-    let args = Args {
-        action: None,
-        default_file: Some(PathBuf::from("cogs/test-runner.scm")),
-        arguments: vec!["cogs/".to_string()],
-    };
-
-    run(args).unwrap()
-}
-
-#[test]
-fn r5rs_test_suite() {
-    let args = Args {
-        action: None,
-        default_file: Some(PathBuf::from("cogs/r5rs.scm")),
-        arguments: vec![],
-    };
-
-    run(args).unwrap()
-}
-
-#[test]
-fn r7rs_test_suite() {
-    let args = Args {
-        action: None,
-        default_file: Some(PathBuf::from("cogs/r7rs.scm")),
-        arguments: vec![],
-    };
-
-    run(args).unwrap()
-}
-
-#[test]
-fn r7rs_benchmark_test_suite() {
-    let benches = &[
-        "r7rs-benchmarks/scheme.scm",
-        "r7rs-benchmarks/simplex.scm",
-        "r7rs-benchmarks/array1.scm",
-        "r7rs-benchmarks/triangl.scm",
-    ];
-
-    for bench in benches {
-        let args = Args {
-            action: None,
-            default_file: Some(PathBuf::from(bench)),
-            arguments: vec![],
-        };
-
-        run(args).unwrap();
-    }
-}
diff --git a/src/main.rs b/src/main.rs
deleted file mode 100644
index 4e0c7acdc..000000000
--- a/src/main.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-use std::error::Error;
-
-use clap::Parser;
-use steel_interpreter::Args;
-
-fn main() -> Result<(), Box<dyn Error>> {
-    env_logger::init();
-
-    // let mut builder = env_logger::Builder::new();
-
-    // let log_targets = [
-    // "requires",
-    // "modules",
-    // "gc",
-    // "kernel",
-    // "super-instructions",
-    // "lambda-lifting",
-    // "dylibs",
-    // ];
-
-    // for target in log_targets {
-    // builder.filter(Some(target), log::LevelFilter::Trace);
-    // }
-
-    // builder.init();
-
-    let clap_args = Args::parse();
-
-    steel_interpreter::run(clap_args)?;
-
-    Ok(())
-}
diff --git a/steel-examples/ack-jit.scm b/steel-examples/ack-jit.scm
deleted file mode 100644
index 6a298bfab..000000000
--- a/steel-examples/ack-jit.scm
+++ /dev/null
@@ -1,14 +0,0 @@
-(define (ackermann m n)
-  (cond [(equal? m 0) (+ n 1)]
-        [(equal? n 0) (ackermann (- m 1) 1)]
-        [else (ackermann (- m 1) (ackermann m (- n 1)))]))
-
-(define (loop x)
-  (if (equal? x 100)
-      #true
-      (begin
-        (ackermann 3 3)
-        (loop (+ x 1)))))
-
-
-(loop 50)
diff --git a/steel-examples/ack.scm b/steel-examples/ack.scm
deleted file mode 100644
index 5d0d90ab5..000000000
--- a/steel-examples/ack.scm
+++ /dev/null
@@ -1,4 +0,0 @@
-(define (ackermann m n)
-  (cond [(zero? m) (add1 n)]
-        [(zero? n) (ackermann (sub1 m) 1)]
-        [else (ackermann (sub1 m) (ackermann m (sub1 n)))]))
\ No newline at end of file
diff --git a/steel-examples/bin_trees.scm b/steel-examples/bin_trees.scm
deleted file mode 100644
index b1c52e9bc..000000000
--- a/steel-examples/bin_trees.scm
+++ /dev/null
@@ -1,87 +0,0 @@
-; #lang racket/base
-
-;;; The Computer Language Benchmarks Game
-;;; https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
-
-;;; Derived from the Chicken variant by Sven Hartrumpf
-;;; contributed by Matthew Flatt
-;;; *reset*
-
-; (require racket/cmdline)
-
-(struct node (left val right))
-
-;; Instead of (define-struct leaf (val)):
-(define (leaf val) (node #f val #f))
-(define (leaf? l) (not (node-left l)))
-(define (leaf-val l) (node-val l))
-
-(define (make item d)
-  (if (= d 0)
-      (leaf item)
-      (%plain-let ((item2 (* item 2))
-            (d2 (- d 1)))
-        (node (make (- item2 1) d2) 
-              item 
-              (make item2 d2)))))
-
-(define (check t)
-  (if (leaf? t)
-      1
-      (+ 1 (+ (check (node-left t)) 
-                         (check (node-right t))))))
-
-(define (iterate n m d sum)
-  (if (equal? n m)
-      sum
-      (iterate (+ n 1) m d (+ sum (check (make n d))))))
-
-
-(define (loop d end max-depth min-depth)
-    (if (>= d end)
-        void
-        (begin
-          (let ((iterations (arithmetic-shift 1 (+ (- max-depth d) min-depth))))
-              (display iterations)
-              (display " trees of depth ")
-              (display d)
-              (display " check: ")
-              ; (displayln
-              ;   (transduce
-              ;       (range 0 iterations) 
-              ;       (mapping (lambda (i) (make i d)))
-              ;       (into-reducer
-              ;       (lambda (c i) (+ c (check i)))
-              ;       0))))
-              (displayln (iterate 0 iterations d 0)))
-        (loop (+ 2 d) end max-depth min-depth))))
-
-
-(define (main n)
-  (let* ((min-depth 4)
-         (max-depth (max (+ min-depth 2) n)))
-    (let ((stretch-depth (+ max-depth 1)))
-      (begin
-        (display "stretch tree of depth ")
-        (display stretch-depth)
-        (display " check: ")
-        (displayln (check (make 0 stretch-depth)))))
-    (%plain-let ((long-lived-tree (make 0 max-depth)))
-      (begin
-        (define end (add1 max-depth))
-
-        (loop 4 end max-depth min-depth))
-
-      
-      (begin (display "long lived tree of depth ")
-             (display max-depth)
-             (display  " check: ")
-             (displayln (check long-lived-tree))))))
-
-(main 12)
-; (main 21)
-; (main 21)
-
-
-; (command-line #:args (n) 
-;               (main (string->number n)))
diff --git a/steel-examples/binary_trees.scm b/steel-examples/binary_trees.scm
deleted file mode 100644
index 8fa19f45b..000000000
--- a/steel-examples/binary_trees.scm
+++ /dev/null
@@ -1,70 +0,0 @@
-; #lang racket/base
-
-;;; The Computer Language Benchmarks Game
-;;; https://salsa.debian.org/benchmarksgame-team/benchmarksgame/
-
-;;; Derived from the Chicken variant by Sven Hartrumpf
-;;; contributed by Matthew Flatt
-;;; *reset*
-
-; (require racket/cmdline)
-
-(struct node (left val right))
-
-;; Instead of (define-struct leaf (val)):
-(define (leaf val)
-  (node #f val #f))
-(define (leaf? l)
-  (not (node-left l)))
-(define (leaf-val l)
-  (node-val l))
-
-(define (make item d)
-  (if (= d 0)
-      (leaf item)
-      (let ([item2 (* item 2)] [d2 (- d 1)]) (node (make (- item2 1) d2) item (make item2 d2)))))
-
-(define (check t)
-  (if (leaf? t) 1 (+ 1 (+ (check (node-left t)) (check (node-right t))))))
-
-(define (max x y)
-  (if (> x y) x y))
-
-(define (main n)
-  (let* ([min-depth 4] [max-depth (max (+ min-depth 2) n)])
-    (let ([stretch-depth (+ max-depth 1)])
-      (begin
-        (display "stretch tree of depth ")
-        (display stretch-depth)
-        (display " check: ")
-        (displayln (check (make 0 stretch-depth)))))
-    (let ([long-lived-tree (make 0 max-depth)])
-      (begin
-        (define end (add1 max-depth))
-        (define (loop d)
-          (if (>= d end)
-              void
-              (begin
-                (let ([iterations (arithmetic-shift 1 (+ (- max-depth d) min-depth))])
-                  (display iterations)
-                  (display " trees of depth ")
-                  (display d)
-                  (display " check: ")
-                  (displayln (transduce (range 0 iterations)
-                                        (mapping (lambda (i) (make i d)))
-                                        (into-reducer (lambda (c i) (+ c (check i))) 0))))
-                (loop (+ 2 d)))))
-        (loop 4))
-
-      (begin
-        (display "long lived tree of depth ")
-        (display max-depth)
-        (display " check: ")
-        (displayln (check long-lived-tree))))))
-
-(main 12)
-; (main 21)
-; (main 21)
-
-; (command-line #:args (n)
-;               (main (string->number n)))
diff --git a/steel-examples/calculator.scm b/steel-examples/calculator.scm
deleted file mode 100644
index b271e0a59..000000000
--- a/steel-examples/calculator.scm
+++ /dev/null
@@ -1,70 +0,0 @@
-;; A basic parser and interpreter for infix mathematical expressions
-;; Example taken from: https://people.eecs.berkeley.edu/~bh/ssch18/trees.html
-
-
-; (struct node (datum children))
-
-(define (node datum children) (list datum children))
-(define (node-datum node) (car node))
-(define (node-children node) (cadr node))
-
-(define (parse expr)
-  (parse-helper expr '() '()))
-
-(define (parse-helper expr operators operands)
-  (cond ((null? expr)
-         (if (null? operators)
-             (car operands)
-             (handle-op '() operators operands)))
-        ((number? (car expr))
-         (parse-helper (cdr expr)
-                       operators
-                       (cons (node (car expr) '()) operands)))
-        ((list? (car expr))
-         (parse-helper (cdr expr)
-                       operators
-                       (cons (parse (car expr)) operands)))
-        (else (if (or (null? operators)
-                      (> (precedence (car expr))
-                         (precedence (car operators))))
-                  (parse-helper (cdr expr)
-                                (cons (car expr) operators)
-                                operands)
-                  (handle-op expr operators operands)))))
-
-(define (handle-op expr operators operands)
-  (parse-helper expr
-                (cdr operators)
-                (cons (node (car operators)
-                                 (list (cadr operands) (car operands)))
-                      (cddr operands))))
-
-(define (member? x los)
-  (cond
-    ((null? los) #f)
-    ((equal? x (car los)) #t)
-    (else (member? x (cdr los)))))
-
-
-(define (precedence oper)
-  (if (member? oper '(+ -))
-      1
-      2))
-
-
-(define (compute tree)
-  (if (number? (node-datum tree))
-      (node-datum tree)
-      ((function-named-by (node-datum tree))
-       (compute (car (node-children tree)))
-       (compute (cadr (node-children tree))))))
-
-(define (function-named-by oper)
-  (cond ((equal? oper '+) +)
-        ((equal? oper '-) -)
-        ((equal? oper '*) *)
-        ((equal? oper '/) /)
-        (else (error! "no such operator as" oper))))
-
-(compute (parse '(4 + 3 * 7 - 5 / (3 + 4) + 6))) ;; => 30.285714285714285
-(compute (parse '(1 + 2 + 3 + 4))) ;; => 10
diff --git a/steel-examples/callcc.scm b/steel-examples/callcc.scm
deleted file mode 100644
index 27099dd49..000000000
--- a/steel-examples/callcc.scm
+++ /dev/null
@@ -1,90 +0,0 @@
-(define (for-each func lst)
-    (if (null? lst) 
-        void
-        (begin
-            (func (car lst))
-            (if (null? lst)
-                void
-                (for-each func (cdr lst))))))
-
-; (for-each (lambda (x) (displayln x)) '(1 2 3 4 5))
-
-;; [LISTOF X] -> ( -> X u 'you-fell-off-the-end)
-(define (generate-one-element-at-a-time lst)
-  ;; Both internal functions are closures over lst
-
-  ;; Internal variable/Function which passes the current element in a list
-  ;; to its return argument (which is a continuation), or passes an end-of-list marker 
-  ;; if no more elements are left. On each step the function name is 
-  ;; rebound to a continuation which points back into the function body,
-  ;; while return is rebound to whatever continuation the caller specifies.
-  (define (control-state return)
-    (for-each 
-     (lambda (element)
-               (set! return (call/cc
-                              (lambda (resume-here)
-                                ;; Grab the current continuation
-                               (set! control-state resume-here)
-                              ;  (displayln "GETTING HERE")
-                               (return element))))) ;; (return element) evaluates to next return
-     lst)
-    ;; TODO
-    ;; this is reading the local variable
-    ;; but it needs to be reading from the heap
-    (return 'you-fell-off-the-end))
-
-  ;; (-> X u 'you-fell-off-the-end)
-  ;; This is the actual generator, producing one item from a-list at a time.
-  ; (define (generator)
-  ;   (call/cc control-state))
-
-  (lambda () (call/cc control-state)))
-
-;; TODO: don't use IDs for ordering - find something (depth + stack offset or arg position) that will better identify the position of a variable. The fact is that certain variables are created later, which means the offsets are all goofy.
-; (define generate-one-element-at-a-time
-;   (λ (lst)
-;     ((λ (control-state)
-;          ((λ (control-state0)
-;               (begin
-;                (set! control-state control-state0)
-;                 (λ ()
-;                   (call/cc control-state))))
-;             (λ (return)
-;               (begin
-;                (for-each
-;                    (λ (element)
-;                      (set! return
-;                        (call/cc
-;                           (λ (resume-here)
-;                             (begin
-;                              (set! control-state
-;                                 resume-here)
-;                               (return element))))))
-;                    lst)
-;                 (return (quote you-fell-off-the-end))))))
-;        123)))
-
-  ;; Return the generator 
-  ; generator)
-
-(define generate-digit
-  (generate-one-element-at-a-time '(0 1 2)))
-
-; (generate-digit) ;; 0
-; (generate-digit) ;; 1
-; (generate-digit) ;; 2
-; (generate-digit) ;; you-fell-off-the-end
-; (generate-digit) ;; you-fell-off-the-end
-
-; (equal? 0 (generate-digit)) ;; 0
-; (equal? 1 (generate-digit)) ;; 1
-; (equal? 2 (generate-digit)) ;; 2
-
-; ; (define res (generate-digit))
-; ; (displayln res)
-
-; (equal? 'you-fell-off-the-end (generate-digit)) ;; you-fell-off-the-end
-; (equal? 'you-fell-off-the-end (generate-digit)) ;; you-fell-off-the-end
-
-
-
diff --git a/steel-examples/captures.scm b/steel-examples/captures.scm
deleted file mode 100644
index c798988ae..000000000
--- a/steel-examples/captures.scm
+++ /dev/null
@@ -1,11 +0,0 @@
-(define test
-    (lambda (x)
-        (lambda (y)
-            (lambda (z)
-                (lambda ()
-                    (lambda (q)
-                        (+ x y z)))))))
-
-
-
-
diff --git a/steel-examples/coop-threads.scm b/steel-examples/coop-threads.scm
deleted file mode 100644
index 97e7aef7c..000000000
--- a/steel-examples/coop-threads.scm
+++ /dev/null
@@ -1,81 +0,0 @@
-; *thread-queue* : list[continuation]
-(define *thread-queue* '())
-
-; halt : continuation
-(define halt #f)
-
-; current-continuation : -> continuation
-(define (current-continuation)
-  (call/cc
-   (lambda (cc)
-     (cc cc))))
-
-; spawn : (-> anything) -> void
-(define (spawn thunk)
-  (let ((cc (current-continuation)))
-    (if (continuation? cc)
-        (set! *thread-queue* (append *thread-queue* (list cc)))
-        (begin 
-               (thunk)
-               (quit)))))
-
-; yield : value -> void
-(define (yield)
-  (let ((cc (current-continuation)))
-    (if (and (continuation? cc) (pair? *thread-queue*))
-        (let ((next-thread (car *thread-queue*)))
-          (set! *thread-queue* (append (cdr *thread-queue*) (list cc)))
-          (next-thread 'resume))
-        void)))
-
-; quit : -> ...
-(define (quit)
-  (if (pair? *thread-queue*)
-      (let ((next-thread (car *thread-queue*)))
-        (set! *thread-queue* (cdr *thread-queue*))
-        (next-thread 'resume))
-      (halt)))
-   
-; start-threads : -> ...
-(define (start-threads)
-  (let ((cc (current-continuation)))
-    (displayln cc)
-    (if cc
-        (begin
-          (displayln cc)
-          (set! halt (lambda () 
-                        ; (inspect-bytecode cc) 
-                        (displayln cc)
-                        (cc #f)))
-          (displayln cc)
-          (if (null? *thread-queue*)
-              void
-              (begin
-                (let ((next-thread (car *thread-queue*)))
-                  (set! *thread-queue* (cdr *thread-queue*))
-                  (next-thread 'resume)))))
-        void)))
-
-
-;; Example cooperatively threaded program
-(define counter 10)
-
-(define (make-thread-thunk name)
-  (define (loop)
-        (when (< counter 0)
-            (quit))
-        (display "in thread ")
-        (display name)
-        (display "; counter = ")
-        (display counter)
-        (newline)
-        (set! counter (- counter 1))
-        (yield)
-        (loop))
-  loop)
-
-(spawn (make-thread-thunk 'a))
-(spawn (make-thread-thunk 'b))
-(spawn (make-thread-thunk 'c))
-
-(start-threads)
diff --git a/steel-examples/define.scm b/steel-examples/define.scm
deleted file mode 100644
index c00d06315..000000000
--- a/steel-examples/define.scm
+++ /dev/null
@@ -1,102 +0,0 @@
-;; Fancy alternative syntax to generating define/contracts
-;; Might be easier to read
-
-(define-syntax fun
-  (syntax-rules (:: ->)
-    [(fun name :: (arg c -> return) body ...)
-     (define/contract (name arg) (->/c c return) body ...)]
-    [(fun name :: (arg c -> arg1 c1 -> return) body ...)
-     (define/contract (name arg arg1) (->/c c c1 return) body ...)]
-    [(fun name :: (arg c -> arg1 c1 -> arg2 c2 -> return) body ...)
-     (define/contract (name arg arg1 arg2) (->/c c c1 c2 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3)
-       (->/c c c1 c2 c3 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4)
-       (->/c c c1 c2 c3 c4 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5)
-       (->/c c c1 c2 c3 c4 c5 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> arg6 c6
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5 arg6)
-       (->/c c c1 c2 c3 c4 c5 c6 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> arg6 c6
-                       -> arg7 c7
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5 arg6 arg7)
-       (->/c c c1 c2 c3 c4 c5 c6 c7 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> arg6 c6
-                       -> arg7 c7
-                       -> arg8 c8
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8)
-       (->/c c c1 c2 c3 c4 c5 c6 c7 c8 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> arg6 c6
-                       -> arg7 c7
-                       -> arg8 c8
-                       -> arg9 c9
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9)
-       (->/c c c1 c2 c3 c4 c5 c6 c7 c8 c9 return) body ...)]))
-
-
-;; New more palatable function declarations
-;; similar to haskell / agda kinda stuff
-(fun add-two :: (left int? -> right int? -> int?)
-     (+ left right))
-
-(displayln (add-two 10 20))
-
-
-(fun boop-lemma-1 :: (l any/c -> any/c)
-     (displayln l))
-
-(boop-lemma-1 "alex")
diff --git a/steel-examples/delim-control-n.scm b/steel-examples/delim-control-n.scm
deleted file mode 100644
index 8f4a060bc..000000000
--- a/steel-examples/delim-control-n.scm
+++ /dev/null
@@ -1,254 +0,0 @@
-; Generic implementation of all four delimited control operators
-;    shift/reset, prompt/control, shift0/reset0 and prompt0/control0
-;                   aka. -F- through +F+   
-;
-; The code below is parameterized by two boolean flags:
-; is-shift and keep-delimiter-upon-effect.
-; Each flag is present in the code exactly once, in a trivial
-; context. In particular, the difference between shift and control is
-; one statement: (hole-push! (cell-new k-return is-shift))
-; which tells whether the created hole is delimiting or not.
-; All four combinations of the two flags correspond to four
-; delimited control operators,  -F- through +F+
-;
-; The code relies on call/cc for capturing undelimited
-; continuations, and uses one global mutable cell. It turns out, this
-; is sufficient for implementing not only shift/reset (Danvy/Filinski)
-; but also for control/prompt and the other F operators. That has not
-; been known before. In particular, the implementation of
-; control/prompt needs no eq? operations.
-;
-; This implementation immediately leads to a CPS transform for
-; control/prompt (which has not been known before either). That
-; transform turns almost identical to the one discussed in the
-; forth-coming paper ``A Monadic Framework for Delimited
-; Continuations'' by R. Kent Dybvig, Simon Peyton Jones and Amr Sabry
-;
-; This code is inspired by CC_Ref.hs -- contexts with holes, while reading
-; Dorai Sitaram and Matthias Felleisen paper (Lisp and symbolic computation,
-; 1990)
-; A hole has a continuation and a mark. The mark, if #t, says if the hole
-; is a delimiting hole.
-; Non-delimiting hole is just like the return from a regular function.
-;
-; $Id: delim-control-n.scm 815 2005-09-05 23:02:12Z oleg $
-
-(define (for-each func lst)
-    (if (null? lst) 
-        void
-        (begin
-            (func (car lst))
-            (when (null? lst) (return! void))
-            (for-each func (cdr lst)))))
-
-; Two parameterizing boolean flags. We can change them at run-time
-; and so mutate shift into control at run-time! The regression test code below
-; does exactly that, so it can test all four *F* operators.
-(define is-shift #f)
-(define keep-delimiter-upon-effect #t)
-
-; This is one single global mutable cell
-(define holes '())
-(define (hole-push! hole) (set! holes (cons hole holes)))
-(define (hole-pop!) (let ((hole (car holes))) (set! holes (cdr holes)) hole))
-
-(define (cell-new v mark) (cons v mark))
-(define (cell-ref c) (car c))
-(define (cell-marked? c) (cdr c))
-
-; Essentially this is the ``return from the function''
-(define (abort-top! v) ((cell-ref (hole-pop!)) v))
-(define (unwind-till-marked!)
-  (when (null? holes) (error! "No prompt set"))
-  (let ((hole (hole-pop!)))
-    (if (cell-marked? hole)		; if marked, it's prompt's hole
-      (begin (hole-push!		; put it back
-	       (if keep-delimiter-upon-effect hole
-		 (cell-new (cell-ref hole) #f))) ; make the hole non-delimiting
-	'())	
-      (cons hole (unwind-till-marked!)))))
-
-(define (prompt* thunk)
-  (call-with-current-continuation
-    (lambda (outer-k)
-      (hole-push! (cell-new outer-k #t)) ; it's prompt's hole
-      (abort-top! (thunk)))))
-      
-(define (control* f)
-  (call-with-current-continuation
-    (lambda (k-control)
-      (let* ((holes-prefix (reverse (unwind-till-marked!)))
-	     (invoke-subcont 
-	       (lambda (v)
-		 (call-with-current-continuation
-		   (lambda (k-return)
-		     (hole-push! (cell-new k-return is-shift))
-		     (for-each hole-push! holes-prefix)
-		     (k-control v))))))
-	(abort-top! (f invoke-subcont))))))
-
-(define (abort v) (control* (lambda (k) v)))
-
-; Some syntactic sugar
-(define-syntax prompt
-  (syntax-rules ()
-    ((prompt e) (prompt* (lambda () e)))))
-
-(define-syntax control
-  (syntax-rules ()
-    ((control f e) (control* (lambda (f) e)))))
-
-;------------------------------------------------------------------------
-;			Shift tests
-(display "shift tests") (newline)
-
-(set! is-shift #t)
-(set! keep-delimiter-upon-effect #t)
-
-; introduce convenient synonyms
-
-(define-syntax reset
-  (syntax-rules ()
-    ((reset e) (prompt e))))
-
-(define-syntax shift
-  (syntax-rules ()
-    ((shift f e) (control f e))))
-
-(display (+ 10 (reset (+ 2 (shift k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (* 10 (reset (* 2 (shift g (reset 
-				   (* 5 (shift f (+ (f 1) 1)))))))))
-(newline)
-; --> 60
-
-(display (let ((f (lambda (x) (shift k (k (k x))))))
-	   (+ 1 (reset (+ 10 (f 100))))))
-(newline)
-; --> 121
-
-(display (reset
-	   (let ((x (shift f (cons 'a (f '())))))
-	     (shift g x))))
-(newline)
-; ==> '(a)
-
-(define (p x) (if (eq? x p) '(p p) `(p ,x)))
-(define (shift* p) (shift f (p f)))
-(reset (display (let ((x 'abcde)) (eq? x ((shift* shift*) x)))))
-(newline)
-
-; (define traverse
-;   (lambda (xs)
-;     (letrec ((visit
-; 	       (lambda (xs)
-; 		 (if (null? xs)
-; 		   '()
-; 		   (visit (control*
-; 			    (lambda (k)
-; 			      (cons (car xs) (k (cdr xs))))))))))
-;       (prompt*
-; 	(lambda ()
-; 	  (visit xs))))))
-
-; (display "Ex by Olivier Danvy") (newline)
-; (display (traverse '(1 2 3 4 5)))
-; (newline)
-
-;------------------------------------------------------------------------
-;			Control tests
-; Example from Sitaram, Felleisen
-
-(newline)
-(display "control tests") (newline)
-
-(set! is-shift #f)
-(set! keep-delimiter-upon-effect #t)
-
-(display "Ex 1") (newline)
-(display
-  (let ((g (prompt (* 2 (control k k)))))
-    (* 3 (prompt (* 5 (abort (g 7)))))))
-(newline)
-
-
-; Olivier Danvy's puzzle
-
-; (define traverse
-;   (lambda (xs)
-;     (letrec ((visit
-; 	       (lambda (xs)
-; 		 (if (null? xs)
-; 		   '()
-; 		   (visit (control*
-; 			    (lambda (k)
-; 			      (cons (car xs) (k (cdr xs))))))))))
-;       (prompt*
-; 	(lambda ()
-; 	  (visit xs))))))
-
-; (display "Ex by Olivier Danvy") (newline)
-; (display (traverse '(1 2 3 4 5)))
-; (newline)
-
-(display (+ 10 (prompt (+ 2 (control k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (prompt (let ((x (control f (cons 'a (f '()))))) (control g x))))
-(newline)
-; ==> '()
-
-(display (prompt ((lambda (x) (control l 2)) (control l (+ 1 (l 0))))))
-(newline)
-;  ==> 2
-(display (prompt (control f (cons 'a (f '())))))
-(newline)
-; ==> '(a)
-(display (prompt (let ((x (control f (cons 'a (f '()))))) (control g (g x)))))
-(newline)
-; ==> '(a)
-
-(prompt (display (let ((x 'abcde)) (eq? x ((control* control*) x)))))
-(newline)
-
-
-;------------------------------------------------------------------------
-;			shift0/control0 tests
-
-
-(define-syntax prompt0
-  (syntax-rules ()
-    ((prompt0 e) (prompt e))))
-
-(display "control0 tests") (newline)
-(set! is-shift #f)
-(set! keep-delimiter-upon-effect #f)
-
-(display (+ 10 (prompt0 (+ 2 (control k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (prompt0 (prompt0 
-		    (let ((x (control f (cons 'a (f '()))))) (control g x)))))
-(newline)
-; ==> '()
-
-
-(define-syntax shift0
-  (syntax-rules ()
-    ((shift0 f e) (control f e))))
-
-(display "shift0 tests") (newline)
-(set! is-shift #t)
-(set! keep-delimiter-upon-effect #f)
-
-(display (+ 10 (prompt0 (+ 2 (shift0 k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (prompt0 (cons 'a (prompt0 (shift0 f (shift0 g '()))))))
-(newline)
-; ==> '()
diff --git a/steel-examples/delim-control.scm b/steel-examples/delim-control.scm
deleted file mode 100644
index f1617ff51..000000000
--- a/steel-examples/delim-control.scm
+++ /dev/null
@@ -1,173 +0,0 @@
-; #lang racket
-
-; Generic implementation of all four delimited control operators
-;    shift/reset, prompt/control, shift0/reset0 and prompt0/control0
-;                   aka. -F- through +F+   
-;
-; The code below is parameterized by two boolean flags:
-; is-shift and keep-delimiter-upon-effect.
-; Each flag is present in the code exactly once, in a trivial
-; context. In particular, the difference between shift and control is
-; one statement: (hole-push! (cell-new k-return is-shift))
-; which tells whether the created hole is delimiting or not.
-; All four combinations of the two flags correspond to four
-; delimited control operators,  -F- through +F+
-;
-; The code relies on call/cc for capturing undelimited
-; continuations, and uses one global mutable cell. It turns out, this
-; is sufficient for implementing not only shift/reset (Danvy/Filinski)
-; but also for control/prompt and the other F operators. That has not
-; been known before. In particular, the implementation of
-; control/prompt needs no eq? operations.
-;
-; This implementation immediately leads to a CPS transform for
-; control/prompt (which has not been known before either). That
-; transform turns almost identical to the one discussed in the
-; forth-coming paper ``A Monadic Framework for Delimited
-; Continuations'' by R. Kent Dybvig, Simon Peyton Jones and Amr Sabry
-;
-; This code is inspired by CC_Ref.hs -- contexts with holes, while reading
-; Dorai Sitaram and Matthias Felleisen paper (Lisp and symbolic computation,
-; 1990)
-; A hole has a continuation and a mark. The mark, if #t, says if the hole
-; is a delimiting hole.
-; Non-delimiting hole is just like the return from a regular function.
-;
-; $Id: delim-control-n.scm 815 2005-09-05 23:02:12Z oleg $
-
-; Two parameterizing boolean flags. We can change them at run-time
-; and so mutate shift into control at run-time! The regression test code below
-; does exactly that, so it can test all four *F* operators.
-(define is-shift #f)
-(define keep-delimiter-upon-effect #t)
-
-; This is one single global mutable cell
-(define holes '())
-(define (hole-push! hole) (set! holes (cons hole holes)))
-(define (hole-pop!) (let ((hole (car holes))) (set! holes (cdr holes)) hole))
-
-(define (cell-new v mark) (cons v mark))
-(define (cell-ref c) (car c))
-(define (cell-marked? c) (cdr c))
-
-; Essentially this is the ``return from the function''
-(define (abort-top! v) ((cell-ref (hole-pop!)) v))
-(define (unwind-till-marked!)
-  (when (null? holes) (error "No prompt set"))
-  (let ((hole (hole-pop!)))
-    (if (cell-marked? hole)		; if marked, it's prompt's hole
-      (begin (hole-push!		; put it back
-	       (if keep-delimiter-upon-effect hole
-		 (cell-new (cell-ref hole) #f))) ; make the hole non-delimiting
-	'())	
-      (cons hole (unwind-till-marked!)))))
-
-(define (prompt* thunk)
-  (call-with-current-continuation
-    (lambda (outer-k)
-      (hole-push! (cell-new outer-k #t)) ; it's prompt's hole
-      (abort-top! (thunk)))))
-      
-(define (control* f)
-  (call-with-current-continuation
-    (lambda (k-control)
-      (let* ((holes-prefix (reverse (unwind-till-marked!)))
-	     (invoke-subcont 
-	       (lambda (v)
-		 (call-with-current-continuation
-		   (lambda (k-return)
-		     (hole-push! (cell-new k-return is-shift))
-		     (for-each hole-push! holes-prefix)
-		     (k-control v))))))
-	(abort-top! (f invoke-subcont))))))
-
-(define (abort v) (control* (lambda (k) v)))
-
-; Some syntactic sugar
-(define-syntax prompt
-  (syntax-rules ()
-    ((prompt e) (prompt* (lambda () e)))))
-
-(define-syntax control
-  (syntax-rules ()
-    ((control f e) (control* (lambda (f) e)))))
-
-
-(define (void) void)
-
-(define (for-each func lst)
-    (if (null? lst) 
-        void
-        (begin
-            (func (car lst))
-            (if (null? lst) 
-                (void)
-                (for-each func (cdr lst))))))
-
-
-;------------------------------------------------------------------------
-;			Shift tests
-(display "shift tests") (newline)
-
-(set! is-shift #t)
-(set! keep-delimiter-upon-effect #t)
-
-; introduce convenient synonyms
-
-(define-syntax reset
-  (syntax-rules ()
-    ((reset e) (prompt e))))
-
-(define-syntax shift
-  (syntax-rules ()
-    ((shift f e) (control f e))))
-
-(display (+ 10 (reset (+ 2 (shift k (+ 100 (k (k 3))))))))
-(newline)
-; --> 117
-
-(display (* 10 (reset (* 2 (shift g (reset 
-				   (* 5 (shift f (+ (f 1) 1)))))))))
-(newline)
-; --> 60
-
-(display (let ((f (lambda (x) (shift k (k (k x))))))
-	   (+ 1 (reset (+ 10 (f 100))))))
-(newline)
-; --> 121
-
-(display (reset
-	   (let ((x (shift f (cons 'a (f '())))))
-	     (shift g x))))
-(newline)
-; ==> '(a)
-
-(define (p x) (if (eq? x p) '(p p) `(p ,x)))
-(define (shift* p) (shift f (p f)))
-(reset (display (let ((x 'abcde)) (eq? x ((shift* shift*) x)))))
-(reset (let ((x 'abcde)) (eq? x ((shift* shift*) x))))
-(newline)
-
-(define visit
-    (lambda (xs)
-        (if (null? xs)
-        '()
-        (visit (control*
-            (lambda (k)
-                (cons (car xs) (k (cdr xs)))))))))
-
-(define (traverse xs)
-    ; (define visit
-    ;     (lambda (xs)
-    ;         (if (null? xs)
-    ;         '()
-    ;         (visit (control*
-    ;             (lambda (k)
-    ;                 (cons (car xs) (k (cdr xs)))))))))
-    (prompt*
-        (lambda ()
-            (visit xs))))
-
-(display "Ex by Olivier Danvy") (newline)
-(display (traverse '(1 2 3 4 5)))
-(newline)
\ No newline at end of file
diff --git a/steel-examples/dependent.scm b/steel-examples/dependent.scm
deleted file mode 100644
index e25fd5ec4..000000000
--- a/steel-examples/dependent.scm
+++ /dev/null
@@ -1,276 +0,0 @@
-; #lang racket
-
-
-;; the symbols that each of the conditions accepts must be validated
-;; there should be a map of symbol to argument as well
-;; i.e. x -> 1st, y -> 2nd
-;; Then (x y) -> 1st and 2nd
-;; This map needs to be validated by the input function in some capacity
-;;
-;; this also needs to be a macro to create a function with the operand
-;;   i.e. (>=/c x) -> (lambda (x) (>=/c x)) ;; -> in the run time, this needs to be 
-;;                                                applied twice, once for the dependencies, once for the argument
-;;
-;; Each argument should only be evaluated once, and the result should be captured
-
-; (foo 1 2)
-
-
-; (x) (>=/c x) -> (lambda (x) (>=/c x))
-(define-syntax contract-wrap 
-    (syntax-rules ()
-        [(contract-wrap args pat) 
-         (lambda (args) pat)]))
-
-;; Takes a precondition, and returns a list to be consumed by a built-in
-;; returns a list of the identifier for the argument, the list of arguments to the input function, 
-;; and the thunk that returns the function for the contract
-(define-syntax dependent-condition
-    (syntax-rules ()
-        [(dependent-condition (ident func))
-         (list 'ident '() (lambda () (make/c func 'func )) 'func )]
-        [(dependent-condition (ident (arg) func))
-         (list 'ident '(arg) (lambda (arg) (make/c func 'func )) 'func )]
-        [(dependent-condition (ident (args ...) func))
-         (list 'ident '(args ...) (lambda (args ...) (make/c func 'func )) 'func )]))
-
-
-(define-syntax ->i
-  (syntax-rules ()
-    [(->i r) ;; alias ->i to ->/c
-     (->/c r)]
-    [(->i (a) b)
-     (make-dependent-function/c (dependent-condition a) (dependent-condition b))]
-    [(->i (a b) c)
-     (make-dependent-function/c (dependent-condition a) (dependent-condition b) (dependent-condition c))]
-
-    ; [(->/i a b c d)
-    ;  (make-function/c (make/c a 'a) (make/c b 'b)
-    ;                   (make/c c 'c) (make/c d 'd))]
-    ; [(->/i a b c d e)
-    ;  (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-    ;                   (make/c d 'd) (make/c e 'e))]
-    ; [(->/i a b c d e f)
-    ;  (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-    ;                   (make/c d 'd) (make/c e 'e) (make/c f 'f))]
-    ; [(->/i a b c d e f g)
-    ;  (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-    ;                   (make/c d 'd) (make/c e 'e) (make/c f 'f)
-    ;                   (make/c g 'g))]
-    ; [(->/i a b c d e f g h)
-    ;  (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-    ;                   (make/c d 'd) (make/c e 'e) (make/c f 'f)
-    ;                   (make/c g 'g) (make/c h 'h))]
-    ; [(->/i a b c d e f g h i)
-    ;  (make-function/c (make/c a 'a) (make/c b 'b) (make/c c 'c)
-    ;                   (make/c d 'd) (make/c e 'e) (make/c f 'f)
-    ;                   (make/c g 'g) (make/c h 'h) (make/c i 'i))]
-                      
-                      ))
-
-; (define/contract (foo x y)
-;     (->/c (>=/c 10) (>=/c 20) (>=/c 30))
-;     (+ x y))
-
-; (displayln (foo 5 20))
-
-;; - make-dependent/c
-;; - each precondition should have (list of args, contract, name)
-;; - the postcondition should have 
-
-
-
-; (define (make-dependent/c ))
-
-(define/contract (foo x y)
-    (->i ([x number?]
-          [y (x) (>=/c x)])
-          [lolol (x y) (and/c number? (>=/c (+ x y)))])
-    (+ x y 1))
-
-; (foo 1 2)
-
-(define (all func lst)
-  (if (null? lst)
-      #t
-      (if (func (car lst))
-          (all func (cdr lst))
-          #f)))
-
-(define (all/c func lst)
-    (make/c (all func lst) (list 'all func lst)))
-
-(define string?/c (make/c string? 'string?/c))
-(define symbol?/c (make/c symbol? 'symbol?/c))
-(define integer?/c (make/c integer? 'integer?/c))
-(define float?/c (make/c float? 'float/c))
-; (define )
-
-(define (lst-func-loop funcs args)
-    (if (empty? funcs) 
-        #t
-        (let ((result ((car funcs) (car args))))
-            (if result
-                (lst-func-loop (cdr funcs) (cdr args))
-                #f))))
-
-;; Get the contract that uniquely identifies this predicate
-;; Down to the predicate - we want to match the predicates along the way
-;; Doesn't need to explicitly match this way - could do it other ways but this way works nicely
-(define (make-identity-pred obj)
-    (cond [(string? obj) string?/c]
-          [(symbol? obj) symbol?/c]
-          [(integer? obj) integer?/c]
-          [(float? obj) float?/c]
-          ;; If its a struct, get the contracts for all of the children fields as well
-          ;; creating an exact copy of the shape of the struct on the way back up
-          [(struct? obj)
-            (make/c 
-                (let ((struct-list (struct->list obj)))
-                (lambda (input)
-                    ; (let ((struct-list (struct->list obj)))
-                        ; (displayln obj)
-                        ; (displayln struct-list)
-                        ; (displayln input)
-                        (if (struct? input)
-                            (let ((input-list-struct (struct->list input)))
-                                ;; If the structs match the name/type, check the children
-                                (and (equal? (car struct-list) (car input-list-struct))
-                                    (let ((children (map make-identity-pred (cdr struct-list))))
-                                            ; (displayln children)
-                                            ; (displayln input-list-struct)
-                                            (lst-func-loop
-                                                (map make-identity-pred (cdr struct-list))
-                                                (cdr input-list-struct)))))
-                                            
-                        #f))) 'struct-contract)]))
-
-
-; (define (make-identity-pred obj)
-;     ; (newline)
-;     ; (display-color "CALLING WITH OBJECT " 'red)
-;     ; (display-color obj 'red)
-;     ; (newline)
-;     (cond [(string? obj) string?/c]
-;           [(symbol? obj) symbol?/c]
-;           [(integer? obj) integer?/c]
-;           [(float? obj) float?/c]
-;           ;; If its a struct, get the contracts for all of the children fields as well
-;           ;; creating an exact copy of the shape of the struct on the way back up
-;           [(struct? obj)
-;             (make/c
-;                 ; TODO uncomment this and comment below, works
-;                 ; (test-let ((struct-list (struct->list obj)))
-;                 ; (newline)
-;                 ; (display-color obj 'green)
-;                 ; (newline)
-;                 (lambda (input)
-;                     ; (newline)
-;                     ; (display-color "CAPTURED OBJ: " 'blue)
-;                     ; (display-color obj 'blue)
-;                     ; (newline)
-;                     (test-let ((struct-list (struct->list obj)))
-;                         (if (struct? input)
-;                             (test-let ((input-list-struct (struct->list input)))
-;                                     ;    (struct-list (struct->list obj)))
-
-;                                 ;; If the structs match the name/type, check the children
-;                                 (display-color "CALLING MAP" 'red)
-;                                 (newline)
-;                                 (and (equal? (car struct-list) (car input-list-struct))
-;                                     ; (display-color "CALLING MAP" 'red)
-;                                     ; (newline)
-;                                     (test-let ((children (map make-identity-pred (cdr struct-list))))
-;                                             (lst-func-loop
-;                                                 ; (map make-identity-pred (cdr struct-list))
-;                                                 children
-;                                                 (cdr input-list-struct)))))
-;                         #f))) 'struct-contract)]))
-
-
-(struct Applesauce (a b c))
-(struct Bananas (foo bar baz))
-
-(define identity-contract (make-identity-pred (Applesauce "test" 'hello (Bananas 1 2 3))))
-
-; (define identity-contract (make-identity-pred (Applesauce (Bananas 1 2 3) 'hello 10)))
-
-; (displayln (identity-contract (Applesauce "blagh" 'test (Bananas 3 4 5))))
-
-(displayln (identity-contract (Applesauce "blagh" 'test (Bananas 1 2 3))))
-
-; (identity-contract (Applesauce "blagh" 'test (Bananas 3 4 5)))
-
-;; Identity contract
-;; Get the predicate that satisfies the most limited type information for a given func
-;; Returns the contract that satisfies a given type most succinctly?
-
-(struct Some (value))
-(struct None ())
-
-;; Contracts for option
-(define (Option/c pred)
-    (make/c (fn (x) 
-                (cond [(Some? x) (pred (Some-value x))]
-                      [(None? x) #t]
-                      [else #f])) 
-            'Option/c))
-
-(define (Option? value)
-    (or (Some? value) (None? value)))
-
-(define (inner-value-contract option)
-    (cond [(Some? option) (make-identity-pred (unwrap-some option))]
-          [(None? option) any/c]
-          [else any/c]))
-
-;; Map - explore dynamic dispatch with contracts?
-(define/contract (map-option option func)
-    (->i ([option Option?]
-          [func (option) (->/c (inner-value-contract option) any/c)])
-          [result Option?])
-
-    (cond [(Some? option) (Some (func (Some-value option)))]
-          [(None? option) (None)]))
-
-;; Get the inner value of the option - contract checking along the way
-;; Figure out how to turn off contracts on OptLevel3 regardless - 
-;; this would speed up performance a lot - also figure out how to map this to compile time options in Rust
-(define (unwrap-some option)
-    (Some-value option))
-
-
-(define test (Some 10))
-
-; (define/contract (add10 word)
-;     (->/c string? string?)
-;     word)
-
-; (displayln (map-option test (lambda (x) (string->int x))))
-
-
-
-; (contract/out o-map (->/c (t : predicate?) (Option/c t) (->/c t Option?) Option?))
-
-; (define (map-option option func)
-;     (cond [(Some? option) (Some (func (Some-value option)))]
-;           [(None? option) option]))
-
-;; Define a generic that is then bound and enforced to be equivalent for each of the fields
-;; For instance:
-; (->t [(K : predicate?)
-;       (V : predicate?)]
-
-;       (Option/c t)
-
-; (->i ([option Option?]
-;       [func (option) (and/c (->/c _ Option?) )]
-
-; ))
-
-;; Implement generics as well
-;; dependent contracts could take an optional parameter that must be unified - i.e. the same
-
-; (->i ([x number?]
-;         [y (x) (>=/c x)])
-;         [lolol (x y) (and/c number? (>=/c (+ x y)))])
\ No newline at end of file
diff --git a/steel-examples/dfs.scm b/steel-examples/dfs.scm
deleted file mode 100644
index fb1b56028..000000000
--- a/steel-examples/dfs.scm
+++ /dev/null
@@ -1,121 +0,0 @@
-;; implementation of a dfs in steel
-
-;; Given a node and a graph
-;; node -> 'a
-;; graph -> '((a b c) (b d) (e f))
-;;
-;; returns the neighbors
-;; ex.
-;; (get-neighbors 'a graph) => '(b c)
-;;
-(define (get-neighbors node graph)
-  (define found-neighbors (assoc node graph))
-  (if found-neighbors
-      (cdr found-neighbors)
-      '()))
-
-(define (longest  lst)
-  (foldr (λ (a b) (if (> (length a) (length b)) a b))
-         '()
-         lst))
-
-(define (reverse ls)
-  (define (my-reverse-2 ls acc)
-    (if (null? ls)
-      acc
-      (my-reverse-2 (cdr ls) (cons (car ls) acc))))
-  (my-reverse-2 ls '()))
-
-(define (first-step curr end graph)
-  (define neighbors (get-neighbors curr graph))
-  (longest (map (lambda (x) (dfs x end '() '() graph)) neighbors)))
-
-
-(define (member? x los)
-  (cond
-    ((null? los) #f)
-    ((equal? x (car los)) #t)
-    (else (member? x (cdr los)))))
-
-;; iteratively tries each neighbor
-;; quits when the length is worse
-(define (try-all-neighbors neighbors best-path end new-path graph)
-  (if (not (empty? neighbors))
-      (let* ((next-neighbor (car neighbors))
-             (found-path (dfs next-neighbor end new-path best-path graph)))
-        (if (> (length found-path) (length best-path))
-            (try-all-neighbors (cdr neighbors) found-path end new-path graph)
-            (try-all-neighbors (cdr neighbors) best-path end new-path graph)))
-      best-path))
-
-; (define dfs
-;   (λ (curr end path best-path graph)
-;     ((λ (neighbors)
-;          ((λ (new-path)
-;               (if (equal? curr end)
-;                 (cons curr path)
-;                 (if (member? curr path)
-;                   (quote
-;                     ())
-;                   (if neighbors
-;                     (try-all-neighbors
-;                        neighbors
-;                        best-path
-;                        end
-;                        (cons curr path)
-;                        graph)
-;                     (quote
-;                       ())))))
-;             (cons curr path)))
-;        (get-neighbors curr graph))))
-
-
-(define (dfs curr end path best-path graph)
-  (define neighbors (get-neighbors curr graph))
-  (define new-path (cons curr path))
-  (cond ((equal? curr end)
-         (cons curr path))
-        ((member? curr path)
-         '())
-        (neighbors
-         (try-all-neighbors neighbors best-path end (cons curr path) graph))
-        (else '())))
-
-(define (longest-path start end graph)
-  (define found-path (reverse (first-step start end graph)))
-  (cond ((empty? found-path)
-         (if (equal? start end)
-             (list start)
-             '()))
-        ((and (equal? (car found-path) start) (not (equal? start end)))
-         found-path)
-        (else (cons start found-path))))
-
-
-(longest-path 'a 'c '((a b) (b c))) ;; '(a b c)
-(longest-path 'a 'c '((a b) (b a c))) ;; '(a b c)
-(longest-path 'a 'c '((a d e f g b) (b a c))) ;; '(a b c)
-(longest-path 'a 'a '((a b) (b a c))) ;; '(a b a)
-(longest-path 'a 'c '((a b) (b a) (c))) ;; '()
-(longest-path 'a 'f '((a b c) (b f) (c d) (d e) (e f))) ;; '(a c d e f)
-(longest-path 'a 'f '((a b c a) (b c d) (c e a) (d e f) (e d f))) ;; '(a b c e d f)
-(longest-path 'a 'a '((a b c a) (b c d) (c e a) (d e f) (e d f))) ;; '(a b c a)
-(longest-path 'a 'a '((a b) (b c))) ;; '(a)
-(longest-path 'a 'a '((a a b) (b c))) ;; '(a a)
-(longest-path 'a 'a '((a b a) (b c))) ;; '(a a)
-(longest-path 'a 'b '((a b) (b c) (c b))) ;; '(a b)
-(longest-path 'a 'b '((a b c) (b c) (c b))) ;; '(a c b)
-
-(equal? (longest-path 'a 'c '((a b) (b c))) '(a b c))
-(equal? (longest-path 'a 'c '((a b) (b a c))) '(a b c))
-(equal? (longest-path 'a 'c '((a d e f g b) (b a c))) '(a b c))
-(equal? (longest-path 'a 'a '((a b) (b a c))) '(a b a))
-(equal? (longest-path 'a 'c '((a b) (b a) (c))) '())
-(equal? (longest-path 'a 'f '((a b c) (b f) (c d) (d e) (e f))) '(a c d e f))
-(equal? (longest-path 'a 'f '((a b c a) (b c d) (c e a) (d e f) (e d f))) '(a b c e d f))
-(equal? (longest-path 'a 'a '((a b c a) (b c d) (c e a) (d e f) (e d f))) '(a b c a))
-(equal? (longest-path 'a 'a '((a b) (b c))) '(a))
-(equal? (longest-path 'a 'a '((a a b) (b c))) '(a a))
-(equal? (longest-path 'a 'a '((a b a) (b c))) '(a a))
-(equal? (longest-path 'a 'b '((a b) (b c) (c b))) '(a b))
-(equal? (longest-path 'a 'b '((a b c) (b c) (c b))) '(a c b))
diff --git a/steel-examples/fib.scm b/steel-examples/fib.scm
deleted file mode 100644
index d805b2cbf..000000000
--- a/steel-examples/fib.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(define (fib n) 
-    (if (<= n 2) 
-        1
-        (+ (fib (- n 1)) (fib (- n 2)))))
-
-(fib 28)
diff --git a/steel-examples/fib_contract.scm b/steel-examples/fib_contract.scm
deleted file mode 100644
index b2e8e125b..000000000
--- a/steel-examples/fib_contract.scm
+++ /dev/null
@@ -1,7 +0,0 @@
-(define/contract (fib n) 
-    (->/c integer? integer?)
-    (if (<= n 2) 
-        1
-        (+ (fib (- n 1)) (fib (- n 2)))))
-
-(fib 20)
\ No newline at end of file
diff --git a/steel-examples/fibiter.scm b/steel-examples/fibiter.scm
deleted file mode 100644
index 1ea453f34..000000000
--- a/steel-examples/fibiter.scm
+++ /dev/null
@@ -1,6 +0,0 @@
-(define (fib n)
-  (define (loop a b n)
-    (if (= n 0)
-        a
-        (loop b (+ a b) (- n 1))))
-  (loop 0 1 n))
diff --git a/steel-examples/forest.scm b/steel-examples/forest.scm
deleted file mode 100644
index 8ee5a0145..000000000
--- a/steel-examples/forest.scm
+++ /dev/null
@@ -1,91 +0,0 @@
-(define (make-node datum children)
-  (cons datum children))
-
-(define (datum node)
-  (car node))
-
-(define (children node)
-  (cdr node))
-
-(define (leaf datum)
-  (make-node datum '()))
-
-(define (cities name-list)
-  (map leaf name-list))
-
-
-(define world-tree
-  (make-node
-   'world
-   (list (make-node
-          'italy
-          (cities '(venezia riomaggiore firenze roma)))
-         (make-node
-          '(united states)
-          (list (make-node
-                 'california
-                 (cities '(berkeley (san francisco) gilroy)))
-                (make-node
-                 'massachusetts
-                 (cities '(cambridge amherst sudbury)))
-                (make-node 'ohio (cities '(kent)))))
-         (make-node 'zimbabwe (cities '(harare hwange)))
-         (make-node 'china
-                    (cities '(beijing shanghai guangzhou suzhou)))
-         (make-node
-          '(great britain)
-          (list
-           (make-node 'england (cities '(liverpool)))
-           (make-node 'scotland
-                      (cities '(edinburgh glasgow (gretna green))))
-           (make-node 'wales (cities '(abergavenny)))))
-         (make-node
-          'australia
-          (list
-           (make-node 'victoria (cities '(melbourne)))
-           (make-node '(new south wales) (cities '(sydney)))
-           (make-node 'queensland
-                      (cities '(cairns (port douglas))))))
-         (make-node 'honduras (cities '(tegucigalpa))))))
-
-
-(define (leaf? node)
-  (null? (children node)))
-
-
-(define (count-leaves tree)
-  (if (leaf? tree)
-      1
-      (count-leaves-in-forest (children tree))))
-
-(define (count-leaves-in-forest forest)
-  (if (null? forest)
-      0
-      (+ (count-leaves (car forest))
-         (count-leaves-in-forest (cdr forest)))))
-
-
-(define (in-tree? place tree)
-  (or (equal? place (datum tree))
-      (in-forest? place (children tree))))
-
-(define (in-forest? place forest)
-  (if (null? forest)
-      #f
-      (or (in-tree? place (car forest))
-          (in-forest? place (cdr forest)))))
-
-
-(define (locate city tree)
-  (if (equal? city (datum tree))
-      (list city)
-      (let ((subpath (locate-in-forest city (children tree))))
-        (if subpath
-            (cons (datum tree) subpath)
-            #f))))
-
-(define (locate-in-forest city forest)
-  (if (null? forest)
-      #f
-      (or (locate city (car forest))
-          (locate-in-forest city (cdr forest)))))
diff --git a/steel-examples/inline.scm b/steel-examples/inline.scm
deleted file mode 100644
index 32545d547..000000000
--- a/steel-examples/inline.scm
+++ /dev/null
@@ -1,216 +0,0 @@
-;; Constant propagation
-;; Need to take an argument and check if its a constant value
-;; If it is a constant value, substitute the value in the source code
-
-
-;; (define (test)
-;;   (+ 1 2 3 4 (+ 5 6 7 8 (+ 9 10 11 12))))
-
-
-;; (define (blagh)
-;;   (test))
-
-
-;; (define (collect-global-context))
-
-;; gotta fix this in the prelude
-(define (reduce op z lst)
-  (cond ((null? lst) z)    ; just pass it in as another argument
-    (else (reduce op
-                  (op z (car lst))  ; NB! `z` as first arg
-                  (cdr lst)))))
-
-(define *program*
-  '((define test (lambda () (+ 1 2 3 4 (+ 4 5 6 7 8) (+ 9 10 11 12))))
-    (define blagh (lambda () (test)))
-    (define foo (lambda () (blagh)))
-    (define bar foo)
-    (define function-with-args (lambda (x y) (+ x y)))
-    (define add1 (lambda (x) (+ x 1)))))
-
-
-;; if its a definition, returns the pair of (name, body)
-(define (define-expr? expr)
-  (if (and (list? expr)
-           (equal? 3 (length expr))
-           (equal? (car expr) 'define))
-      (cdr expr)
-      #f))
-
-;; takes an expression, and if its a definition
-;; puts the pair into the map
-(define (insert-define-var env expr)
-  (let ((p (define-expr? expr)))
-    (if p
-        (hash-insert env (car p) (cadr p))
-        env)))
-
-;; This gives the top level definitions
-(define initial-env
-  (reduce insert-define-var (hash) *program*))
-
-(define (lookup sym)
-  (if (hash-contains? initial-env sym)
-      (hash-get initial-env sym)
-      #f))
-
-;; Heres the deal:
-;; In order to remove the closure, form and instead just replace the body as it is
-;; We need to assert that the argument to the function is only used once
-
-;; For now, just assume that the function has one argument
-(define (count-argument-usages sym expr)
-  (cond [(equal? sym expr) 1]
-        [(list? expr)
-         (apply + (map (lambda (x) (count-argument-usages sym x)) expr))]
-        [else 0]))
-
-;; Any true
-(define (any lst)
-  (if (null? lst)
-      #f
-      (if (car lst)
-          #t
-          (any (cdr lst)))))
-
-
-;; This is also not quite correct
-;; This should take into account aliasing
-(define (recursive? expr)
-  (define ctx (cadr expr))
-  (define (recursive?* expr)
-    (cond
-      [(list? expr)
-       (if (equal? (car expr) ctx)
-           #t
-           (any (map recursive?* (cdr expr))))]
-      [else #f]))
-  (recursive?* expr))
-
-
-(recursive? '(define loop
-               (lambda () (loop))))
-
-
-
-
-;; We also need to know that the body of the function in which we're inlining has no sideeffects that we could be goofing up evaluation order w/
-;; (count-argument-usages 'x '(+ x (+ x y)))
-
-;; (define (perform-native-substitution))
-
-
-;; (define (can-perform-beta-reduction func)
-;;   )
-
-
-;; initial-env
-
-;; ignore the fact that they could have been shadowed... for now
-;; (define (inline-expr expr))
-
-;; We want to inline a given expr, outside of the
-(define (naive-inline expr)
-  (cond [(symbol? expr)
-         (define bound-expr (lookup expr))
-         (if bound-expr
-             bound-expr
-             expr)]
-        [(list? expr) (map naive-inline expr)]
-        [else expr]))
-
-(naive-inline 'bar)
-(naive-inline '(blagh))
-(naive-inline '(add1 10))
-
-
-
-;; Argument Substitution below
-;; -----------------------------------------
-
-(define (lambda-expression-application? expr)
-  (if (and (>= (length expr) 2)
-           (list? (car expr))
-           (equal? (car (car expr)) 'lambda))
-      (car (cdr (car expr)))
-      '()))
-
-(define (atom? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-(define (constant? expr)
-  (or (number? expr)
-      (symbol? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-
-;; hash -> (listof sym?) -> (listof any?) -> hash
-(define (bind-args env list-of-symbols args)
-  (if (or (null? list-of-symbols) (null? args))
-      env
-      (bind-args
-       (hash-insert env
-                    (car list-of-symbols) (car args))
-       (cdr list-of-symbols)
-       (cdr args))))
-
-;; this is just an alias here
-(define get-application-args cdr)
-
-;; naive substitution of constant arguments
-(define (naive-subst* expr env)
-  ;; (displayln expr)
-  ;; (displayln (symbol? expr))
-  (cond [(null? expr) expr]
-        [(atom? expr) expr]
-        [(symbol? expr)
-         ;; (displayln "inside symbol case with: ")
-         ;; (displayln expr)
-         ;; (displayln (hash-contains? env expr))
-         ;; (displayln env)
-         (cond
-           [(hash-contains? env expr)
-            (define expr-value (hash-get env expr))
-            ;; (displayln expr-value)
-            (if (constant? expr-value)
-                (begin
-                  ;; (mark-changed)
-                  expr-value)
-                expr)]
-           [else expr])]
-        [(lambda-expression-application? expr)
-         ;; (displayln "Found an expression")
-         ;; (displayln expr)
-         (define list-of-bindings (lambda-expression-application? expr))
-         (define list-of-args (get-application-args expr))
-         (define new-env (bind-args env list-of-bindings list-of-args))
-         ;; (displayln "lambda evaluation")
-         ;; (displayln new-env)
-         ;; (displayln (caddr (car expr)))
-         ;; TODO check if you can remove the constant value
-         ;; in the argument position
-         (cons
-          (list
-           'lambda
-           (car (cdr (car expr)))
-           (naive-subst* (caddr (car expr)) new-env))
-          (cdr expr))]
-        [else
-         (map (lambda (x) (naive-subst* x env)) expr)]))
-
-(define (naive-subst expr)
-  ;; (init-changed)
-  (naive-subst* expr (hash)))
-
-
-;; (naive-subst
-;;  (naive-inline '(add1 10)))
-
-;; (naive-subst '((lambda (x) (* x x)) y))
diff --git a/steel-examples/letrec.scm b/steel-examples/letrec.scm
deleted file mode 100644
index 18151a6b0..000000000
--- a/steel-examples/letrec.scm
+++ /dev/null
@@ -1,145 +0,0 @@
-; (let ([f void])
-;   (let ([ft (let ([g void])
-;               (let ([gt (let ([x 5])
-;                               (lambda () ...))])
-;                     (set! g gt))
-;                   (lambda () ... g ...))])
-;   (set! f ft))
-;   f)
-
-
-;; Just turn the whole thing into a let-rec?
-(define (blah)
-    (define x 10)
-    (displayln "hello world")
-    (define (foo x) (if (= x 10000) x (bar (+ x 1))))
-    (define (bar x) (if (= x 10000) x (foo (+ x 1))))
-    (displayln x)
-    (foo 0))
-
-;; TODO
-;; handle case where define sequentially uses a define
-;; before it
-;; this should turn into a let* effectively
-(define (blargh)
-  (define x (+ 1 2 3 4))
-  (define y (+ 1 2 3 4 x))
-  (displayln x)
-  (displayln y)
-  (list 1 2 3 4 5 x y))
-
-; (define blargh 
-;   (lambda () 
-;     ((lambda (x y) 
-;       ((lambda (#####x0 #####y1) 
-;         (begin 
-;           (set! x #####x0) 
-;           (set! y (#####y1)) (displayln x) (displayln y) (list 1 2 3 4 5 x y))) (+ 1 2 3 4) (lambda () (+ 1 2 3 4 x)))) 123 123)))
-
-
-; (define blah 
-;   (lambda () 
-;     ((lambda (x #####define-conversion1 foo bar) 
-;       ((lambda (#####x0 #####define-conversion1 #####foo2 #####bar3) 
-;         (begin 
-;           (set! x #####x0) 
-;           (set! foo #####foo2) 
-;           (set! bar #####bar3) 
-;           (displayln x) 
-;           (foo 0))) 
-;         10 
-;         (displayln "hello world") 
-;         (lambda (x) (if (= x 10000) x (bar (+ x 1)))) 
-;         (lambda (x) (if (= x 10000) x (foo (+ x 1)))))) 
-;     0 0 0 0)))
-
-
-; (define handle-intern-letter 
-;   (lambda (char-list lst prefix-chars) 
-;     ((lambda (char next-prefix) 
-;       ((lambda (#####char0 #####next-prefix1) 
-;         (begin 
-;           (set! char #####char0) 
-;           (set! next-prefix #####next-prefix1) 
-;           (if (empty? lst) 
-;             (begin (list (trie char (create-children (rest char-list) empty next-prefix) #false next-prefix))) 
-;             (if (< char (trie-char (first lst))) 
-;               (begin (cons (trie char (create-children (rest char-list) empty next-prefix) #false next-prefix) lst)) (if (= char (trie-char (first lst))) (begin (cons (trie char (create-children (rest char-list) (trie-children (first lst)) next-prefix) (trie-end-word? (first lst)) (trie-word-up-to (first lst))) (rest lst))) (begin (cons (first lst) (create-children char-list (rest lst) prefix-chars)))))))) 
-              
-;       (first char-list) (push-back prefix-chars char))) 0 0)))
-
-
-; (define handle-last-letter 
-;   (lambda (char-list lst prefix-chars) 
-;     ((lambda (char next-prefix) 
-;       ((lambda (#####char0 #####next-prefix1) 
-;         (begin 
-;           (set! char #####char0) 
-;           (set! next-prefix #####next-prefix1) 
-;           (if (empty? lst) 
-;             (begin (list (trie char empty #true next-prefix))) (if (< char (trie-char (first lst))) (begin (cons (trie char empty #true next-prefix) lst)) (if (= char (trie-char (first lst))) (begin (cons (trie char (trie-children (first lst)) #true next-prefix) (rest lst))) (begin (cons (first lst) (create-children char-list (rest lst) prefix-chars)))))))) 
-      
-;       (first char-list) (push-back prefix-chars char))) 69 69)))
-
-(define (test)
-  (let ((x 10) (y 0) (foo void) (bar void))
-        (let ((foo-prime (lambda (x) (if (= x 10000) x (bar (+ x 1)))))
-              (bar-prime (lambda (x) (if (= x 10000) x (foo (+ x 1))))))
-              (set! foo foo-prime)
-              (set! bar bar-prime)
-              (set! y x))
-        (foo 0)))
-
-(define (test-loop)
-  (let ((loop void))
-    (let ((loop-prime (lambda (x) 
-                            (if (= x 10000)
-                                x
-                                (loop (+ x 1))))))
-      (set! loop loop-prime))
-    (loop 0)))
-
-
-(define (test-loop-2)
-  (define (loop x)
-    (if (= x 10000)
-        x
-        (loop (+ x 1))))
-  (loop 0))
-
-; (define test-loop-2 
-;   (lambda () 
-;     ((lambda (loop) 
-;       ((lambda (#####loop0) 
-;         (begin 
-;         (set! loop #####loop0) 
-;         (loop 0))) 
-;       (lambda (x) 
-;         (if (= x 10000) 
-;             x 
-;             (loop (+ x 1)))))) 0)))
-
-
-(define (thing)
-  (define blagh 10)
-  (displayln 15)
-  (define blegh 20)
-  (displayln 25))
-
-
-
-;; TODO this transformation is how I should implement defines
-;; Do compile time transformation of AST -> this form
-
-; (let ((is-even? void) (is-odd? void))
-;   (let ((is-even?-prime 
-;           (lambda (n) (or (zero? n) 
-;                           (is-odd? (sub1 n)))))
-        
-;         (is-odd?-prime
-;           (lambda (n) (and (not (zero? n))
-;                            (is-even? (sub1 n))))))
-
-;         (set! is-even? is-even?-prime)
-;         (set! is-odd? is-odd?-prime))
-;   (is-odd? 12))
\ No newline at end of file
diff --git a/steel-examples/loop.scm b/steel-examples/loop.scm
deleted file mode 100644
index 8dd5768ad..000000000
--- a/steel-examples/loop.scm
+++ /dev/null
@@ -1,31 +0,0 @@
-; (define loop (lambda (x) (if (= x 10000) x (loop (+ x 1)))))
-
-; (define (loop)
-;     (define (foo x) (bar x))
-;     (define (bar x) (foo x))
-;     (foo 10))
-
-; (define (test)
-;     (let ((value 123456))
-;         (let ((test (lambda (x) value)))
-;             test)
-;     value))
-
-(define (test)
-    (let ((loop void))
-        (let ((loop-prime (lambda (x) 
-                            (if (= x 10000)
-                                x
-                                (loop (+ x 1))))))
-            (set! loop loop-prime))
-    (loop 0)))
-
-
-(define (blagh x)
-    (if (= x 100)
-        x
-        (begin
-            (test)
-            (blagh (+ x 1)))))
-
-(blagh 0)
\ No newline at end of file
diff --git a/steel-examples/matcher.scm b/steel-examples/matcher.scm
deleted file mode 100644
index ea5a4b57c..000000000
--- a/steel-examples/matcher.scm
+++ /dev/null
@@ -1,403 +0,0 @@
-;; Sets of useful ideas for things
-;; #lang racket
-
-;; ------------------- match functions ----------------------
-
-;; Tells me if this is a free variable (for now)
-(define (var? x)
-  (and (symbol? x)
-       (starts-with? (symbol->string x) "?")))
-
-(define (ignore? x)
-  (equal? x '_))
-
-(define (many? x)
-  (and (symbol? x)
-       (let ((str (symbol->string x)))
-         (and (starts-with? str "?")
-              (ends-with? str "...")))))
-
-
-(define (equal-or-insert hm key value)
-  (define existing-value (hash-try-get hm key))
-  (if existing-value
-      (if (equal? existing-value value)
-          hm
-          #f)
-      (hash-insert hm key value)))
-
-(define (collect-until-last-p input collected)
-  (if (null? (cdr input))
-      (list (car input) collected)
-      (collect-until-last-p (cdr input) (cons (car input) collected))))
-
-
-(define (collect-until-last input)
-  (collect-until-last-p input '()))
-
-
-;; Bindings or #false if there is not a match
-(define (match-p pattern input bindings)
-  (cond [(and (list? pattern)
-              (not (null? pattern))
-              (many? (car pattern)))
-         (if (null? (cdr pattern))
-             (equal-or-insert bindings (car pattern) input)
-             (let ((collected (collect-until-last input)))
-               (define remainder (car collected))
-               (define collected-list (reverse (car (cdr collected))))
-               (if (null? (cdr (cdr pattern)))
-                   (let ((remainder-bound
-                          (equal-or-insert bindings
-                                           (car (cdr pattern)) remainder)))
-                     (equal-or-insert remainder-bound (car pattern) collected-list))
-                   #f)))]
-        [(var? pattern) (equal-or-insert bindings pattern input)]
-        [(ignore? pattern) bindings]
-        [(atom? pattern) (if (equal? pattern input) bindings #f)]
-        [(null? pattern) (if (null? input) bindings #f)]
-        [(null? input) #f]
-        [(and (list? pattern) (not (list? input))) #f]
-        [else
-         (define remaining (match-p (cdr pattern) (cdr input) bindings))
-         (if remaining
-             (match-p (car pattern) (car input) remaining)
-             #f)]))
-
-(define (match pattern input)
-  (match-p pattern input (hash)))
-
-
-;; ---------------- tests --------------------
-
-;; Pretty print for testing purposes
-;; Throw in the assert as well for testing
-(define (test name input expected)
-;   (assert! (equal? input expected))
-  (if (equal? input expected)
-      (begin
-        (display "> ")
-        (display name)
-        (display " ... ")
-        (display-color "OK" 'green)
-        (newline))
-      (begin
-        (display "> ")
-        (display name)
-        (display " ... ")
-        (display-color "FAILED" 'red)
-        (newline)
-        (display "    Expected: ")
-        (display expected)
-        (display ", Found ")
-        (displayln input))))
-
-(displayln "--------------------- match tests ----------------------")
-
-;; Matches a pattern explicitly
-(test "Simple match" 
-      (match '?x '(1 2 3 4))
-      (hash '?x '(1 2 3 4)))
-
-;; If the pattern match fails, return false
-(test "Pattern match fails returns false"
-      (match '(10 2 ?z 5) '(1 2 3 4))
-      #f)
-
-;; If the pattern fails because we didn't match exactly, bail
-(test "Pattern fails because constants don't match exactly"
-      (match '(1 2 3 4 5) '(1 2 3 4))
-      #f)
-
-;; Should fail
-(test "Lengths unequal fails"
-      (match '(?x ?y ?z 4 5) '(1 2 3 4))
-      #f)
-
-;; Should succeed with x y z bound to 1 2 3
-(test "Successful pattern match on simple list"
-      (match '(?x ?y ?z 4 5) '(1 2 3 4 5))
-      (hash '?x 1 '?y 2 '?z 3))
-
-;; Should succed with x y z bound to 1 2 3
-(test "Nested patterns match"
-      (match '(?x (?y ?z)) '(1 (2 3)))
-      (hash '?x 1 '?y 2 '?z 3))
-
-;; Also should work
-(test "Deep nested pattern"
-      (match '(?x (?y (?z (?applesauce ?bananas))))
-        '(1 (2 (3 (4 5)))))
-      (hash '?x 1 '?y 2 '?z 3 '?applesauce 4 '?bananas 5))
-
-
-;; Also should work
-(test "Deep nested pattern with list matching"
-      (match '(?x (?y (?z (?applesauce ?bananas))))
-        '(1 (2 (3 (4 (1 2 3 4 5))))))
-      (hash '?x 1 '?y 2 '?z 3 '?applesauce 4 '?bananas '(1 2 3 4 5)))
-
-
-;; Match the bindings
-(test "Pattern variables once bound retain their value"
-      (match '(?x ?y ?x) '(1 2 1))
-      (hash '?x 1 '?y 2))
-
-;; Should fail since x doesn't match what was there at first
-(test "Matching fails when variable has two different values"
-      (match '(?x ?y ?x) '(1 2 3))
-      #f)
-
-;; Shouldn't fail, should ignore whatever is in the second position
-(test "Wildcard ignores the matching at that position"
-      (match '(?x _ 3) '(1 (1 2 3) 3))
-      (hash '?x 1))
-
-;; a => 1
-;; x => '(2 3 4 5)
-(test "Basic ellipses matching works"
-      (match '(?a ?x...) '(1 2 3 4 5))
-      (hash '?a 1 '?x... '(2 3 4 5)))
-
-
-(test "Ellipses matches to empty list"
-      (match '(?first ?rest...) '(1))
-      (hash '?first 1 '?rest... '()))
-
-
-(test "Ellipses matches until next value"
-      (match '(?first ?rest... ?last) '(1 2 3 4 5))
-      (hash '?first 1 '?rest... '(2 3 4) '?last 5))
-
-; TODO this should error out as illegal pattern
-(test "Ellipses does not match multiple characters at the end"
-      (match '(?first ?rest... ?second-last ?last) '(1 2 3 4 5 6))
-      #f
-      ; (hash '?first 1 '?rest... '(2 3 4) '?last 5 '?last 6)
-      )
-
-(test "Ellipses with nested pattern"
-      (match '(?x (?y ?z (?foo ?bar...))) '(1 (2 3 (4 5 6 7 8 9 10))))
-      (hash '?x 1 '?y 2 '?z 3 '?foo 4 '?bar... '(5 6 7 8 9 10)))
-
-
-(test "Empty pattern matches empty list"
-      (match '() '())
-      (hash))
-
-(test "Empty pattern fails on non empty list"
-      (match '() '(1 2 3))
-      #f)
-
-(test "Single variable with empty list"
-      (match '?x '())
-      (hash '?x '()))
-
-(test "Constant matches constant"
-      (match (list 1 2 3) (list 1 2 3))
-      (hash))
-
-(test "List pattern does not match constant"
-      (match (list 1 2 3 4 5) 10)
-      #f)
-
-(test "Constant pattern does not match list"
-      (match 10 (list 1 2 3 4 5))
-      #f)
-
-(test "Wildcard passes"
-      (match '_ (list 1 2 3 4 5))
-      (hash))
-
-
-;; ----------------- match! syntax --------------------
-
-
-(define-syntax syntax->pattern
-  (syntax-rules ()
-    [(syntax->pattern (var1))
-     '(var1)]
-    [(syntax->pattern (var1 var2 ...))
-       (cons 'var1 (syntax->pattern (var2 ...)))]
-    [(syntax->pattern var)
-     'var]))
-
-
-(define-syntax syntax-pattern->lets
-  (syntax-rules ()
-    [(syntax-pattern->lets ((var1)) bindings body)
-     (syntax-pattern->lets (var1) bindings body)]
-    [(syntax-pattern->lets ((var1 ...) rest ...) bindings body)
-     (syntax-pattern->lets (var1 ...) bindings
-                           (syntax-pattern->lets (rest ...) bindings body))]
-    [(syntax-pattern->lets (var1) bindings body)
-     ;; TODO
-     (syntax-const-if var1 body
-                      (let ((var1 (hash-try-get bindings 'var1)))
-                        body))]
-    [(syntax-pattern->lets (var1 var2 ...) bindings body)
-     (syntax-const-if var1
-                      (syntax-pattern->lets (var2 ...) bindings body)
-                      (let ((var1 (hash-try-get bindings 'var1)))
-                        (syntax-pattern->lets (var2 ...) bindings body)))]
-    [(syntax-pattern->lets () bindings body)
-     body]
-    [(syntax-pattern->lets var bindings body)
-     (syntax-const-if var body
-                      (let ((var (hash-try-get bindings 'var)))
-                        body))]))
-
-
-
-;; TODO add case for the remaining - when there is no else case given
-;; and it should just error out
-(define-syntax match-dispatch
-  (syntax-rules (else)
-    ;; Explicitly giving an else case
-    [(match-dispatch expr [else e1 ...])
-     (begin e1 ...)]
-    ;; Generic recursive case
-    [(match-dispatch expr [p1 e2 ...] c1 ...)
-     (let ((match? (match (syntax->pattern p1) expr)))
-       (if match?
-           (syntax-pattern->lets p1 match? (begin e2 ...))
-           (match-dispatch expr c1 ...)))]
-    ;; When there isn't an else case given, the last case
-    ;; Should include a failure mode
-    [(match-dispatch expr (p1 e2 ...))
-     (let ((match? (match (syntax->pattern p1) expr)))
-       (if match?
-           (syntax-pattern->lets p1 match? (begin e2 ...))
-           (error! "Unable to match expression: " expr " to any of the given patterns")))]))
-
-
-(define-syntax match!
-  (syntax-rules ()
-    [(match expr pat)
-     (let ((evald-expr expr))
-       (match-dispatch evald-expr pat))]
-    [(match expr pats ...)
-     (let ((evald-expr expr))
-       (match-dispatch evald-expr pats ...))]))
-
-
-;; --------------------- match! tests ------------------------
-
-(displayln "--------------------- match! tests ----------------------")
-
-(test "Matches constant patterns"
-      (match! (list 1 2 3 4 5)
-              ((1 2 3 4 5) 'case1))
-      'case1)
-
-
-(test "Matches patterns with constants mixed in"
-      (match! (list 1 2 3 4 5)
-              ((?x 2 ?y 4 ?z) (+ ?x ?y ?z)))
-      (+ 1 3 5))
-
-
-(test
-   "Matches patterns with constants mixed in"
-   ((λ (evald-expr)
-        ((λ (match?)
-             (if match?
-               ((λ (?x)
-                    ((λ (?y)
-                         ((λ (?z)
-                              (+ ?x ?y ?z))
-                            (hash-try-get
-                               match?
-                               (quote
-                                 ?z))))
-                       (hash-try-get match? (quote ?y))))
-                  (hash-try-get match? (quote ?x)))
-               (error!
-                  "Unable to match expression: "
-                  evald-expr
-                  " to any of the given patterns")))
-           (match
-              (cons
-                 (quote
-                   ?x)
-                 (cons
-                    (quote
-                      2)
-                    (cons
-                       (quote
-                         ?y)
-                       (cons (quote 4) (quote (?z))))))
-              evald-expr)))
-      (list 1 2 3 4 5))
-   (+ 1 3 5))
-
-; ((λ (evald-expr)
-;       ((λ (match?)
-;             (if match?
-;                   ((λ (?x)
-;                         ((λ (?y)
-;                               ((λ (?z) (+ ?x ?y ?z))
-;                                     (hash-try-get match? (quote ?z))))
-;                         (hash-try-get match? (quote ?y))))
-;                   (hash-try-get match? (quote ?x)))
-;             (error! "Unable to match expression: " evald-expr " to any of the given patterns")))
-;       (hash '?x 1 '?y 3 '?z 5)))
-;       (list 1 2 3 4 5))
-
-
-; ; ((λ (evald-expr)
-; ((λ (match?)
-;       (if match?
-;             ((λ (?x)
-;                   ((λ (?y)
-;                         ((λ (?z) (+ ?x ?y ?z))
-;                               (hash-try-get match? (quote ?z))))
-;                   (hash-try-get match? (quote ?y))))
-;             (hash-try-get match? (quote ?x)))
-;       (error! "Unable to match expression: to any of the given patterns")))
-; (hash '?x 1 '?y 3 '?z 5))
-;       ; (list 1 2 3 4 5))
-
-
-(test "Dispatches on first of multiple matching patterns"
-      (match! (list 1 2 3 4 5)
-              (?x 'case1)
-              ((?a ?b ?c ? d ?e) 'case2))
-      'case1)
-
-(test "Constants match"
-      (match! 10
-              (10 'case1))
-      'case1)
-
-(test "Successfully takes the else case on no match"
-      (match! (list 1 (list 2 (list 3)))
-              ((?x ?y ?z) 'case1)
-              (24 'case2)
-              (else 'case3))
-      'case3)
-
-
-(test "Custom map implementation succeeds"
-      ((lambda ()
-         (define (budget-map func lst)
-           (define (loop lst accum)
-             (match! lst
-                     (() accum)
-                     ((?x ?xs...)
-                      (loop ?xs...
-                            (cons (func ?x) accum)))))
-           (reverse (loop lst '())))
-         (budget-map (fn (x) (+ x 1)) (list 1 2 3 4 5))))
-      '(2 3 4 5 6))
-
-(test "Empty list matches empty list"
-      (match! '()
-              (() 'found-empty-list!)
-              ((?x ?xs...) 'found-list!))
-      'found-empty-list!)
-
-(test "Nested patterns match with bindings"
-      (match! (list (list 1 2) 3 (list 4 (list 5 6)))
-              (((?a 2) ?b (?c (5 6))) (+ ?a ?b ?c)))
-      (+ 1 3 4))
diff --git a/steel-examples/memoized.scm b/steel-examples/memoized.scm
deleted file mode 100644
index 0888dced1..000000000
--- a/steel-examples/memoized.scm
+++ /dev/null
@@ -1,123 +0,0 @@
-(struct Tokenizer (buffer delimiter))
-(struct Result (token tokenizer))
-(struct End (token))
-
-(define (reverse lst)
-  (define (reverse-help lst init)
-    (if (null? lst)
-        init
-        (reverse-help (cdr lst) (cons (car lst) init))))
-  (reverse-help lst '()))
-
-(define (next-token tokenizer)
-  (define delim (Tokenizer-delimiter tokenizer))
-  (define (consume-until-delimiter lst buffer)
-    (cond [(null? lst) (End (list->string (reverse buffer)))]
-          [(equal? (car lst) delim)
-           (begin
-             (displayln "found a delimiter")
-             (Result (list->string (reverse buffer))
-                     (Tokenizer (list->string (cdr lst)) delim)))]
-          [else
-           (consume-until-delimiter (cdr lst) (cons (car lst) buffer))]))
-  (displayln (Tokenizer-buffer tokenizer))
-  (consume-until-delimiter (string->list (Tokenizer-buffer tokenizer)) '()))
-
-;; (split-single-token input delimiter)
-
-(next-token (Tokenizer "hello world my name is matthew" #\SPACE))
-
-(define (split-single-space input)
-  (define (loop result lst)
-    (if (Result? result)
-        (loop (next-token (Result-tokenizer result))
-              (cons (Result-token result) input))
-        (cons (End-token result) input)))
-  (reverse (loop
-            (next-token
-             (Tokenizer input #\SPACE))
-            '())))
-
-
-(split-single-space "hello world my name is matthew")
-
-
-
-
-;; (define (levenshtein s t)
-;;   (define (*levenshtein s sl t tl)
-;;     (displayln s)
-;;     (cond ((zero? sl) tl)
-;;           ((zero? tl) sl)
-;;           (else
-;;            (min (+ (*levenshtein (cdr s) (- sl 1) t tl) 1)
-;;                 (min
-;;                  (+ (*levenshtein s sl (cdr t) (- tl 1)) 1)
-;;                  (+ (*levenshtein (cdr s) (- sl 1) (cdr t) (- tl 1))
-;;                     (if (equal? (car s) (car t)) 0 1)))))))
-;;   (*levenshtein (string->list s)
-;;                 (string-length s)
-;;                 (string->list t)
-;;                 (string-length t)))
-
-
-;; (levenshtein "cat" "data")
-
-;; (levenshtein "rosettacode" "raisethysword")
-
-;; TODO make generalized memoization library based off of this form
-(define *cache* (box (hash)))
-(define (update-cache! key value)
-  (set-box! *cache* (hash-insert (unbox *cache*) key value)))
-(define (cache-contains? key)
-  (define inner (unbox *cache*))
-  (if (hash-contains? inner key)
-      (hash-get inner key)
-      #f))
-
-
-;; TODO make generalized memoization library based off of this form
-(define (fib n)
-  (when (not (cache-contains? n))
-    (update-cache! n (*fib n)))
-  (cache-contains? n))
-
-(define (*fib n)
-  (if (< n 2)
-      n
-      (+ (fib (- n 1)) (fib (- n 2)))))
-
-;; (fib 100)
-
-
-;; (define a (unbox *cache*))
-;; (define b (update-cache! 'apple 'sauce))
-;; (define c (unbox *cache*))
-
-
-
-(define (levenshtein s t)
-  (define (levenshtein* s sl t tl)
-    (define args (list s sl t tl))
-    (when (not (cache-contains? args))
-      (update-cache! args (*levenshtein s sl t tl)))
-    (cache-contains? args))
-
-
-  (define (*levenshtein s sl t tl)
-    (cond ((zero? sl) tl)
-          ((zero? tl) sl)
-          (else
-           (min (+ (levenshtein* (cdr s) (- sl 1) t tl) 1)
-                (min
-                 (+ (levenshtein* s sl (cdr t) (- tl 1)) 1)
-                 (+ (levenshtein* (cdr s) (- sl 1) (cdr t) (- tl 1))
-                    (if (equal? (car s) (car t)) 0 1)))))))
-  (levenshtein* (string->list s)
-                (string-length s)
-                (string->list t)
-                (string-length t)))
-
-(levenshtein "cat" "dataaaa")
-(levenshtein "kitten" "sitting") ;; 3
-(levenshtein "rosettacode" "raisethysword")
diff --git a/steel-examples/monad.scm b/steel-examples/monad.scm
deleted file mode 100644
index c5f4f7723..000000000
--- a/steel-examples/monad.scm
+++ /dev/null
@@ -1,42 +0,0 @@
-;-- type Numbered a = (Int,a)
-(define (make-numbered-value tag val) (cons tag val))
-; accessors of the components of the value
-(define (nvalue-tag tv) (car tv))
-(define (nvalue-val tv) (cdr tv))
-
-
-
-;-- return:: a -> NumberedM a
-(define (return val)
-  (lambda (curr_counter)
-    (make-numbered-value curr_counter val)))
-
-
-;-- (>>=):: NumberedM a -> (a -> NumberedM b) -> NumberedM b
-(define (>>= m f)
-  (lambda (curr_counter)
-    (let* ((m_result (m curr_counter))
-           (n1 (nvalue-tag m_result))   ; result of the delayed computation
-           (v  (nvalue-val m_result))   ; represented by m
-
-           (m1 (f v))                   ; feed the result to f, get another m1
-           )
-      (m1 n1))))                        ; The result of the bigger monad
-
-
-(define incr
-  (lambda (n)
-    (make-numbered-value (+ 1 n) n)))
-
-
-;-- run_numberedM:: NumberedM a -> Int -> Numbered a
-;-- run_numberedM (NumberedM m) init_count = m init_count
-
-(define (runM m init-counter)
-  (m init-counter))
-
-
-;; (define computation (>>= (incr) ()))
-
-
-;; (runM (make-numbered-value "lmao" 0) 0)
diff --git a/steel-examples/nanopass.scm b/steel-examples/nanopass.scm
deleted file mode 100644
index 0d3f4c917..000000000
--- a/steel-examples/nanopass.scm
+++ /dev/null
@@ -1,444 +0,0 @@
-;; Actually instead put here a hashmap
-;; that is exposed by the root enviroment
-;;
-;; then keep track of the bindings to see if its a thing
-;; All that needs to happen is to keep track of bindings
-;; at every point
-;; if a symbol has been shadowed, then we move on
-;; later, we can provide functionality to expose const functions
-
-(define (all func lst)
-  (if (null? lst)
-      #t
-      (if (func (car lst))
-          (all func (cdr lst))
-          #f)))
-
-
-(define (constant? expr)
-  (or (number? expr)
-      (symbol? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-
-(define (constant-not-symbols? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-;; See if this maps to a constant function that exists
-(define (match-func sym bound-vars)
-  (if (and (hash-contains? *env* sym)
-           (not (hashset-contains? bound-vars sym)))
-      (hash-get *env* sym)
-      #f))
-
-;; determines if that function actually was bound by the current expression
-;; match the
-(define (bound? sym)
-  (hash-contains? *env* sym))
-
-;; either outputs the symbol used for the definition
-;; or false otherwise
-(define (define-expr? expr)
-  (if (and (list? expr)
-           (equal? 3 (length expr))
-           (equal? (car expr) 'define))
-      (cadr expr)
-      #f))
-
-(define (lambda-expression-application? expr)
-  (if (and (>= (length expr) 2)
-           (list? (car expr))
-           (equal? (car (car expr)) 'lambda))
-      (car (cdr (car expr)))
-      '()))
-
-
-;; TODO go back through and actually fix the prelude
-;; reduce is broken there
-(define (reduce op z lst)
-  (cond ((null? lst) z)    ; just pass it in as another argument
-    (else (reduce op
-                  (op z (car lst))  ; NB! `z` as first arg
-                  (cdr lst)))))
-
-;; returns the updated bound-variable set
-(define (bind-args-to-env env args)
-  (reduce hashset-insert env args))
-
-(define bind-arg-to-env hashset-insert)
-
-(define get-body-lambda-expression cddr)
-
-(define (match-if expr)
-  (equal? (car expr) 'if))
-
-;; (define (match-define expr)
-;;   (equal? (car expr) 'define))
-
-(define *changed* (box #f))
-(define (init-changed) (set-box! *changed* #f))
-(define (mark-changed) (set-box! *changed* #t))
-(define (changed?) (unbox *changed*))
-
-;; might have to return 2 values each time, the expr and the set
-;; this way I can just pass them around everywhere
-;; select the first element of the return each time
-;; select the second element whenever we want the second one
-(define (constant-fold expr bound-vars)
-  ;; (displayln expr)
-  (cond
-    ;; if its a constant, just return a pair of the expr and bound vars
-    [(constant? expr) (list expr bound-vars)]
-    ;; if its a definition, continue on the body
-    ;; return the new bound vars
-    [(define-expr? expr)
-     ;; (displayln "inside here")
-     (define new-bound-vars (bind-arg-to-env bound-vars (define-expr? expr)))
-     (list
-      (list 'define (cadr expr) (car (constant-fold (caddr expr) bound-vars)))
-      new-bound-vars)]
-    ;; if its a function application
-    ;; bind the args to whatever is there
-    ;; return a pair of the bound vars
-    [(lambda-expression-application? expr)
-     (define new-bound-vars
-       (bind-args-to-env bound-vars (lambda-expression-application? expr)))
-     (list
-      ;; constant fold the args w/ the new bound variables
-      (cons (append (list 'lambda (lambda-expression-application? expr)) ;; args
-                    (map (lambda (x)
-                           (car (constant-fold x new-bound-vars)))
-                         (get-body-lambda-expression (car expr))))
-            ;; constant fold the arguments to the function
-            (map (lambda (x)
-                   (car (constant-fold x bound-vars)))
-                 (cdr expr)))
-      bound-vars)]
-    ;; if we have an if statement
-    ;; go ahead and remove the stuff
-    [(match-if expr)
-     (define condition (car (constant-fold (car (cdr expr)) bound-vars)))
-     ;; HACK / TODO
-     ;; Find how to differentiate something like a constant expression '(1 2 3 4) which
-     ;; evaluates to a list, versus something like '(lambda (x) 10)
-     (list
-      (if (constant? condition)
-          (cond
-            [condition
-             (mark-changed)
-             (car (constant-fold (caddr expr) bound-vars))]
-            [else
-             (mark-changed)
-             (car (constant-fold (cadddr expr) bound-vars))])
-          (list
-           'if
-           condition
-           (car (constant-fold (caddr expr) bound-vars))
-           (car (constant-fold (cadddr expr) bound-vars))))
-      bound-vars)]
-    ;; [(match-define expr)
-    ;;  (displayln expr)
-    ;;  (list
-    ;;   (list 'define (cadr expr) (car (constant-fold (caadr expr) bound-vars)))
-    ;;   bound-vars)]
-
-    ;; now if it actually is a function application
-    ;; get the constants associated with the
-    [(match-func (car expr) bound-vars)
-     (define res (map (lambda (x)
-                        (car (constant-fold x bound-vars))) expr))
-     (if (all constant-not-symbols? (cdr res))
-         (begin
-           (mark-changed)
-           (list (apply (match-func (car expr) bound-vars) (cdr res)) bound-vars))
-         (list res bound-vars))]
-    [else
-     ;; (displayln "else case")
-     ;; (displayln expr)
-     (list
-      (map (lambda (x)
-                 (car (constant-fold x bound-vars))) expr)
-      bound-vars)]))
-
-
-;; (define (CF expr)
-;;   ;; (init-changed)
-;;   (car (constant-fold expr (hashset))))
-
-
-;; (CF
-;;  '(list 1 2 3 4
-;;         (+ 1 2 3 4
-;;            (+ 4 5
-;;               (+ 7 8 9 10)))))
-
-;; (CF
-;;  '(if #t 10 20))
-
-;; (CF
-;;  '(if '(1 2 3 4) 20 40))
-
-;; (CF
-;;  '(if 25 10 20))
-
-;; (CF
-;;  '(if #t
-;;       (lambda (x) 10)
-;;       25))
-
-;; (CF
-;;  '(lambda (x) (* x x)))
-
-(define (atom? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-(define lookup hash-get)
-
-;; this is just an alias here
-(define get-application-args cdr)
-
-;; hash -> (listof sym?) -> (listof any?) -> hash
-(define (bind-args env list-of-symbols args)
-  (if (or (null? list-of-symbols) (null? args))
-      env
-      (bind-args
-       (hash-insert env
-                    (car list-of-symbols) (car args))
-       (cdr list-of-symbols)
-       (cdr args))))
-
-;; naive substitution of constant arguments
-(define (naive-subst* expr env)
-  ;; (displayln expr)
-  ;; (displayln (symbol? expr))
-  (cond [(null? expr) expr]
-        [(atom? expr) expr]
-        [(symbol? expr)
-         ;; (displayln "inside symbol case with: ")
-         ;; (displayln expr)
-         ;; (displayln (hash-contains? env expr))
-         ;; (displayln env)
-         (cond
-           [(hash-contains? env expr)
-            (define expr-value (lookup env expr))
-            ;; (displayln expr-value)
-            (if (constant? expr-value)
-                (begin
-                  (mark-changed)
-                  expr-value)
-                expr)]
-           [else expr])]
-        [(lambda-expression-application? expr)
-         ;; (displayln "Found an expression")
-         ;; (displayln expr)
-         (define list-of-bindings (lambda-expression-application? expr))
-         (define list-of-args (get-application-args expr))
-         (define new-env (bind-args env list-of-bindings list-of-args))
-         ;; (displayln "lambda evaluation")
-         ;; (displayln new-env)
-         ;; (displayln (caddr (car expr)))
-         ;; TODO check if you can remove the constant value
-         ;; in the argument position
-         (cons
-          (list
-           'lambda
-           (car (cdr (car expr)))
-           (naive-subst* (caddr (car expr)) new-env))
-          (cdr expr))]
-        [else
-         (map (lambda (x) (naive-subst* x env)) expr)]))
-
-(define (naive-subst expr)
-  ;; (init-changed)
-  (naive-subst* expr (hash)))
-
-
-;; (naive-subst '((lambda (x) x) 10))
-;; (changed?)
-
-
-(define (lambda-application? e)
-  (and (not (null? e))
-       (list? (car e))
-       (equal? (caar e) 'lambda)))
-
-(define (m-atom? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)
-      (symbol? expr)))
-
-;; (define (get-body-fn l)
-;;   (last l))
-
-(define get-body-exprs cddr)
-(define args cadr)
-
-
-(define (last l)
-  (if (null? (cdr l))
-      (car l)
-      (last (cdr l))))
-
-
-
-(define (lambda-removal expr)
-  (cond [(m-atom? expr) expr]
-        [(lambda-application? expr)
-         (define bodies (map lambda-removal (get-body-exprs (car expr))))
-         ;; TODO
-         ;; actually need to handle the case like
-         ;; (lambda (x) (list 1 2 3) 100)
-         ;; (list 1 2 3) should be removed
-         (if (all constant-not-symbols? bodies)
-             (begin
-               (mark-changed)
-               (last bodies))
-             (cons
-              (append
-               (list 'lambda (args (car expr)))
-               bodies)
-              (cdr expr)))]
-        [else (map lambda-removal expr)]))
-
-
-;; (lambda-removal '((lambda (x) 10) 2))
-;; (lambda-removal '((lambda () 10 20 30 40 50 60)))
-
-
-
-;; (-> '((lambda (x) (* x x)) (+ 1 2 3 (+ 1 2 3)))
-;;     (CF)
-;;     (naive-subst)
-;;     (CF)
-;;     (lambda-removal))
-
-
-;; (CF '((lambda (x) (* x x)) (+ 1 2 3 (+ 1 2 3))))
-
-;; (define *program* '((list 1 2 3)))
-
-(define (insert-define-var bound-vars expr)
-  (let ((v (define-expr? expr)))
-    (if v
-        (hashset-insert bound-vars v)
-        bound-vars)))
-
-
-;; (define *program*
-;;   '((define make-stack (lambda () (quote ())))
-;;     (define pop (lambda (stack) (if (null? stack) (quote (#false (quote ()))) (list (car stack) (cdr stack)))))
-;;     (define push cons)
-;;     (define my-stack (make-stack))
-;;     (begin (define pop-val (car (pop ((lambda (x) (push 4 x))
-;;                                       ((lambda (x) (push 3 x)) ((lambda (x) (push 2 x))
-;;                                                                 ((lambda (x) (push 1 x)) my-stack)))))))
-;;            (define new-stack (car (cdr (pop ((lambda (x) (push 4 x)) ((lambda (x) (push 3 x))
-;;                                                                           ((lambda (x) (push 2 x))
-;;                                                                            ((lambda (x) (push 1 x)) my-stack)))))))))
-;;     pop-val
-;;     new-stack))
-
-
-;; if begin statement, lift the defines up to be flattened at the top
-;; e.g.
-;; (begin (define x 10) (define y 20))
-;; should be converted into
-;; (define x 10)
-;; (define y 20)
-;; TODO/HACK
-(define (lift-defines-out-of-begin begin-expr)
-  (if (all define-expr? (cdr begin-expr))
-      (cdr begin-expr)
-      (begin-expr)))
-
-(define (begin-expr? expr)
-  (and (list? expr)
-       (equal? 'begin (car expr))))
-
-
-(define (flatten-to-define lst)
-  (cond ((null? lst) '())
-        ((define-expr? lst)
-         (list lst))
-        ((list? lst)
-         (append (flatten-to-define (car lst))
-                 (flatten-to-define (cdr lst))))
-        (else (list lst))))
-
-(define (lift-defines-out-of-begin begin-expr)
-  (define (helper expr)
-    (cond
-      [(not (list? expr)) expr]
-      [(null? expr) expr]
-      [(define-expr? expr)
-       expr]
-      [(begin-expr? expr)
-       (map lift-defines-out-of-begin (cdr expr))]
-      [else expr]))
-  (flatten-to-define (helper begin-expr)))
-
-
-(define (lift-defines-out-of-begin-2 expr)
-  (filter (lambda (x) (not (equal? x 'begin))) (flatten-to-define expr)))
-
-
-;; TODO
-(define (flatten-top-level-defines lst-of-exprs)
-  (define (loop input output)
-    (cond [(null? input) output]
-          [(begin-expr? (car input))
-           (loop (cdr input) (append output (lift-defines-out-of-begin (car input))))]
-          [else (loop (cdr input) (append output (list (car input))))]))
-  (loop lst-of-exprs '()))
-
-
-;; (flatten-top-level-defines *program*)
-
-;; ----- main thing kinda starts here ----
-
-(define *flattened-program* (flatten-top-level-defines *program*))
-
-(define initial-bound-vars
-  (reduce insert-define-var (hashset) *flattened-program*))
-
-(define (CF expr)
-  (car (constant-fold expr initial-bound-vars)))
-
-
-(define (optimize! expr)
-  ;; (displayln "looping")
-  (init-changed)
-  (define output
-    (-> expr
-        (CF)
-        (naive-subst)
-        (lambda-removal)))
-  (if (changed?)
-      (begin
-        (displayln "program changed!")
-        (optimize! output))
-      output))
-
-
-(displayln "-------------- BEFORE --------------")
-(displayln *flattened-program*)
-(define *result* (map optimize! *flattened-program*))
-(displayln "-------------- AFTER ---------------")
-(displayln *result*)
-*result*
-
-;; ----------------------------
diff --git a/steel-examples/option.scm b/steel-examples/option.scm
deleted file mode 100644
index bb0c62664..000000000
--- a/steel-examples/option.scm
+++ /dev/null
@@ -1,73 +0,0 @@
-(provide
-    ; (contract/out o-map (->/c (t : predicate?) (Option/c t) (->/c t Option?) Option?))
-    (contract/out map-option (->/c Option? Option?))
-    Some None
-    Some? None? Option?
-    Option/c)
-
-(struct Some (value))
-(struct None ())
-
-;; Contracts for option
-(define (Option/c pred)
-    (make/c (fn (x) 
-                (cond [(Some? x) (pred (Some-value x))]
-                      [(None? x) #t]
-                      [else #f])) 
-            'Option/c))
-
-(define (Option? value)
-    (or (Some? value) (None? value)))
-
-;; Map - explore dynamic dispatch with contracts?
-(define (map-option option func)
-    (cond [(Some? option) (Some (func (Some-value option)))]
-          [(None? option) option]))
-
-;; Get the inner value of the option - contract checking along the way
-;; Figure out how to turn off contracts on OptLevel3 regardless - 
-;; this would speed up performance a lot - also figure out how to map this to compile time options in Rust
-(define/contract (unwrap-some option)
-    (->/c Some? any/c)
-    (Some-value option))
-
-
-
-; (displayln (o-map (Some 10) (fn (x) (+ x 10))))
-
-; (displayln (o-map 10 (fn (x) 10)))
-
-
-
-
-
-; (module test 
-;     (provide
-;     ; (contract/out o-map (->/c (t : predicate?) (Option/c t) (->/c t Option?) Option?))
-;     Some None
-;     Some? None? Option?
-;     (contract/out o-map (->/c Option? (->/c any/c any/c) Option?))
-;     Option/c)
-
-;     (struct Some (value))
-;     (struct None ())
-
-;     ;; Contracts for option
-;     (define (Option/c pred)
-;         (make/c (fn (x) 
-;                     (cond [(Some? x) (pred (Some-value x))]
-;                         [(None? x) #t]
-;                         [else #f])) 
-;                 'Option/c))
-
-;     (define (Option? value)
-;         (or (Some? value) (None? value)))
-
-;     ;; Map - explore dynamic dispatch with contracts?
-;     (define (o-map option func)
-;         (cond [(Some? option) (Some (func (Some-value option)))]
-;             [(None? option) (None)]))
-
-; )
-
-
diff --git a/steel-examples/result.scm b/steel-examples/result.scm
deleted file mode 100644
index dda09a4f8..000000000
--- a/steel-examples/result.scm
+++ /dev/null
@@ -1,36 +0,0 @@
-(struct Ok (value))
-(struct Err (value))
-
-(define (Result? value)
-    (or (Ok? value) (Err? value)))
-
-;; Contracts for Result
-(define (Result/c ok-pred err-pred)
-    (make/c (fn (x) 
-                (cond [(Ok? x) (ok-pred (Ok-value x))]
-                      [(Err? x) (err-pred (Err-value x))]
-                      [else #f])) 
-            'Result/c))
-
-(define (map-option option func)
-    (cond [(Some? option) (Some (func (Some-value option)))]
-          [(None? option) (None)]))
-
-;; (->/c Ok? any/c)
-(define (unwrap-ok result)
-    (Ok-value result))
-
-;; (->/c Err? any/c)
-(define (unwrap-err result)
-    (Err-value result))
-
-;; (->/c Result? (->/c any/c any/c) Result?)
-(define (map-ok result func)
-    (cond [(Ok? result) (Ok (func (Ok-value result)))]
-          [(Err? result) result]))
-
-;; (->/c Result? (->/c any/c any/c Result?))
-(define (map-err result func)
-    (cond [(Ok? result) result]
-          [(Err? result) (Err (func (Err-value result)))]))
-
diff --git a/steel-examples/shift-reset.scm b/steel-examples/shift-reset.scm
deleted file mode 100644
index e3670b460..000000000
--- a/steel-examples/shift-reset.scm
+++ /dev/null
@@ -1,71 +0,0 @@
-(define-syntax reset 
-    (syntax-rules ()
-        ((reset ?e) (*reset (lambda () ?e)))))
-
-(define-syntax shift 
-    (syntax-rules ()
-        ((shift ?k ?e) (*shift (lambda (?k) ?e)))))
-
-(define (*meta-continuation* v)
-    (error "You forgot the top-level reset..."))
-
-(define (*abort thunk) 
-    (let ((v (thunk)))
-        (*meta-continuation* v)))
-
-(define (*reset thunk)
-    (let ((mc *meta-continuation*))
-        (call/cc (lambda (k)
-            (begin
-                (set! *meta-continuation*
-                        (lambda (v)
-                            (set! *meta-continuation* mc) 
-                            (k v)))
-                (*abort thunk))))))
-
-(define (*shift f)
-    (call/cc
-        (lambda (k)
-            (*abort (lambda ()
-                        (f (lambda (v)
-                                (reset (k v)))))))))
-
-(* 2 (reset (+ 1 (shift k (k 5)))))
-
-;; In theory, this seems to work for our shift and reset business
-;; Now, its not performant, but you seem to only pay the price only if you use the code
-; (let () 
-;     (reset
-;         (call-with-exception-handler (lambda (x) (displayln x) (shift k (k void))) 
-;             (lambda () (+ 10 20 (error "oops!")))))
-;     (displayln "hi"))
-
-
-(define-syntax with-handler
-    (syntax-rules ()
-        [(with-handler handler expr)
-         (reset (call-with-exception-handler (lambda (err) (handler err) (shift k (k void)))
-                    (lambda () expr)))]
-        [(with-handler handler expr ...)
-         (reset (call-with-exception-handler (lambda (err) (handler err) (shift k (k void)))
-                    (lambda () expr ...)))]))
-
-(with-handler
-    (lambda (err) 
-        (displayln err) 
-        (displayln "Going back to the main thread of execution..."))
-    (+ 10 20 30 "blagh"))
-
-; (displayln "I made it out")
-
-; ; (let ()
-; (with-handler
-;     (lambda (err) 
-;         (displayln err) 
-;         (error "Going back to the main thread of execution..."))
-;     (let ()
-;         (with-handler (lambda (err) (displayln "inner error!") (error "applesauce"))
-;             (+ 10 20 (error "uh oh")))))
-
-; (displayln "outside the loop")
-
diff --git a/steel-examples/sieve.scm b/steel-examples/sieve.scm
deleted file mode 100644
index eb676e906..000000000
--- a/steel-examples/sieve.scm
+++ /dev/null
@@ -1,68 +0,0 @@
-; #lang racket
-; Tail-recursive solution :
-(define (sieve n)
-  ;; Transform this function since it does not escape - should be possible to pass the argument in
-  (define (aux u v)
-    (displayln v)
-    (let ((p (car v)))
-      (if (> (* p p) n)
-        (rev-append u v)
-        (aux (cons p u)
-          (wheel '() (cdr v) (* p p) p)))))
-  (aux '(2)
-    (range-s '() (if (odd? n) n (- n 1)))))
-
-; (define sieve (lambda (n) 
-;   ((lambda (aux) 
-;     ((lambda (#####aux0) 
-;       (begin (set! aux #####aux0) 
-;               (aux (quote (2)) (range-s (quote ()) (if (odd? n) n (- n 1)))))) 
-;       (lambda (u v) 
-;         ((lambda (p) 
-;           (if (> (* p p) n) (rev-append u v) (aux (cons p u) (wheel (quote ()) (cdr v) (* p p) p)))) (car v))))) 123)))
-
-
-;; TODO: Looks like the lambda lifter doesn't work on its own
-;; passing in aux explicitly causes issues because aux 
-; (define sieve 
-;   (lambda (n) 
-;     ((lambda (aux) 
-;       ((lambda (#####aux0) 
-;         (begin (set! aux #####aux0) 
-;                (aux (quote (2)) 
-;                     (range-s (quote ()) (if (odd? n) n (- n 1))))))
-      
-;         (lambda (u v) (##-##lambda-lifter-sieve1 (car v) n aux u v))))
-;     123)))
-
-; (define (sieve n)
-;   ;; Transform this function since it does not escape - should be possible to pass the argument in
-;   (define (aux u v n)
-;     ; (displayln v)
-;     (let ((p (car v)))
-;       (if (> (* p p) n)
-;         (rev-append u v)
-;         (aux (cons p u)
-;           (wheel '() (cdr v) (* p p) p)
-;           n
-;           ))))
-;   (aux '(2)
-;     (range-s '() (if (odd? n) n (- n 1)))
-;     n
-;     ))
-
-
-(define (wheel u v a p)
-  ; (displayln v)
-    (cond ((null? v) (reverse u))
-          ((= (car v) a) (wheel u (cdr v) (+ a p) p))
-          ((> (car v) a) (wheel u v (+ a p) p))
-          (else (wheel (cons (car v) u) (cdr v) a p))))
-
-(define (rev-append u v)
-    (if (null? u) v (rev-append (cdr u) (cons (car u) v))))
-
-(define (range-s v k)
-    (if (< k 3) v (range-s (cons k v) (- k 2))))
-
-(sieve 10)
\ No newline at end of file
diff --git a/steel-examples/simple-callcc.scm b/steel-examples/simple-callcc.scm
deleted file mode 100644
index 5c048a372..000000000
--- a/steel-examples/simple-callcc.scm
+++ /dev/null
@@ -1,8 +0,0 @@
-(define x 0) ; dummy value - will be used to store continuation later
-
-(+ 2 (call/cc 
-          (lambda (cc)
-           (set! x cc)  ; set x to the continuation cc; namely, (+ 2 _)
-           3)))         ; returns 5
-
-(x 4) ;; 6 
\ No newline at end of file
diff --git a/steel-examples/sort-jit.scm b/steel-examples/sort-jit.scm
deleted file mode 100644
index bd37f3090..000000000
--- a/steel-examples/sort-jit.scm
+++ /dev/null
@@ -1,41 +0,0 @@
-(provide merge-sort)
-
-(define (empty) '())
-
-;;; Define a merge sort for sake of simplicity
-(define (merge-lists l1 l2)
-  (cond [(null? l1) l2]
-        [(null? l2) l1]
-        [(< (car l1) (car l2))
-         (cons (car l1) (merge-lists (cdr l1) l2))]
-        [else
-         (cons (car l2) (merge-lists (cdr l2) l1))]))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in even positions
-
-(define (even-numbers l)
-  (cond [(null? l) (empty)]
-        [(null? (cdr l)) (empty)]
-        [else
-         (cons (car (cdr l)) (even-numbers (cdr (cdr l))))]))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in odd positions
-
-(define (odd-numbers l)
-  (cond [(null? l) (empty)]
-        [(null? (cdr l)) (cons (car l) (empty))]
-        [else
-         (cons (car l) (odd-numbers (cdr (cdr l))))]))
-
-;;; ---------------------------------------------------------------------
-;;; Use the procedures above to create a simple and efficient merge-sort
-
-(define (merge-sort l)
-  (cond [(null? l) l]
-        [(null? (cdr l)) l]
-        [else
-         (merge-lists
-          (merge-sort (odd-numbers l))
-          (merge-sort (even-numbers l)))]))
\ No newline at end of file
diff --git a/steel-examples/sort.scm b/steel-examples/sort.scm
deleted file mode 100644
index 764cfac01..000000000
--- a/steel-examples/sort.scm
+++ /dev/null
@@ -1,39 +0,0 @@
-(provide merge-sort)
-
-;;; Define a merge sort for sake of simplicity
-(define (merge-lists l1 l2)
-  (cond [(null? l1) l2]
-        [(null? l2) l1]
-        [(< (car l1) (car l2))
-         (cons (car l1) (merge-lists (cdr l1) l2))]
-        [else
-         (cons (car l2) (merge-lists (cdr l2) l1))]))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in even positions
-
-(define (even-numbers l)
-  (cond [(null? l) '()]
-        [(null? (cdr l)) '()]
-        [else
-         (cons (car (cdr l)) (even-numbers (cdr (cdr l))))]))
-
-;;; -------------------------------------------------------------------
-;;; Given list l, output those tokens of l which are in odd positions
-
-(define (odd-numbers l)
-  (cond [(null? l) '()]
-        [(null? (cdr l)) (list (car l))]
-        [else
-         (cons (car l) (odd-numbers (cdr (cdr l))))]))
-
-;;; ---------------------------------------------------------------------
-;;; Use the procedures above to create a simple and efficient merge-sort
-
-(define (merge-sort l)
-  (cond [(null? l) l]
-        [(null? (cdr l)) l]
-        [else
-         (merge-lists
-          (merge-sort (odd-numbers l))
-          (merge-sort (even-numbers l)))]))
\ No newline at end of file
diff --git a/steel-examples/sqlite.scm b/steel-examples/sqlite.scm
deleted file mode 100644
index 00865fa1d..000000000
--- a/steel-examples/sqlite.scm
+++ /dev/null
@@ -1,24 +0,0 @@
-(require-builtin steel/sqlite)
-(require "steel/result")
-
-(require "steel/time/time.scm"
-        (for-syntax "steel/time/time.scm"))
-
-(define connection (unwrap-ok (connection/open-in-memory)))
-
-(connection/execute! connection
-    "CREATE TABLE person (
-        id   INTEGER PRIMARY KEY,
-        name TEXT NOT NULL,
-        data TEXT
-    )" '())
-
-(connection/prepare-and-execute! connection
-    "INSERT INTO person (name, data) VALUES (?1, ?2)"
-    (list (list "Steven" "likes to eat")
-          (list "Alex" "likes biking")
-          (list "Matt" "likes running")))
-
-(dbg! (time! (connection/prepare-and-query! connection
-    "SELECT id, name, data FROM person"
-    '())))
diff --git a/steel-examples/stack.scm b/steel-examples/stack.scm
deleted file mode 100644
index 47cc32a19..000000000
--- a/steel-examples/stack.scm
+++ /dev/null
@@ -1,59 +0,0 @@
-;; Implementation of a stack in `steel`
-;; Returning multiple values requires returning as a list
-;; Functional data structure, is definitely verbose but is super helpful
-;; Maybe look into using monadic forms in order to not have the verbosity
-;; associated with a functional data structure
-
-
-;; ---------------------------------------------------------------------
-;; Implementation of a stack purely using a list
-;; ---------------------------------------------------------------------
-
-
-;; destruct works like so:
-;; (destruct (a b c) value)
-;;  ...
-;; (define a (car value))
-;; (define b (car (cdr value)))
-;; (define c (car (cdr (cdr value))))
-(define-syntax destruct
-  (syntax-rules ()
-    [(destruct (var) ret-value)
-     (define (datum->syntax var) (car ret-value))]
-    [(destruct (var1 var2 ...) ret-value)
-     (begin (define (datum->syntax var1) (car ret-value))
-            (destruct (var2 ...) (cdr ret-value)))]))
-
-
-(define (any? v) #t)
-(define stack? list?)
-(define (pair? s)
-  (and (list? s) (= (length s) 2)))
-
-
-(define (make-stack) '())
-
-(define/contract (pop stack)
-  (->/c stack? pair?)
-  (if (null? stack)
-      '(#f '())
-      (list (car stack) (cdr stack))))
-
-;; value -> stack -> stack
-(define push cons)
-
-;; instantiate an empty stack
-(define my-stack (make-stack))
-
-;; Bind the last few values from the stack
-;; Push the values 1, 2, 3, 4, then pop and return the value and the stack
-(destruct (pop-val new-stack)
-          (->> my-stack
-               (push 1)
-               (push 2)
-               (push 3)
-               (push 4)
-               (pop)))
-
-pop-val ;; => 4
-new-stack ;; => '(3 2 1)
diff --git a/steel-examples/stack_state.scm b/steel-examples/stack_state.scm
deleted file mode 100644
index 1f1ce0656..000000000
--- a/steel-examples/stack_state.scm
+++ /dev/null
@@ -1,90 +0,0 @@
-(define (push element)
-  (lambda (stack)
-    (list '() (cons element stack))))
-
-(define (pop)
-  (lambda (stack)
-    (let ((element (car stack))
-          (new-stack (cdr stack)))
-      (list element new-stack))))
-
-(define stack-of cadr)
-(define value-of car)
-
-(define (>>= stack-action continuation)
-  (lambda (stack)
-    (let ((result (stack-action stack)))
-      ((continuation (value-of result)) (stack-of result)))))
-
-(define (return value)
-  (lambda (stack)
-    (list value stack)))
-
-(define (run-stack computation stack)
-  (computation stack))
-
-(define (eval-stack computation stack)
-  (value-of (computation stack)))
-
-(define (exec-stack computation stack)
-  (stack-of (computation stack)))
-
-(define computation-1 (>>= (push 4) (lambda (_)
-                      (>>= (push 5) (lambda (_)
-                      (>>= (pop)    (lambda (a)
-                      (>>= (pop)    (lambda (b)
-                      (return (list a b)))))))))))
-
-(define computation-2 (>>= (push 2) (lambda (_)
-                      (>>= (push 3) (lambda (_)
-                      (>>= (pop)    (lambda (a)
-                      (>>= (pop)    (lambda (b)
-                      (return (list a b)))))))))))
-
-(define (main)
-  (let ((initial-stack '())
-        (composed (>>= computation-1 
-                      (lambda (a)
-                        (>>= computation-2 
-                             (lambda (b)
-                                (return (list a b))))))))
-    (begin
-      ; (display "Result: ")
-      (define result (eval-stack composed initial-stack))
-      ; (display result)
-      ; (newline)
-      result)))
-
-(main)
-
-(define (test x)
-  (if (= x 10) x
-      (begin
-        (main)
-        (test (+ x 1)))))
-
-(test 0)
-
-(define (foo x)
-  (main)
-  (bar x))
-
-(define (bar x)
-  (main)
-  (foo x))
-
-(define (foo2)
-  (bar2))
-
-(define (bar2)
-  (foo2))
-
-(define (test-2)
-  (define (foo) (main) (bar))
-  (define (bar) (main) (foo))
-  (foo))
-
-(define (test-3)
-  (define (foo) (bar))
-  (define (bar) (foo))
-  (foo))
\ No newline at end of file
diff --git a/steel-examples/stack_struct.scm b/steel-examples/stack_struct.scm
deleted file mode 100644
index d96890812..000000000
--- a/steel-examples/stack_struct.scm
+++ /dev/null
@@ -1,116 +0,0 @@
-;; Implementation of a stack in `steel`
-;; Returning multiple values requires returning as a list
-;; Functional data structure, is definitely verbose but is super helpful
-;; Maybe look into using monadic forms in order to not have the verbosity
-;; associated with a functional data structure
-
-;; ---------------------------------------------------------------------
-;; Make the same stack but instead wrap the list with a struct data type
-;;
-;; A little bit more boilerplate, but adds some runtime checks for us
-;; ---------------------------------------------------------------------
-
-;; destruct works like so:
-;; (destruct (a b c) value)
-;;  ...
-;; (define a (car value)
-;; (define b (car (cdr value)))
-;; (define c (car (cdr (cdr value))))
-(define-syntax destruct
-  (syntax-rules ()
-    [(destruct (var) ret-value)
-     (define (datum->syntax var) (car ret-value))]
-    [(destruct (var1 var2 ...) ret-value)
-     (begin (define (datum->syntax var1) (car ret-value))
-            (destruct (var2 ...) (cdr ret-value)))]))
-
-;; destruct a list
-;; maybe write a generic match library?
-(define-syntax let-destruct
-  (syntax-rules ()
-    ;; [(let-destruct ((var) ret-value) body ...)
-    ;;  (let ((var (car ret-value)))
-    ;;    (begin body ...))]
-    [(let-destruct ((var) ret-value) body ...)
-     (let ((var (if (null? (cdr ret-value))
-                    (car ret-value)
-                    ret-value)))
-       (begin body ...))]
-    [(let-destruct ((var1 var2 ...) ret-value) body ...)
-     (let ((var1 (car ret-value)))
-       (let-destruct ((var2 ...) (cdr ret-value))
-                     body ...))]))
-
-(define-syntax def-method
-  (syntax-rules ()
-    [(def-method struct-name (define/method (a this b ...) body ...))
-     (define ((datum->syntax struct-name . a) this b ...)
-       (unless ((datum->syntax struct-name ?) this)
-         (error! (datum->syntax struct-name . a) "method takes a value of" struct-name "given" this))
-       body ...)]))
-
-;; impl block asserts that each function contains the struct type given as the first argument
-;; This is why later down we use the thread first vs. the thread last given above
-;;
-;; However, take note that a recursive call will not work properly in this, best to be used as an interface
-;; since it does not transform the name of the recursive call
-;; TODO turn this into a test case
-(define-syntax impl
-  (syntax-rules ()
-    [(impl struct-name (define/method (a this b ...) body ...) c ...)
-     (begin (def-method struct-name (define/method (a this b ...) body ...))
-            (impl struct-name c ...))]
-    [(impl struct-name (define/method (a this b ...) body ...))
-     (def-method struct-name (define/method (a this b ...) body ...))]))
-
-
-;; There is an issue with unrolling definitions from begins
-;; collecting the defines will not work correctly
-;; make sure to account for those in the counting
-
-(struct Stack (lst))
-(impl Stack
-      ;; Change this to be something like (define/method)
-      ;; as to disambiguate it from the base define
-      (define/method (pop stack)
-        (define contents (Stack-lst stack))
-        (if (null? contents)
-            '(#f '())
-            (list (car contents) (cdr contents))))
-
-      (define/method (push stack value)
-        (define contents (Stack-lst stack))
-        (Stack (cons value contents))))
-
-(define test-stack (Stack '()))
-
-(destruct (pop-val-test new-stack-test)
-          (-> test-stack
-               (Stack.push 1)
-               (Stack.push 2)
-               (Stack.push 3)
-               (Stack.push 4)
-               (Stack.pop)))
-
-pop-val-test ;; => 4
-new-stack-test ;; => '(3 2 1)
-
-
-(let-destruct ((pop-val new-stack)
-               (-> test-stack
-                   (Stack.push 1)
-                   (Stack.push 2)
-                   (Stack.push 3)
-                   (Stack.push 4)
-                   (Stack.pop)))
-
-              (displayln "Hello world")
-              (displayln pop-val)
-              (displayln new-stack))
-
-(let-destruct
- ((a b c)
-  (list 1 2 3 4 5 6 7 8 9 10))
- (displayln a)
- (displayln b)
- (displayln c))
diff --git a/steel-examples/stream.scm b/steel-examples/stream.scm
deleted file mode 100644
index 3f39138c2..000000000
--- a/steel-examples/stream.scm
+++ /dev/null
@@ -1,66 +0,0 @@
-
-
-
-(define (force promise) (promise))
-
-;; syntax
-(define-syntax delay
-  (syntax-rules ()
-    ((delay expr)
-     (lambda ()
-        expr))))
-
-(define-syntax cons-stream
-  (syntax-rules ()
-    ((cons-stream x y)
-     (cons x (delay y)))))
-
-(define head car)
-(define (tail stream) (force (car (cdr stream))))
-(define empty-stream? null?)
-(define the-empty-stream '())
-
-(define (integers n)
-  (cons-stream n (integers (+ 1 n))))
-
-(define (stream-section n stream)
-  (cond ((= n 0) '())
-        (else
-          (cons
-            (head stream)
-            (stream-section
-             (- n 1)
-             (tail stream))))))
-
-(define (add-streams s1 s2)
- (let ((h1 (head s1))
-       (h2 (head s2)))
-   (cons-stream
-     (+ h1 h2)
-     (add-streams (tail s1) (tail s2)))))
-
-(define fibs
-  (cons-stream 0
-    (cons-stream 1
-      (add-streams (tail fibs) fibs))))
-
-(define (integers n)
-  (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(define (in-range-stream n m)
-  (if (= n m)
-      empty-stream
-      (stream-cons n (lambda () (in-range-stream (add1 n) m)))))
-
-(define (append-streams s1 s2)
-  (cond
-    [(empty-stream? s1) s2]
-    [(empty-stream? s2) s1]
-    [else
-     (stream-cons (stream-car s1)
-                  (lambda () (append-streams (stream-cdr s1) s2)))]))
-
-
-; (stream-section 15 fibs)
-
-;; TODO add macro to assist in the wrapping of stream-cons similar to how cons-stream functions
diff --git a/steel-examples/streams.scm b/steel-examples/streams.scm
deleted file mode 100644
index 108759a52..000000000
--- a/steel-examples/streams.scm
+++ /dev/null
@@ -1,80 +0,0 @@
-(define (stream-cdr stream)
-  ((#%stream-cdr stream)))
-
-(define (integers n)
-  (stream-cons n (lambda () (integers (+ 1 n)))))
-
-(define (in-range-stream n m)
-  (if (= n m) empty-stream (stream-cons n (lambda () (in-range-stream (add1 n) m)))))
-
-(define (append-streams s1 s2)
-  (cond
-    [(stream-empty? s1) s2]
-    [(stream-empty? s2) s1]
-    [else (stream-cons (stream-car s1) (lambda () (append-streams (stream-cdr s1) s2)))]))
-
-(define (add-streams s1 s2)
-  (let ([h1 (stream-car s1)] [h2 (stream-car s2)])
-    (stream-cons (+ h1 h2) (lambda () (add-streams (stream-cdr s1) (stream-cdr s2))))))
-
-(define (merge-streams s1 s2)
-  (cond
-    [(stream-empty? s1) s2] ; nothing to merge from s1
-    [(stream-empty? s2) s1] ; nothing to merge from s2
-    [else
-     (let ([h1 (stream-car s1)] [h2 (stream-car s2)])
-       (stream-cons
-        h1
-        (lambda () (stream-cons h2 (lambda () (merge-streams (stream-cdr s1) (stream-cdr s2)))))))]))
-
-(define (map-stream func s)
-  (cond
-    [(stream-empty? s) s]
-    [else (stream-cons (func (stream-car s)) (lambda () (map-stream func (stream-cdr s))))]))
-
-(define (list->stream lst)
-  (if (null? lst) empty-stream (stream-cons (car lst) (lambda () (list->stream (cdr lst))))))
-
-(define (stream->list s)
-  (define (*stream->list s lst)
-    (if (stream-empty? s) lst (*stream->list (stream-cdr s) (cons (stream-car s) lst))))
-  (*stream->list s '()))
-
-(define (stream-section n stream)
-  (cond
-    [(= n 0) '()]
-    [else (cons (stream-car stream) (stream-section (- n 1) (stream-cdr stream)))]))
-
-;; execute / transducer work with transducers
-;; these are like source agnostic
-
-(transduce (add-streams (integers 0) (integers 0)) (taking 15) (into-list))
-
-(transduce (merge-streams (integers 0) (integers 0)) (taking 15) (into-list))
-
-(transduce (merge-streams (merge-streams (integers 0) (integers 0))
-                          (add-streams (integers 0) (integers 0)))
-           (taking 15)
-           (into-list))
-
-(transduce (map-stream (lambda (x) 10) (integers 0)) (taking 15) (into-list))
-
-(stream->list (in-range-stream 0 10))
-
-;; make a stream out of a port
-(define my-port (open-input-file "scheme_examples/dfs.rkt"))
-
-(define (port-stream)
-  (let ([head (read-line-from-port my-port)])
-    (if (equal? 'eof head) empty-stream (stream-cons head (lambda () (port-stream))))))
-
-;; Make a stream out of a port
-;; Access the port using the given func
-;; Stop reading w/ the given end-sym
-(define (port->stream p func end-sym)
-  (let ([head (func p)])
-    (if (equal? end-sym head)
-        empty-stream
-        (stream-cons head (lambda () (port->stream p func end-sym))))))
-
-(transduce (port-stream my-port read-line-from-port 'eof) (taking 15) (into-list))
diff --git a/steel-examples/test-dfs.scm b/steel-examples/test-dfs.scm
deleted file mode 100644
index a62cb394d..000000000
--- a/steel-examples/test-dfs.scm
+++ /dev/null
@@ -1,102 +0,0 @@
-;; implementation of a dfs in steel
-
-;; Given a node and a graph
-;; node -> 'a
-;; graph -> '((a b c) (b d) (e f))
-;;
-;; returns the neighbors
-;; ex.
-;; (get-neighbors 'a graph) => '(b c)
-;;
-(define (get-neighbors node graph)
-  (define found-neighbors (assoc node graph))
-  (if found-neighbors
-      (cdr found-neighbors)
-      '()))
-
-(define (longest  lst)
-  (foldr (λ (a b) (if (> (length a) (length b)) a b))
-         '()
-         lst))
-
-; (define (reverse ls)
-;   (define (my-reverse-2 ls acc)
-;     (if (null? ls)
-;       acc
-;       (my-reverse-2 (cdr ls) (cons (car ls) acc))))
-;   (my-reverse-2 ls '()))
-
-(define (first-step curr end graph)
-  (let ((neighbors (get-neighbors curr graph)))
-    (longest (map (lambda (x) (dfs x end '() '() graph)) neighbors))))
-
-
-(define (member? x los)
-  (cond
-    ((null? los) #f)
-    ((equal? x (car los)) #t)
-    (else (member? x (cdr los)))))
-
-;; iteratively tries each neighbor
-;; quits when the length is worse
-(define (try-all-neighbors neighbors best-path end new-path graph)
-  (if (not (empty? neighbors))
-      (let* ((next-neighbor (car neighbors))
-             (found-path (dfs next-neighbor end new-path best-path graph)))
-        (if (> (length found-path) (length best-path))
-            (try-all-neighbors (cdr neighbors) found-path end new-path graph)
-            (try-all-neighbors (cdr neighbors) best-path end new-path graph)))
-      best-path))
-
-(define (dfs curr end path best-path graph)
-;   (define neighbors (get-neighbors curr graph))
-;   (define new-path (cons curr path))
-  (let ((neighbors (get-neighbors curr graph))
-        (new-path (cons curr path)))
-            (cond ((equal? curr end)
-                (cons curr path))
-                ((member? curr path)
-                '())
-                (neighbors
-                (try-all-neighbors neighbors best-path end (cons curr path) graph))
-                (else '()))))
-
-
-(define (longest-path start end graph)
-  (define found-path (reverse (first-step start end graph)))
-  (cond ((empty? found-path)
-         (if (equal? start end)
-             (list start)
-             '()))
-        ((and (equal? (car found-path) start) (not (equal? start end)))
-         found-path)
-        (else (cons start found-path))))
-
-
-(longest-path 'a 'c '((a b) (b c))) ;; '(a b c)
-(longest-path 'a 'c '((a b) (b a c))) ;; '(a b c)
-(longest-path 'a 'c '((a d e f g b) (b a c))) ;; '(a b c)
-(longest-path 'a 'a '((a b) (b a c))) ;; '(a b a)
-(longest-path 'a 'c '((a b) (b a) (c))) ;; '()
-(longest-path 'a 'f '((a b c) (b f) (c d) (d e) (e f))) ;; '(a c d e f)
-(longest-path 'a 'f '((a b c a) (b c d) (c e a) (d e f) (e d f))) ;; '(a b c e d f)
-(longest-path 'a 'a '((a b c a) (b c d) (c e a) (d e f) (e d f))) ;; '(a b c a)
-(longest-path 'a 'a '((a b) (b c))) ;; '(a)
-(longest-path 'a 'a '((a a b) (b c))) ;; '(a a)
-(longest-path 'a 'a '((a b a) (b c))) ;; '(a a)
-(longest-path 'a 'b '((a b) (b c) (c b))) ;; '(a b)
-(longest-path 'a 'b '((a b c) (b c) (c b))) ;; '(a c b)
-
-(equal? (longest-path 'a 'c '((a b) (b c))) '(a b c))
-(equal? (longest-path 'a 'c '((a b) (b a c))) '(a b c))
-(equal? (longest-path 'a 'c '((a d e f g b) (b a c))) '(a b c))
-(equal? (longest-path 'a 'a '((a b) (b a c))) '(a b a))
-(equal? (longest-path 'a 'c '((a b) (b a) (c))) '())
-(equal? (longest-path 'a 'f '((a b c) (b f) (c d) (d e) (e f))) '(a c d e f))
-(equal? (longest-path 'a 'f '((a b c a) (b c d) (c e a) (d e f) (e d f))) '(a b c e d f))
-(equal? (longest-path 'a 'a '((a b c a) (b c d) (c e a) (d e f) (e d f))) '(a b c a))
-(equal? (longest-path 'a 'a '((a b) (b c))) '(a))
-(equal? (longest-path 'a 'a '((a a b) (b c))) '(a a))
-(equal? (longest-path 'a 'a '((a b a) (b c))) '(a a))
-(equal? (longest-path 'a 'b '((a b) (b c) (c b))) '(a b))
-(equal? (longest-path 'a 'b '((a b c) (b c) (c b))) '(a c b))
diff --git a/steel-examples/toy.scm b/steel-examples/toy.scm
deleted file mode 100644
index a403ec820..000000000
--- a/steel-examples/toy.scm
+++ /dev/null
@@ -1,549 +0,0 @@
-;; Sets of useful ideas for things
-;; #lang racket
-
-;; ------------------- match functions ----------------------
-
-;; Tells me if this is a free variable (for now)
-(define (var? x)
-  (and (symbol? x)
-       (starts-with? (symbol->string x) "?")))
-
-(define (ignore? x)
-  (equal? x '_))
-
-(define (many? x)
-  (and (symbol? x)
-       (let ((str (symbol->string x)))
-         (and (starts-with? str "?")
-              (ends-with? str "...")))))
-
-
-(define (equal-or-insert hm key value)
-  (define existing-value (hash-try-get hm key))
-  (if existing-value
-      (if (equal? existing-value value)
-          hm
-          #f
-          ;; (error! "Duplicate bindings found for variable: " key)
-          )
-      (hash-insert hm key value)))
-
-(define (collect-until-last-p input collected)
-  (if (null? (cdr input))
-      (list (car input) collected)
-      (collect-until-last-p (cdr input) (cons (car input) collected))))
-
-
-(define (collect-until-last input)
-  (collect-until-last-p input '()))
-
-
-;; Bindings or #false if there is not a match
-(define (match-p pattern input bindings)
-  (cond
-    ;; If its a struct, immediately do the conversion
-    ;; TODO bug arity check is not happening here
-    [(and (list? pattern) (struct? input)) (match-p pattern (struct->list input) bindings)]
-    [(and (list? pattern)
-          (not (null? pattern))
-          (many? (car pattern)))
-     (if (null? (cdr pattern))
-         (equal-or-insert bindings (car pattern) input)
-         (let ((collected (collect-until-last input)))
-           (define remainder (car collected))
-           (define collected-list (reverse (car (cdr collected))))
-           (if (null? (cdr (cdr pattern)))
-               (let ((remainder-bound
-                      (equal-or-insert bindings
-                                       (car (cdr pattern)) remainder)))
-                 (equal-or-insert remainder-bound (car pattern) collected-list))
-               #f)))]
-    [(var? pattern) (equal-or-insert bindings pattern input)]
-    [(ignore? pattern) bindings]
-    [(atom? pattern) (if (equal? pattern input) bindings #f)]
-    [(null? pattern) (if (null? input) bindings #f)]
-    [(null? input) #f]
-    [(and (list? pattern) (not (list? input))) #f]
-    [else
-     (define remaining (match-p (cdr pattern) (cdr input) bindings))
-     (if remaining
-         (match-p (car pattern) (car input) remaining)
-         #f)]))
-
-(define (match pattern input)
-  (match-p pattern input (hash)))
-
-
-;; ---------------- tests --------------------
-
-;; Pretty print for testing purposes
-(define (test name input expected)
-  (if (equal? input expected)
-      (begin
-        (display "> ")
-        (display name)
-        (display " ... ")
-        (display-color "OK" 'green)
-        (newline))
-      (begin
-        (display "> ")
-        (display name)
-        (display " ... ")
-        (display-color "FAILED" 'red)
-        (newline)
-        (display "    Expected: ")
-        (display expected)
-        (display ", Found ")
-        (displayln input))))
-
-(displayln "--------------------- match tests ----------------------")
-
-;; Matches a pattern explicitly
-(test "Simple match" 
-      (match '?x '(1 2 3 4))
-      (hash '?x '(1 2 3 4)))
-
-;; If the pattern match fails, return false
-(test "Pattern match fails returns false"
-      (match '(10 2 ?z 5) '(1 2 3 4))
-      #f)
-
-;; If the pattern fails because we didn't match exactly, bail
-(test "Pattern fails because constants don't match exactly"
-      (match '(1 2 3 4 5) '(1 2 3 4))
-      #f)
-
-;; Should fail
-(test "Lengths unequal fails"
-      (match '(?x ?y ?z 4 5) '(1 2 3 4))
-      #f)
-
-;; Should succeed with x y z bound to 1 2 3
-(test "Successful pattern match on simple list"
-      (match '(?x ?y ?z 4 5) '(1 2 3 4 5))
-      (hash '?x 1 '?y 2 '?z 3))
-
-;; Should succed with x y z bound to 1 2 3
-(test "Nested patterns match"
-      (match '(?x (?y ?z)) '(1 '(2 3)))
-      (hash '?x 1 '?y 2 '?z 3))
-
-;; Also should work
-(test "Deep nested pattern"
-      (match '(?x (?y (?z (?applesauce ?bananas))))
-        '(1 (2 (3 (4 5)))))
-      (hash '?x 1 '?y 2 '?z 3 '?applesauce 4 '?bananas 5))
-
-
-;; Also should work
-(test "Deep nested pattern with list matching"
-      (match '(?x (?y (?z (?applesauce ?bananas))))
-        '(1 (2 (3 (4 (1 2 3 4 5))))))
-      (hash '?x 1 '?y 2 '?z 3 '?applesauce 4 '?bananas '(1 2 3 4 5)))
-
-
-;; Match the bindings
-(test "Pattern variables once bound retain their value"
-      (match '(?x ?y ?x) '(1 2 1))
-      (hash '?x 1 '?y 2))
-
-;; Should fail since x doesn't match what was there at first
-(test "Matching fails when variable has two different values"
-      (match '(?x ?y ?x) '(1 2 3))
-      #f)
-
-;; Shouldn't fail, should ignore whatever is in the second position
-(test "Wildcard ignores the matching at that position"
-      (match '(?x _ 3) '(1 (1 2 3) 3))
-      (hash '?x 1))
-
-;; a => 1
-;; x => '(2 3 4 5)
-(test "Basic ellipses matching works"
-      (match '(?a ?x...) '(1 2 3 4 5))
-      (hash '?a 1 '?x... '(2 3 4 5)))
-
-
-(test "Ellipses matches to empty list"
-      (match '(?first ?rest...) '(1))
-      (hash '?first 1 '?rest... '()))
-
-
-(test "Ellipses matches until next value"
-      (match '(?first ?rest... ?last) '(1 2 3 4 5))
-      (hash '?first 1 '?rest... '(2 3 4) '?last 5))
-
-; TODO this should error out as illegal pattern
-(test "Ellipses does not match multiple characters at the end"
-      (match '(?first ?rest... ?second-last ?last) '(1 2 3 4 5 6))
-      #f
-      ; (hash '?first 1 '?rest... '(2 3 4) '?last 5 '?last 6)
-      )
-
-(test "Ellipses with nested pattern"
-      (match '(?x (?y ?z (?foo ?bar...))) '(1 (2 3 (4 5 6 7 8 9 10))))
-      (hash '?x 1 '?y 2 '?z 3 '?foo 4 '?bar... '(5 6 7 8 9 10)))
-
-
-(test "Empty pattern matches empty list"
-      (match '() '())
-      (hash))
-
-(test "Empty pattern fails on non empty list"
-      (match '() '(1 2 3))
-      #f)
-
-(test "Single variable with empty list"
-      (match '?x '())
-      (hash '?x '()))
-
-(test "Constant matches constant"
-      (match (list 1 2 3) (list 1 2 3))
-      (hash))
-
-(test "List pattern does not match constant"
-      (match (list 1 2 3 4 5) 10)
-      #f)
-
-(test "Constant pattern does not match list"
-      (match 10 (list 1 2 3 4 5))
-      #f)
-
-(test "Wildcard passes"
-      (match '_ (list 1 2 3 4 5))
-      (hash))
-
-
-;; ----------------- match! syntax --------------------
-
-
-(define-syntax syntax->pattern
-  (syntax-rules ()
-    [(syntax->pattern (var1))
-     '(var1)]
-    [(syntax->pattern (var1 var2 ...))
-       (cons 'var1 (syntax->pattern (var2 ...)))]
-    [(syntax->pattern var)
-     'var]))
-
-
-(define-syntax syntax-pattern->lets
-  (syntax-rules ()
-    [(syntax-pattern->lets ((var1)) bindings body)
-     (syntax-pattern->lets (var1) bindings body)]
-    [(syntax-pattern->lets ((var1 ...) rest ...) bindings body)
-     (syntax-pattern->lets (var1 ...) bindings
-                           (syntax-pattern->lets (rest ...) bindings body))]
-    [(syntax-pattern->lets (var1) bindings body)
-     ;; TODO
-     (syntax-const-if var1 body
-                      (let ((var1 (hash-try-get bindings 'var1)))
-                        body))]
-    [(syntax-pattern->lets (var1 var2 ...) bindings body)
-     (syntax-const-if var1
-                      (syntax-pattern->lets (var2 ...) bindings body)
-                      (let ((var1 (hash-try-get bindings 'var1)))
-                        (syntax-pattern->lets (var2 ...) bindings body)))]
-    [(syntax-pattern->lets () bindings body)
-     body]
-    [(syntax-pattern->lets var bindings body)
-     (syntax-const-if var body
-                      (let ((var (hash-try-get bindings 'var)))
-                        body))]))
-
-
-
-;; TODO add case for the remaining - when there is no else case given
-;; and it should just error out
-(define-syntax match-dispatch
-  (syntax-rules (else)
-    ;; Explicitly giving an else case
-    [(match-dispatch expr [else e1 ...])
-     (begin e1 ...)]
-    ;; Generic recursive case
-    [(match-dispatch expr [p1 e2 ...] c1 ...)
-     (let ((match? (match (syntax->pattern p1) expr)))
-       (if match?
-           (syntax-pattern->lets p1 match? (begin e2 ...))
-           (match-dispatch expr c1 ...)))]
-    ;; When there isn't an else case given, the last case
-    ;; Should include a failure mode
-    [(match-dispatch expr (p1 e2 ...))
-     (let ((match? (match (syntax->pattern p1) expr)))
-       (if match?
-           (syntax-pattern->lets p1 match? (begin e2 ...))
-           (error! "Unable to match expression: " expr " to any of the given patterns")))]))
-
-
-(define-syntax match!
-  (syntax-rules ()
-    [(match expr pat)
-     (let ((evald-expr expr))
-       (match-dispatch evald-expr pat))]
-    [(match expr pats ...)
-     (let ((evald-expr expr))
-       (match-dispatch evald-expr pats ...))]))
-
-
-;; --------------------- match! tests ------------------------
-
-(displayln "--------------------- match! tests ----------------------")
-
-(test "Matches constant patterns"
-      (match! (list 1 2 3 4 5)
-              ((1 2 3 4 5) 'case1))
-      'case1)
-
-
-(test "Matches patterns with constants mixed in"
-      (match! (list 1 2 3 4 5)
-              ((?x 2 ?y 4 ?z) (+ ?x ?y ?z)))
-      (+ 1 3 5))
-
-(test "Dispatches on first of multiple matching patterns"
-      (match! (list 1 2 3 4 5)
-              (?x 'case1)
-              ((?a ?b ?c ? d ?e) 'case2))
-      'case1)
-
-(test "Constants match"
-      (match! 10
-              (10 'case1))
-      'case1)
-
-(test "Successfully takes the else case on no match"
-      (match! (list 1 (list 2 (list 3)))
-              ((?x ?y ?z) 'case1)
-              (24 'case2)
-              (else 'case3))
-      'case3)
-
-
-(test "Custom map implementation succeeds"
-      ((lambda ()
-         (define (budget-map func lst)
-           (define (loop lst accum)
-             (match! lst
-                     (() accum)
-                     ((?x ?xs...)
-                      (loop ?xs...
-                            (cons (func ?x) accum)))))
-           (reverse (loop lst '())))
-         (budget-map (fn (x) (+ x 1)) (list 1 2 3 4 5))))
-      '(2 3 4 5 6))
-
-(test "Empty list matches empty list"
-      (match! '()
-              (() 'found-empty-list!)
-              ((?x ?xs...) 'found-list!))
-      'found-empty-list!)
-
-(test "Nested patterns match with bindings"
-      (match! (list (list 1 2) 3 (list 4 (list 5 6)))
-              (((?a 2) ?b (?c (5 6))) (+ ?a ?b ?c)))
-      (+ 1 3 4))
-
-
-(define-syntax begin-scope
-  (syntax-rules ()
-    ((begin-scope body ...)
-     ((fn () body ...)))))
-
-(test "Struct matching"
-      (begin-scope
-         (struct Apples (a b c))
-         (match! (Apples 10 30 50)
-                 ((Apples ?x ?y ?z) (+ ?x ?y ?z))))
-      (+ 10 30 50))
-
-
-(test "Nested struct matching"
-      (begin-scope
-        (struct Apples (a b c))
-        (match! (Apples (Apples (Apples 10 30 50) 1 2) 3 4)
-                ((Apples (Apples (Apples ?x ?y ?z) _ _) _ _)
-                 (+ ?x ?y ?z))))
-      (+ 10 30 50))
-
-
-(struct Add (l r))
-(struct Sub (l r))
-(struct Num (n))
-(struct String (s))
-
-(define (calculate expr)
-  (match! expr
-          ((Num ?n) ?n)
-          ((Sub ?l ?r) (- (calculate ?l) (calculate ?r)))
-          ((Add ?l ?r) (+ (calculate ?l) (calculate ?r)))))
-
-;; TODO provide stack trace on errors for debug builds
-;; collecting stack trace should just be:
-;; Go to function stack: Print out last executing functions with their spans
-;; Map spans to file + call site - print out underneath the function information
-;; Will help with errors inside functions, the callstack will tell me where things actually
-;; went wrong
-
-
-;; (displayln (calculate (Add (Add (Num 10) (Num 25)) (Sub (Num 100) (Num 300)))))
-
-; (struct Some (type inner))
-; (struct None (type))
-
-
-; (struct tuple (inner))
-; (displayln (t
-
-;; TODO multi arity functions - how do implement those? just turn everything inside into a list? maybe?
-
-; (displayln (apply list '(1 2 3 4 5 6)))
-
-
-; (struct Tuple (inner))
-
-; (define-syntax tuple
-;   (syntax-rules ()
-;     [(tuple arg ...) (Tuple (vector arg ...))]))
-
-
-
-; (displayln (tuple 1 2 3 4 5))
-
-
-
-
-; (define-syntax case-lambda
-;   (syntax-rules ()
-;     ((case-lambda)
-;      (lambda args
-;        (error "CASE-LAMBDA without any clauses.")))
-;     ((case-lambda 
-;       (?a1 ?e1 ...) 
-;       ?clause1 ...)
-;      (lambda args
-;        (let ((l (length args)))
-;          (case-lambda "CLAUSE" args l 
-;            (?a1 ?e1 ...)
-;            ?clause1 ...))))
-;     ((case-lambda "CLAUSE" ?args ?l 
-;       ((?a1 ...) ?e1 ...) 
-;       ?clause1 ...)
-;      (if (= ?l (length '(?a1 ...)))
-;          (apply (lambda (?a1 ...) ?e1 ...) ?args)
-;          (case-lambda "CLAUSE" ?args ?l 
-;            ?clause1 ...)))
-;     ((case-lambda "CLAUSE" ?args ?l
-;       ((?a1 . ?ar) ?e1 ...) 
-;       ?clause1 ...)
-;      (case-lambda "IMPROPER" ?args ?l 1 (?a1 . ?ar) (?ar ?e1 ...) 
-;        ?clause1 ...))
-;     ((case-lambda "CLAUSE" ?args ?l 
-;       (?a1 ?e1 ...)
-;       ?clause1 ...)
-;      (let ((?a1 ?args))
-;        ?e1 ...))
-;     ((case-lambda "CLAUSE" ?args ?l)
-;      (error "Wrong number of arguments to CASE-LAMBDA."))
-;     ((case-lambda "IMPROPER" ?args ?l ?k ?al ((?a1 . ?ar) ?e1 ...)
-;       ?clause1 ...)
-;      (case-lambda "IMPROPER" ?args ?l (+ ?k 1) ?al (?ar ?e1 ...) 
-;       ?clause1 ...))
-;     ((case-lambda "IMPROPER" ?args ?l ?k ?al (?ar ?e1 ...) 
-;       ?clause1 ...)
-;      (if (>= ?l ?k)
-;          (apply (lambda ?al ?e1 ...) ?args)
-;          (case-lambda "CLAUSE" ?args ?l 
-;            ?clause1 ...)))))
-  
-; (define plus
-;       (case-lambda 
-;             (() 0)
-;             ((x) x)
-;             ((x y) (+ x y))
-;             ((x y z) (+ (+ x y) z))
-;             (args (apply + args))))
-
-; (plus)                     
-; (plus 1)                   
-; (plus 1 2 3)
-
-
-;; (test "Matching duplicate names fails"
-;;       (match! (list 1 2 3 4 5)
-;;               ((?x ?x ?x ?x ?x) 'should-fail))
-;;       #f)
-
-
-;; match struct
-;; given a value, destruct it into each variables positions
-
-;; (struct Apple ())
-;; (struct Banana ())
-;; (struct Fruit ())
-;; (struct Burger ())
-
-;; (displayln (struct-ref (Apple) 2))
-
-
-;; (define (which-struct? s)
-;;   (cond [(Apple? s) 'Apple]
-;;         [(Banana? s) 'Banana]
-;;         [(Fruit? s) 'Fruit]
-;;         [else 'Unknown]))
-
-;; (displayln (which-struct? (Apple)))
-;; (displayln (which-struct? (Banana)))
-;; (displayln (which-struct? (Fruit)))
-;; (displayln (which-struct? (Burger)))
-
-;; When its a struct, we want to pop off the first pattern
-;; Keywords inside quotes expressions do not work properly
-; (displayln (match (quote (Apple y z)) '(x y z)))
-
-
-;; (displayln (match '(?x y z) (list 10 'y 'z)))
-
-
-; '(Apple 1 2 3)
-
-;; (struct Applesauce (a b c))
-
-;; (define (struct-pattern->indices pat)
-;;       (define (loop pat accum seed)
-;;             (if (null? pat)
-;;                   accum
-;;                   (let ((next-index (+ 1 seed)))
-;;                         (loop (cdr pat) (cons next-index accum) next-index))))
-;;       (reverse (loop (cdr pat) '() -1)))
-
-;; (displayln (struct-pattern->indices '(Applesauce ?x ?y z)))
-;; (displayln (struct-pattern->indices '(Unit-Struct)))
-
-
-;; (displayln (struct->list (Applesauce 10 45 90)))
-
-;; (displayln
-;;  (match '(Applesauce ?x ?y ?z)
-;;    (struct->list (Applesauce (Applesauce 10 20 30) 45 90))))
-
-
-;; (displayln
-;;  (match! (Applesauce (Applesauce 10 20 30) 2 3)
-;;          ((Applesauce (Applesauce ?x ?y ?z) 2 3) (+ ?x ?y ?z))
-;;          (else 'no-match)))
-
-;; (define-syntax match-struct
-;;   (syntax-rules ()
-;;     [(match-struct struct-name pattern expr)
-;;      (if ((datum->syntax struct-name?) expr)
-;;          (match (cdr pattern) (struct->list expr)))]))
-
-
-; (define (match-struct pattern struct bindings)
-      
-
-
-; )
-
-
-;; (define (match-wrapper pattern expr
diff --git a/steel-examples/transducer.scm b/steel-examples/transducer.scm
deleted file mode 100644
index 38fd56c9a..000000000
--- a/steel-examples/transducer.scm
+++ /dev/null
@@ -1,90 +0,0 @@
-(struct Iterator (stack))
-
-(struct Mapping (func))
-(struct Filtering (predicate))
-(struct Taking (num count))
-
-(define (mapping-2 func)
-    (Iterator (list (Mapping func))))
-
-(define (filtering-2 pred)
-    (Iterator (list (Filtering pred))))
-
-(define (taking num)
-    (Iterator (list (Taking num 0))))
-
-
-(define (flatten lst)
-  (cond ((null? lst) '())
-        ((list? lst)
-         (append (flatten (car lst)) (flatten (cdr lst))))
-        (else (list lst))))
-
-;; Build up stack of functions to apply
-(define (compose-2 a b)
-    (Iterator (flatten (append (Iterator-stack a) (Iterator-stack b)))))
-
-
-(define m (mapping-2 (fn (x) (+ x 1))))
-(define f (filtering-2 (fn (x) (even? x))))
-
-(define z (compose-2 m f))
-
-(Iterator-stack z)
-
-
-;; 
-(define (apply-stack stack value)
-    (if (null? stack)
-        value
-        (let ((transducer (car stack)))
-            (cond 
-                [(Mapping? transducer) 
-                (apply-stack (cdr stack) ((Mapping-func transducer) value))]
-                [(Filtering? transducer) 
-                 (apply-stack 
-                    (cdr stack) 
-                    (if ((Filtering-predicate transducer) value)
-                        value
-                        void))]
-                [else (error "Iterator with internal state not handled yet")]))))
-
-
-; (apply-stack (Iterator-stack z) 2)
-
-(define (transducing-foo iterator-stack lst res)
-    (if (null? lst)
-        res
-        (let ((output (apply-stack iterator-stack (car lst))))
-            (if output
-                (transducing-foo iterator-stack (cdr lst) (cons output res))
-                (transducing-foo iterator-stack (cdr lst) res)))))
-
-(define (transducing iterator lst)
-    (reverse (transducing-foo (Iterator-stack iterator) lst '())))
-
-
-(define xf (compose (mapping (fn (x) (+ x 1)))
-                    (filtering (fn (x) (even? x)))))
-
-(define r (range 0 1000))
-
-(transducing z r)
-; (execute xf r)
-
-;; Run through the stack and spit out the result
-; (define (execute stack input result)
-
-;     (if (null? stack)
-;         result
-;         (let* ((transducer (car stack))
-;                (name (Transducer-name transducer))
-;                (func (Transducer-func transducer)))
-;             (cond [(equal? 'map name)])
-;         )))
-
-;     (cond [(null? stack) result]
-;           [()]
-;     )
-
-
diff --git a/steel-examples/transducers.scm b/steel-examples/transducers.scm
deleted file mode 100644
index cc3401a62..000000000
--- a/steel-examples/transducers.scm
+++ /dev/null
@@ -1,19 +0,0 @@
-(define input-collection (range 0 10))
-
-;; passing nothing just does the reduction
-; (test-transduce 
-;     input-collection
-;     (into-vector))
-
-(define input-collection (range 0 10000))
-
-(test-transduce
-    input-collection
-    (into-reducer + 0))
-
-(test-transduce
-    input-collection
-    (into-sum))
-
-(define (for-each func col)
-    (test-transduce col (into-for-each func)))
diff --git a/steel-examples/transformer.scm b/steel-examples/transformer.scm
deleted file mode 100644
index dbbb21a1d..000000000
--- a/steel-examples/transformer.scm
+++ /dev/null
@@ -1,444 +0,0 @@
-
-
-(define (last l)
-  (if (null? (cdr l))
-      (car l)
-      (last (cdr l))))
-
-
-(define (lambda-no-args? e)
-  (and (equal? (car e) 'lambda)
-       (null? (cadr e))))
-
-;; assumes the body is one expression
-(define (get-body-fn l)
-  (last l))
-
-(define (empty-function-application? e)
-  (and (equal? (length e) 1)
-       (lambda-no-args? (car e))))
-
-
-(lambda-no-args? '(lambda () 10))
-(lambda-no-args? '(lambda (x) 10))
-
-
-(empty-function-application? '((lambda () 10)))
-(empty-function-application? '((lambda (x) 10) 2))
-
-;; take the code and transform it
-(define (transform e)
-  (caddr (car e)))
-
-(transform '((lambda () 10)))
-
-(define (transform-empty-function-application e)
-  (if (empty-function-application? e)
-      (transform e)
-      e))
-
-
-(transform-empty-function-application '((lambda () 10))) ;; 10
-(transform-empty-function-application '((lambda (x) 10) 2)) ;; stays the same
-
-
-(define (lambda-application? e)
-  (and (not (null? e))
-       (list? (car e))
-       (equal? (caar e) 'lambda)))
-
-
-
-;; '(+ 1 2 (+ 3 4) (+ 5 6))
-
-;; `(+ 1 2 ,(+ 3 4) (+ 5 6))
-
-(define (constant? expr)
-  (or (number? expr)
-      (symbol? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-(define (constant-not-symbols? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-(define (all func lst)
-  (if (null? lst)
-      #t
-      (if (func (car lst))
-          (all func (cdr lst))
-          #f)))
-
-(define (match-func sym)
-  (cond [(equal? '+ sym) +]
-        [(equal? '- sym) -]
-        [(equal? '* sym) *]
-        [(equal? '/ sym) /]
-        [(equal? 'string-append sym) string-append]
-        [(equal? 'equal? sym) equal?]
-        [else #f]))
-
-(define (match-if expr)
-  (equal? (car expr) 'if))
-
-;; provide functions which can be run at compile time?
-;; Or just try to run all of them?
-
-;; this is a generic recursive evaluation
-;; it's not quite done yet
-(define (constant-fold expr)
-  (cond
-    [(constant? expr) expr]
-    [(match-func (car expr))
-     (define res (map constant-fold expr))
-     (if (all constant-not-symbols? (cdr res))
-         (apply (match-func (car expr)) (cdr res))
-         res)]
-    [(match-if expr)
-     (define condition (constant-fold (car (cdr expr))))
-     ;; HACK / TODO
-     ;; Find how to differentiate something like a constant expression '(1 2 3 4) which
-     ;; evaluates to a list, versus something like '(lambda (x) 10)
-     (if (constant? condition)
-         (if condition
-             (constant-fold (caddr expr))
-             (constant-fold (cadddr expr)))
-         (list
-          'if
-          condition
-          (constant-fold (caddr expr))
-          (constant-fold (cadddr expr))))]
-    [else (map constant-fold expr)]))
-
-    ;; [(all atom? expr)
-    ;;  (apply
-    ;;   (match-func (car expr))
-    ;;   (map traverse (cdr expr)))]
-
-
-;; (define (all-atom expr)
-;;   (all atom? expr))
-
-(constant-fold
- '(list 1 2 3 4
-        (+ 1 2 3 4
-           (+ 4 5
-              (+ 7 8 9 10)))))
-
-(constant-fold
- '(if #t 10 20))
-
-(constant-fold
- '(if '(1 2 3 4) 20 40))
-
-(constant-fold
- '(if 25 10 20))
-
-(constant-fold
- '(if #t
-      (lambda (x) 10)
-      25))
-
-(constant-fold
- '(lambda (x) (* x x)))
-
-
-;; TODO make bytecode serializable
-;; compile the bytecode for the pipeline
-
-
-(define (atom? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)))
-
-(struct MFunction (bindings body))
-
-;; Meta Circular Evaluator
-(define (meval expr env)
-  (cond [(null? expr) (error! "empty expression")]
-        [(atom? expr) expr]
-        [(symbol? expr) (lookup env expr)]
-        [(equal? (car expr) 'if)
-         (if (meval (cadr expr) env)
-             (meval (caddr expr) env)
-             (meval (cadddr expr) env))]
-        [(equal? (car expr) 'lambda)
-         (MFunction (cadr expr) (caddr expr))]
-        [else ;; hopefully function application?
-         (define res (map (lambda (x) (meval x env)) expr))
-         (cond
-           [(function? (car res))
-            (apply (car res) (cdr res))]
-           [(MFunction? (car res))
-            ;; bind the arguments to the function arguments
-            (define new-env
-              (bind-args env
-                         (MFunction-bindings (car res))
-                         (cdr res)))
-            (meval (MFunction-body (car res))
-                   new-env)])]))
-
-
-(define (lookup env expr)
-  ;; (displayln "looking up: " expr)
-  (hash-get env expr))
-
-;; hash -> (listof sym?) -> (listof any?) -> hash
-(define (bind-args env list-of-symbols args)
-  (if (or (null? list-of-symbols) (null? args))
-      env
-      (bind-args
-       (hash-insert env
-                    (car list-of-symbols) (car args))
-       (cdr list-of-symbols)
-       (cdr args))))
-
-;; bind the functions from my initial environment
-;; into the scheme
-(define initial-env
-  (hash '+ +
-        '- -
-        '* *
-        '/ /
-        'list list
-        'equal? equal?))
-
-
-(meval '(list 1 2 3 4) initial-env)
-(meval '((lambda (x) 10)) initial-env)
-(meval '(if (equal? (+ 1 2 3) 6)
-            ((lambda (x) (* x x)) 25)
-            420) initial-env)
-
-;; remove unused variables from closures
-;; as in '((lambda (x) 30) 25)
-;;
-;; This should go to -> ((lambda () 30) 25)
-;; Which should then map to 25
-
-(define program
-  '(if (equal? (+ 1 2 3) 6)
-       ((lambda (x) (+ x x)) 25)
-       420))
-
-
-(constant-fold program)
-
-
-(define (m-atom? expr)
-  (or (number? expr)
-      (string? expr)
-      (integer? expr)
-      (boolean? expr)
-      (null? expr)
-      (symbol? expr)))
-
-;; does a naive walk of the tree to remove
-;; the empty function applications
-(define (walk expr)
-  (cond [(m-atom? expr)
-         expr]
-        [(empty-function-application? expr)
-         (define body
-           (transform-empty-function-application expr))
-         (walk body)]
-        [else
-         (map walk expr)]))
-
-(constant-fold
- (walk '(if #t
-           ((lambda () 10))
-           #f)))
-
-
-
-;; try to see if a value is constant by looking in the env and seeing if the closest related
-;; definition is a constant, if so substitute the value there and continue
-
-;; returns the bindings for a lambda expression application
-(define (lambda-expression-application? expr)
-  (if (and (>= (length expr) 2)
-           (list? (car expr))
-           (equal? (car (car expr)) 'lambda))
-      (car (cdr (car expr)))
-      '()))
-
-;; this is just an alias here
-(define get-application-args cdr)
-
-;; naive substitution of constant arguments
-(define (naive-subst* expr env)
-  ;; (displayln expr)
-  ;; (displayln (symbol? expr))
-  (cond [(null? expr) (error! "empty expression")]
-        [(atom? expr) expr]
-        [(symbol? expr)
-         ;; (displayln "inside symbol case with: ")
-         ;; (displayln expr)
-         ;; (displayln (hash-contains? env expr))
-         ;; (displayln env)
-         (cond
-           [(hash-contains? env expr)
-            (define expr-value (lookup env expr))
-            (displayln expr-value)
-            (if (constant? expr-value)
-                expr-value
-                expr)]
-           [else expr])]
-        [(lambda-expression-application? expr)
-         (define list-of-bindings (lambda-expression-application? expr))
-         (define list-of-args (get-application-args expr))
-         (define new-env (bind-args env list-of-bindings list-of-args))
-         ;; (displayln "lambda evaluation")
-         ;; (displayln new-env)
-         ;; (displayln (caddr (car expr)))
-         ;; TODO check if you can remove the constant value
-         ;; in the argument position
-         (cons
-          (list
-           'lambda
-           (car (cdr (car expr)))
-           (naive-subst* (caddr (car expr)) new-env))
-          (cdr expr))]
-        [else
-         (map (lambda (x) (naive-subst* x env)) expr)]))
-
-(define (naive-subst expr)
-  (naive-subst* expr (hash)))
-
-
-(constant-fold
- (naive-subst
-  (constant-fold
-   '((lambda (x) (* x x)) (+ 1 2 3 (+ 1 2 3))))))
-
-(naive-subst '((lambda (x) x) 10))
-
-
-(define (lambda-application? e)
-  (and (not (null? e))
-       (list? (car e))
-       (equal? (caar e) 'lambda)))
-
-(define args cadr)
-
-
-
-;; (define (walk2 expr)
-;;   (cond [(m-atom? expr) expr]
-;;         [(lambda-application? expr)
-;;          (define body (walk2 (get-body-fn (car expr))))
-;;          (if (constant? body)
-;;              body
-;;              (cons
-;;               (list 'lambda (args (car expr)) body)
-;;               (cdr expr)))]
-;;         [else (map walk2 expr)]))
-
-
-
-(define-syntax case
-  (syntax-rules (else =>)
-    [(case arg [else => e1 ...])
-     (begin e1 ...)]
-    [(case arg [e1 => e2 ...])
-     (when (e1 arg) e2 ...)]
-    [(case arg [e1 => e2 ...] c1 ...)
-     (if (e1 arg)
-         (begin e2 ...)
-         (case arg c1 ...))]))
-
-(define (walk2 expr)
-  (case expr
-    [m-atom? => expr]
-    [lambda-application? =>
-                         (define body (walk2 (get-body-fn (car expr))))
-                         (if (constant? body)
-                             body
-                             (cons
-                              (list 'lambda (args (car expr)) body)
-                              (cdr expr)))]
-    [else => (map walk2 expr)]))
-
-
-;; (define (pattern-match x)
-;;   (case x
-;;     [number? =>
-;;              (displayln "Found a number!")
-;;              (displayln "second statement")]
-;;     [function? =>
-;;                (displayln "found a function")
-;;                (displayln "found some other noise")]
-;;     [else => (displayln "else case!")]))
-
-
-(walk2 '((lambda (x) 10) 2))
-(walk2 '((lambda () 10)))
-
-(-> '((lambda (x) (* x x)) (+ 1 2 3 (+ 1 2 3)))
-    (constant-fold)
-    (naive-subst)
-    (constant-fold)
-    (walk2)) ;; -> 144
-
-
-(define *changed* (box #f))
-(define (init-changed) (set-box! *changed* #f))
-(define (mark-changed) (set-box! *changed* #t))
-(define (changed?) (unbox *changed*))
-
-
-(define *box* (box 0))
-(while (not (changed?))
-  (if (equal? (unbox *box*) 10)
-      (begin
-        (displayln "hello")
-        (mark-changed)
-        (displayln *box*))
-      (begin
-        (set-box! *box* (+ 1 (unbox *box*)))
-        (displayln *box*))))
-
-*box*
-
-;; default arguments need to get handled internally?
-;; replace all callsites with these
-;; (define (test-function  a (b 10) (c 25))
-;;   (+ a b c))
-
-;; -> have to figure out the aliasing rules to see if we can always do this
-;; this could also be handled fundamentally - the optional arguments always get
-;; put in on the lambda and could be handled that way
-;; (define (test func arg1)
-;;   (func arg1))
-
-;; ;; default values are going to be handled earlier
-;; (test-function)
-
-;; (test-function 10)
-
-;; (test-function 10 20)
-
-;; optional arguments to function
-
-
-
-
-;; (define-pass)
-;; pass -> takes an expr, returns an expr
-;; could require optional state, could not
-
-;; (walk2
-;;  (constant-fold
-;;   (naive-subst
-;;    (constant-fold
-;;     '((lambda (x) (* x x)) (+ 1 2 3 (+ 1 2 3)))))))
diff --git a/steel-examples/tree.scm b/steel-examples/tree.scm
deleted file mode 100644
index 827b0428b..000000000
--- a/steel-examples/tree.scm
+++ /dev/null
@@ -1,91 +0,0 @@
-;;; Simple 'Tree' implementation in Steel
-;;; Relies on the use of bindings to the file system through Rust
-; (require "sort.rkt")
-
-;;; Define a merge sort for sake of simplicity
-; (define (merge-lists l1 l2)
-;   (cond [(null? l1) l2]
-;         [(null? l2) l1]
-;         [(< (car l1) (car l2))
-;          (cons (car l1) (merge-lists (cdr l1) l2))]
-;         [else
-;          (cons (car l2) (merge-lists (cdr l2) l1))]))
-
-; ;;; -------------------------------------------------------------------
-; ;;; Given list l, output those tokens of l which are in even positions
-
-; (define (even-numbers l)
-;   (cond [(null? l) '()]
-;         [(null? (cdr l)) '()]
-;         [else
-;          (cons (car (cdr l)) (even-numbers (cdr (cdr l))))]))
-
-; ;;; -------------------------------------------------------------------
-; ;;; Given list l, output those tokens of l which are in odd positions
-
-; (define (odd-numbers l)
-;   (cond [(null? l) '()]
-;         [(null? (cdr l)) (list (car l))]
-;         [else
-;          (cons (car l) (odd-numbers (cdr (cdr l))))]))
-
-; ;;; ---------------------------------------------------------------------
-; ;;; Use the procedures above to create a simple and efficient merge-sort
-
-; (define (merge-sort l)
-;   (cond [(null? l) l]
-;         [(null? (cdr l)) l]
-;         [else
-;          (merge-lists
-;           (merge-sort (odd-numbers l))
-;           (merge-sort (even-numbers l)))]))
-
-(define (flatten x)
-  (cond [(null? x) '()]
-        [(not (list? x)) (list x)]
-        [else (append (flatten (car x))
-                      (flatten (cdr x)))]))
-
-
-;; Simple tree implementation
-;; Walks the file structure and prints without much fancy formatting
-;; Returns a list of the visited files for convenience
-(define (tree p)
-  (define (tree-rec path padding)
-    (define name (file-name path))
-    (displayln (string-append padding name))
-    (cond [(is-file? path) name]
-          [(is-dir? path)
-            (map (fn (x)
-                    (tree-rec x (string-append padding "    ")))
-                  ; (merge-sort (read-dir path)))]
-                  (read-dir path))]
-          [else void]))
-  (flatten (tree-rec p "")))
-
-(tree "/home/matt/Documents/steel/crates/steel/src")
-
-; (define p "/Users/mwparas/Documents/MatSci201")
-
-; (tree p)
-
-;; MatSci201
-;;     Midterm #1
-;;         Assessment Solutions
-;;             MatSci201-Midterm1-PracticeExam-F19-Sol.pdf
-;;             MatSci201-Midterm1-PracticeExam-F19.pdf
-;;             PSet-R1-Sol.pdf
-;;             PSetD2-F19-Sol.pdf
-;;             PSetD3-F19-Sol.pdf
-;;             PSetD4-F19-Sol.pdf
-;;             PracticeD2_F19-Sol.pdf
-;;             PracticeD3_F19-Sol.pdf
-;;             QuizD2_F19-Sol.pdf
-;;         Lectures
-;;             L1-1_Introduction_to_Materials-F19.pdf
-;;             L1-2-Bonding-F19.pdf
-;;             L2-1_Crystal Structure I-F19.pdf
-;;             L2-2 Crystal Structure II-F19-Companion.pdf
-;;             L2-2 Crystal Structure II-F19.pdf
-;;             L3-1 Ceramics and Polymer Structures-F19.pdf
-;;         Midterm1_StudyGuide-F19.pdf
diff --git a/steel-examples/trie.scm b/steel-examples/trie.scm
deleted file mode 100644
index d7549f0af..000000000
--- a/steel-examples/trie.scm
+++ /dev/null
@@ -1,123 +0,0 @@
-; #lang racket
-(struct trie (char children end-word? word-up-to))
-
-;; Rename functions for the sake of compatibility
-(define empty (list))
-(define empty-trie (trie void empty #f empty))
-
-;; Throw in a mediocre flatten definition
-(define (flatten lst)
-  (cond ((null? lst) empty)
-        ((list? lst)
-         (append (flatten (car lst)) (flatten (cdr lst))))
-        (else (list lst))))
-
-;; contract: (listof char?) (listof tries?) integer? -> (listof trie?)
-(define (create-children char-list lst prefix-chars)
-  (cond [(= (length char-list) 1)
-         (handle-last-letter char-list lst prefix-chars)]
-        [else ;; you are in the middle of the word
-         (handle-intern-letter char-list lst prefix-chars)]))
-
-;; contract: (listof char?) (listof trie?) integer? -> (listof trie?)
-(define (handle-last-letter char-list lst prefix-chars)
-  (define char (first char-list))
-  (define next-prefix (push-back prefix-chars char))
-  (cond [(empty? lst) ;; children are empty, return list of empty children
-         (list (trie char empty #t next-prefix))]
-        [(< char (trie-char (first lst))) ;; less than, put it to the left
-         (cons (trie char empty #t next-prefix) lst)]
-        [(= char (trie-char (first lst))) ;; equal, step down a level
-         (cons (trie char (trie-children (first lst)) #t next-prefix) (rest lst))]
-        [else ;; move to the right
-         (cons (first lst)
-               (create-children char-list (rest lst) prefix-chars))]))
-
-;; contract: (listof char?) (listof trie?) integer? -> (listof trie?)
-(define (handle-intern-letter char-list lst prefix-chars)
-  (define char (first char-list))
-  (define next-prefix (push-back prefix-chars char))
-  (cond [(empty? lst) ;; no children, pop off front and step down
-         (list (trie char (create-children
-                           (rest char-list) empty next-prefix) #f next-prefix))]
-        [(< char (trie-char (first lst))) ;; place where it is, pop off front and go
-         (cons (trie char (create-children
-                           (rest char-list) empty next-prefix) #f next-prefix) lst)]
-        [(= char (trie-char (first lst))) ;; equal, step down
-         (cons (trie char (create-children (rest char-list) (trie-children (first lst)) next-prefix)
-                     (trie-end-word? (first lst))
-                     (trie-word-up-to (first lst)))
-               (rest lst))]
-        [else ; move to the right
-         (cons (first lst)
-               (create-children char-list (rest lst) prefix-chars))]))
-
-
-;; contract: trie? string? integer? -> trie?
-(define (insert root-trie word)
-  (define char-list (string->list word))
-  (trie
-   (trie-char root-trie)
-   (create-children char-list (trie-children root-trie) empty)
-   (trie-end-word? root-trie)
-   (trie-word-up-to root-trie)))
-
-; contract: trie? trie? -> boolean?
-(define (trie<? trie-node1 trie-node2)
-  (< (trie-char trie-node1) (trie-char trie-node2)))
-
-;; contract: trie? -> void
-(define (pre-order-traverse trie-node)
-  (displayln (list (trie-char trie-node) (trie-end-word? trie-node) (trie-word-up-to trie-node)))
-  (map pre-order-traverse (trie-children trie-node))
-  "finished")
-
-;; contract: trie? (listof string?) -> trie?
-(define (build-trie-from-list-of-words trie list-of-words)
-  (cond
-    [(= (length list-of-words) 1)
-     (insert trie (first list-of-words))]
-    [else
-     (build-trie-from-list-of-words
-      (insert trie (first list-of-words))
-      (rest list-of-words))]))
-
-
-(define (trie-sort list-of-words)
-  (pre-order (build-trie-from-list-of-words empty-trie list-of-words)))
-
-; THIS ONE WORKS (using con and flatten)
-;; contract: trie? -> (listof string?)
-(define (pre-order trie-node)
-  (if (trie-end-word? trie-node)
-    (cons (list->string (trie-word-up-to trie-node))
-      (flatten (map pre-order (trie-children trie-node))))
-    (flatten (map pre-order (trie-children trie-node)))))
-
-
-(define test-list
-  (list
-   "suppose"
-   "believe"
-   "changeable"
-   "absent"
-   "busy"
-   "float"
-   "debonair"
-   "throat"
-   "grey"
-   "use"
-   "measure"
-   "van"
-   "thirsty"
-   "notify"
-   "star"
-))
-
-
-(define (generate-trie list-of-words)
-  (build-trie-from-list-of-words empty-trie list-of-words))
-
-
-(displayln (pre-order (generate-trie test-list)))
-
diff --git a/steel-examples/trie_contract.scm b/steel-examples/trie_contract.scm
deleted file mode 100644
index eafd9d8da..000000000
--- a/steel-examples/trie_contract.scm
+++ /dev/null
@@ -1,124 +0,0 @@
-; #lang racket
-(struct trie (char children end-word? word-up-to))
-
-;; Rename functions for the sake of compatibility
-(define empty (list))
-(define empty-trie (trie void empty #f empty))
-
-;; Throw in a mediocre flatten definition
-(define (flatten lst)
-  (cond ((null? lst) empty)
-        ((list? lst)
-         (append (flatten (car lst)) (flatten (cdr lst))))
-        (else (list lst))))
-
-(define/contract (create-children char-list lst prefix-chars)
-  (->/c (listof char?) (listof trie?) (listof char?) (listof trie?))
-  (cond [(= (length char-list) 1)
-         (handle-last-letter char-list lst prefix-chars)]
-        [else ;; you are in the middle of the word
-         (handle-intern-letter char-list lst prefix-chars)]))
-
-(define/contract (handle-last-letter char-list lst prefix-chars)
-  (->/c (listof char?) (listof trie?) (listof char?) (listof trie?))
-  (define char (first char-list))
-  (define next-prefix (push-back prefix-chars char))
-  (cond [(empty? lst) ;; children are empty, return list of empty children
-         (list (trie char empty #t next-prefix))]
-        [(< char (trie-char (first lst))) ;; less than, put it to the left
-         (cons (trie char empty #t next-prefix) lst)]
-        [(= char (trie-char (first lst))) ;; equal, step down a level
-         (cons (trie char (trie-children (first lst)) #t next-prefix) (rest lst))]
-        [else ;; move to the right
-         (cons (first lst)
-               (create-children char-list (rest lst) prefix-chars))]))
-
-(define (handle-intern-letter char-list lst prefix-chars)
-  (->/c (listof char?) (listof trie?) (listof char?) (listof trie?))
-  (define char (first char-list))
-  (define next-prefix (push-back prefix-chars char))
-  (cond [(empty? lst) ;; no children, pop off front and step down
-         (list (trie char (create-children
-                           (rest char-list) empty next-prefix) #f next-prefix))]
-        [(< char (trie-char (first lst))) ;; place where it is, pop off front and go
-         (cons (trie char (create-children
-                           (rest char-list) empty next-prefix) #f next-prefix) lst)]
-        [(= char (trie-char (first lst))) ;; equal, step down
-         (cons (trie char (create-children (rest char-list) (trie-children (first lst)) next-prefix)
-                     (trie-end-word? (first lst))
-                     (trie-word-up-to (first lst)))
-               (rest lst))]
-        [else ; move to the right
-         (cons (first lst)
-               (create-children char-list (rest lst) prefix-chars))]))
-
-
-(define/contract (insert root-trie word)
-  (->/c trie? string? trie?)
-  (define char-list (string->list word))
-  (trie
-   (trie-char root-trie)
-   (create-children char-list (trie-children root-trie) empty)
-   (trie-end-word? root-trie)
-   (trie-word-up-to root-trie)))
-
-(define/contract (trie<? trie-node1 trie-node2)
-  (->/c trie? trie? boolean?)
-  (< (trie-char trie-node1) (trie-char trie-node2)))
-
-(define/contract (pre-order-traverse trie-node)
-  (->/c trie? any/c)
-  (displayln (list (trie-char trie-node) (trie-end-word? trie-node) (trie-word-up-to trie-node)))
-  (map pre-order-traverse (trie-children trie-node))
-  "finished")
-
-(define/contract (build-trie-from-list-of-words trie list-of-words)
-  (->/c trie? (listof string?) trie?)
-  (cond
-    [(= (length list-of-words) 1)
-     (insert trie (first list-of-words))]
-    [else
-     (build-trie-from-list-of-words
-      (insert trie (first list-of-words))
-      (rest list-of-words))]))
-
-
-(define/contract (trie-sort list-of-words)
-  (->/c (listof string?) (listof string?))
-  (pre-order (build-trie-from-list-of-words empty-trie list-of-words)))
-
-(define/contract (pre-order trie-node)
-  (->/c trie? (listof string?))
-  (if (trie-end-word? trie-node)
-    (cons (list->string (trie-word-up-to trie-node))
-      (flatten (map pre-order (trie-children trie-node))))
-    (flatten (map pre-order (trie-children trie-node)))))
-
-
-(define test-list
-  (list
-   "suppose"
-   "believe"
-   "changeable"
-   "absent"
-   "busy"
-   "float"
-   "debonair"
-   "throat"
-   "grey"
-   "use"
-   "measure"
-   "van"
-   "thirsty"
-   "notify"
-   "star"
-))
-
-
-(define/contract (generate-trie list-of-words)
-  (->/c (listof string?) trie?)
-  (build-trie-from-list-of-words empty-trie list-of-words))
-
-
-(displayln (pre-order (generate-trie test-list)))
-
diff --git a/steel-examples/unicode.scm b/steel-examples/unicode.scm
deleted file mode 100644
index 2d20d4106..000000000
--- a/steel-examples/unicode.scm
+++ /dev/null
@@ -1,13 +0,0 @@
-;; Steel supports unicode, whether you want math symbols or just emojis
-;; This is very WIP and potentially might not work
-
-(define 😁 15)
-(define 😼 25)
-(define (🔥 👨 👩)
-    (+ 👨 👩))
-
-(🔥 😁 😼)
-
-(define blagh "😂😂💯")
-
-(define 😂😂💯 100)
\ No newline at end of file
diff --git a/steel-examples/vm.scm b/steel-examples/vm.scm
deleted file mode 100644
index 2b666da7e..000000000
--- a/steel-examples/vm.scm
+++ /dev/null
@@ -1,176 +0,0 @@
-
-(define-syntax fun
-  (syntax-rules (:: ->)
-    [(fun name :: (arg c -> return) body ...)
-     (define/contract (name arg) (->/c c return) body ...)]
-    [(fun name :: (arg c -> arg1 c1 -> return) body ...)
-     (define/contract (name arg arg1) (->/c c c1 return) body ...)]
-    [(fun name :: (arg c -> arg1 c1 -> arg2 c2 -> return) body ...)
-     (define/contract (name arg arg1 arg2) (->/c c c1 c2 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3)
-       (->/c c c1 c2 c3 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4)
-       (->/c c c1 c2 c3 c4 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5)
-       (->/c c c1 c2 c3 c4 c5 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> arg6 c6
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5 arg6)
-       (->/c c c1 c2 c3 c4 c5 c6 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> arg6 c6
-                       -> arg7 c7
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5 arg6 arg7)
-       (->/c c c1 c2 c3 c4 c5 c6 c7 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> arg6 c6
-                       -> arg7 c7
-                       -> arg8 c8
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8)
-       (->/c c c1 c2 c3 c4 c5 c6 c7 c8 return) body ...)]
-    [(fun name :: (arg c
-                       -> arg1 c1
-                       -> arg2 c2
-                       -> arg3 c3
-                       -> arg4 c4
-                       -> arg5 c5
-                       -> arg6 c6
-                       -> arg7 c7
-                       -> arg8 c8
-                       -> arg9 c9
-                       -> return) body ...)
-     (define/contract
-       (name arg arg1 arg2 arg3 arg4 arg5 arg6 arg7 arg8 arg9)
-       (->/c c c1 c2 c3 c4 c5 c6 c7 c8 c9 return) body ...)]))
-
-
-;; New more palatable function declarations
-;; similar to haskell / agda kinda stuff
-; (fun add-two :: (left int? -> right int? -> int?)
-;      (+ left right))
-
-; (displayln (add-two 10 20))
-
-
-; (fun boop-lemma-1 :: (l any/c -> any/c)
-;      (displayln l))
-
-; (boop-lemma-1 "alex")
-
-
-
-(struct VmState (ip stack))
-
-
-(define PUSH 0)
-(define POP 1)
-(define ADD 2)
-(define SUB 3)
-
-;; Just use 
-(define (make-inst op-code payload)
-    (list op-code payload))
-
-(define (handle-push instructions payload state)
-    (VmState (+ (VmState-ip state) 1) (cons payload (VmState-stack state))))
-
-(fun handle-add :: (instructions vector? -> payload any/c -> state VmState? -> (or/c VmState? integer?))
-    (define stack (VmState-stack state))
-    ; (displayln stack) ;; this is a bug - it should print the stack and not "123"
-    (define left (car stack))
-    (define right (car (cdr stack)))
-    (VmState (+ (VmState-ip state) 1) (cons (+ left right) (cdr (cdr stack)))))
-
-(fun handle-sub :: (instructions vector? -> payload any/c -> state VmState? -> (or/c VmState? integer?))
-    (define stack (VmState-stack state))
-    (define left (car stack))
-    (define right (car (cdr stack)))
-    (define result (- left right))
-    (VmState (+ (VmState-ip state) 1) (cons result (cdr (cdr stack)))))
-
-(fun handle-pop :: (instructions vector? -> payload any/c -> state VmState? -> (or/c VmState? integer?))
-    (car (VmState-stack state)))
-
-(define event-loop
-    ;; Index corresponds to the actual op code itself
-    ;; This then dispatches to the correct case
-    ;; Could also do this with a big cond but this might be better performance on every loop to just do this
-    (vector 
-        handle-push
-        handle-pop
-        handle-add
-        handle-sub))
-
-(fun dispatch :: (opcode integer? -> (->/c vector? any/c VmState? (or/c VmState? integer?)))
-    (vector-ref event-loop opcode))
-
-
-;; Core event loop 
-(define (vm instructions state)
-    (let* ((ip (VmState-ip state))
-           (stack (VmState-stack state))
-           (cur-inst (vector-ref instructions ip))
-           (cur-op (car cur-inst)))
-
-           (displayln cur-op)
-           ;; Hand off the VM here
-           (let ((output ((dispatch cur-op) instructions (car (cdr cur-inst)) state)))
-                (if (equal? cur-op POP)
-                    output
-                    (vm instructions output)))))
-
-
-(define test-instructions
-    (vector
-        (list PUSH 10) ;; (10)
-        (list PUSH 20) ;; (20 10)
-        (list ADD 0) ;; (30)
-        (list PUSH 30) ;; (30 30)
-        (list ADD 0) ;; (60)
-        (list POP 0)))
-
-(displayln (vm test-instructions (VmState 0 '())))
-
-
diff --git a/steel-examples/y_combinator.scm b/steel-examples/y_combinator.scm
deleted file mode 100644
index 12e3e4c77..000000000
--- a/steel-examples/y_combinator.scm
+++ /dev/null
@@ -1,72 +0,0 @@
-; #lang racket
-
-(define Y 
-  (lambda (f)
-    ((lambda (x) (x x))
-      (lambda (x) (f (lambda (y) ((x x) y)))))))
-
-;; head-recursive factorial
-(define fac                ; fac = (Y f) = (f      (lambda a (apply (Y f) a))) 
-  (Y (lambda (r)           ;     = (lambda (x) ... (r     (- x 1)) ... )
-       (lambda (x)         ;        where   r    = (lambda a (apply (Y f) a))
-         (if (< x 2)       ;               (r ... ) == ((Y f) ... )
-             1             ;     == (lambda (x) ... (fac  (- x 1)) ... )
-             (* x (r (- x 1))))))))
- 
- 
-; double-recursive Fibonacci
-(define fib
-  (Y (lambda (f)
-       (lambda (x)
-         (if (< x 2)
-             x
-             (+ (f (- x 1)) (f (- x 2))))))))
-
-
-
-; (display (fac 6))
-; (newline)
- 
-; (display (fib 13))
-; (newline)
-
-
-(define (loop x)
-  ; (displayln "looping")
-  (test-let ((output (vector 1 2 3 4 5)))
-    (test-let ((output2 (vector 1 2 3 4 5)))
-      (if (= x 100)
-          output2
-          (loop (+ x 1))))))
-
-
-(define (loop x)
-  (test-let ((output (vector 1 2 3 4 5))
-             (output2 (vector 1 2 3 4 5)))
-      (if (= x 1000)
-          output2
-          (loop (+ x 1)))))
-
-
-(define (test x)
-  (test-let ((y 20))
-    (lambda (z) (+ x y z))))
-
-
-(define lambda-lifter-Y1
-  (lambda (x f)
-    (x x)))
-
-
-(define Y
-  (lambda (f)
-    (lambda-lifter-Y1
-       (lambda (x)
-         (f (lambda (y) ((x x) y))))
-       f)))
-
-(define fib
-  (Y
-     (lambda (f)
-       (lambda (x)
-         (if (< x 2) x (+ (f (- x 1)) (f (- x 2))))))))