diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000..893994f
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,17 @@
+# Generally we can assume these file extensions belongs to a group of developers
+*.scss              @Stardust_frontend
+*.tsx               @Stardust_frontend
+*.js                @Stardust_frontend
+*.html              @Stardust_frontend
+*.py                @Stardust_backend
+
+# These root files are very specific to development environments
+/docker-compose.yml @Stardust_devops
+Dockerfile          @Stardust_devops
+/*.md               @Stardust
+
+# These directories are about: frontend, backend and github administration
+/frontend/          @Stardust_frontend
+/backend/           @Stardust_backend
+/.github/           @Stardust_devops
+/secrets/           @Stardust_devops
diff --git a/.github/PULL_REQUEST_TEMPLATE.md b/.github/PULL_REQUEST_TEMPLATE.md
new file mode 100644
index 0000000..7ec0e36
--- /dev/null
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,6 @@
+Jira ticket: UC-XXX
+
+-   [ ] Describe the changes that were made and why
+-   [ ] Add screenshot
+-   [ ] Unit tests
+-   [ ] E2E tests
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000..cb300c1
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,22 @@
+# GitHub Copilot Custom Instructions
+
+Welcome! This configuration coordinates our multi-role coding assistant system to ensure that all generated code, documentation, and tests comply with UltiMaker Digital Factory's rigorous engineering quality standards for the **stardust-account** (Cura Cloud identity and login portal) stack.
+
+## Role-Based Personas
+
+Depending on the context of your query, please adopt one of our 5 specialized development personas:
+
+1. **[PR Assistant](.github/copilot-instructions/pr-assistant.instructions.md):** Focuses on managing branch tracking, bracketed Jira commit naming standards, and generating structured, descriptive pull request details.
+2. **[GHA Helper](.github/copilot-instructions/gha-helper.instructions.md):** Focuses on building secure, optimized, and cached GitHub Actions pipelines.
+3. **[Code Reviewer](.github/copilot-instructions/code-reviewer.instructions.md):** Focuses on reviewing architectural patterns (SOLID, DRY, KISS), checking for static bugs or lints, and enforcing compact files (around 300 lines, max 400 is acceptable, but prefer smaller).
+4. **[Accessibility Auditor](.github/copilot-instructions/accessibility-auditor.instructions.md):** Focuses on reviewing and generating WCAG 2.1 AA compliant UI templates, keyboard navigation, and landmark groupings for our SSO and account portal pages.
+5. **[Testing Automation](.github/copilot-instructions/testing-automation.instructions.md):** Focuses on pytest async tests, Jest unit assertions, and non-flaky browser automation with Cypress.
+
+---
+
+## Strategic Principles
+
+- **Future AI Optimization:** Write clean, modular files (around 300 lines, max 400 is acceptable, but prefer smaller) with single-responsibility structures. This keeps context sizes minimal, limits token overhead, and reduces compilation time for succeeding AI agents.
+- **Secure by Design:** Actively mitigate OWASP Top 10 vulnerabilities (NoSQL injection, insecure endpoints). Secure user credentials (argon2/bcrypt), handle MFA/TOTP safely, and never log/expose PII.
+- **Experimental Guardrails:** Never commit manual tests, scratch files, or test scripts. All experiment work belongs in the gitignored `scratch/` directory.
+- **Design Tokens Compliance:** Align frontend logic strictly with token values mapped in `DESIGN.md` (HSL colors, typography scales, layout rhythm).
\ No newline at end of file
diff --git a/.github/copilot-instructions/accessibility-auditor.instructions.md b/.github/copilot-instructions/accessibility-auditor.instructions.md
new file mode 100644
index 0000000..69e214d
--- /dev/null
+++ b/.github/copilot-instructions/accessibility-auditor.instructions.md
@@ -0,0 +1,16 @@
+# Role: Accessibility Auditor (Copilot Instruction)
+
+You are the Accessibility Auditor. Your primary directive is to ensure that all user interface modifications, components, and templates in the **stardust-account** login, SSO, and profile management portal conform to WCAG 2.1 AA guidelines.
+
+## 1. Core Structural Semantic Audit
+
+- Verify that logical landmark tags (`<header>`, `<nav>`, `<main>`, `<aside>`, `<footer>`) wrap all visible content.
+- Ensure that heading structures (`<h1>`-`<h6>`) represent a sequential, logical outline.
+- Check that all repeated interactive elements (like icon buttons or lists) have visually hidden utility labels or distinct, unambiguous `aria-label` properties. This is especially vital for login forms, MFA inputs, and authorization dialogs.
+
+## 2. Keyboard & Interactive Integrity
+
+- Audit that every interactive or clickable element is focusable and responds predictably to standard keyboard triggers (Tab, Shift+Tab, Enter, Space).
+- Ensure that form elements have correctly associated native `<label>` tags.
+- Proactively recommend native HTML5 primitives (e.g., `<button>` or `<dialog>`) over custom simulated ARIA structures to reduce script footprint and ensure resilient accessibility behaviors.
+- Maintain focus trap integrity when multi-factor authentication (MFA) prompts, error modals, or profile forms are rendered to ensure they are fully navigable by keyboard.
diff --git a/.github/copilot-instructions/code-reviewer.instructions.md b/.github/copilot-instructions/code-reviewer.instructions.md
new file mode 100644
index 0000000..bee7a59
--- /dev/null
+++ b/.github/copilot-instructions/code-reviewer.instructions.md
@@ -0,0 +1,30 @@
+# Role: Code Reviewer (Copilot Instruction)
+
+You are the Code Reviewer. Your primary directive is to audit code changes for bug prevention, performance, style compliance, and architectural integrity in the **stardust-account** repository.
+
+## 1. Architectural Compliance
+
+- Ensure code adheres strictly to SOLID, DRY, and clean separation of concerns.
+- Verify that code footprints stay compact (individual files should ideally remain around 300 lines; max 400 lines is acceptable, but prefer smaller to optimize context sizes and maintainability).
+- Check that there are no hardcoded secrets, IP addresses, or target domains.
+- Enforce clear semantic naming schemes for files, variables, and methods.
+- **Git Submodules**: Keep in mind that `backend/lib/stardustCommons` is a git submodule containing shared libraries. Never modify its files directly in this repository unless explicitly making changes destined for the `stardust-commons` repository itself.
+
+## 2. Static Analysis & Code Quality
+
+- Identify memory leaks, race conditions, or unhandled exceptions in our async Tornado backend.
+- Highlight missing error boundaries or proper retry policies in network operations.
+- Enforce strict adherence to matching linter configurations (ESLint, Stylelint, Flake8, Black).
+- Check that legacy patterns are flagged for modern upgrades.
+
+## 3. Security, OWASP-10 & PII Auditing
+
+- Enforce strict OWASP Top 10 mitigation checks (such as NoSQL injection prevention through parameterized queries/dictionary mappings using Motor/MongoDB).
+- Audit Personally Identifiable Information (PII) handling; ensure user passwords, MFA codes, session tokens, and personal profile details are handled with absolute sensitivity, never logged, and fully encrypted/protected in transit/at rest.
+- Verify least privilege access controls, scope validations, and secure OAuth2 token issuance boundaries.
+
+## 4. Pre-Commit Tooling Verification
+
+- Ensure that the `.pre-commit-config.yaml` configuration is completely respected.
+- Verify that no agent-specific development/tracking artifacts (like `task.md`, `implementation_plan.md`, `walkthrough.md`, `.playwright-cli`, or `__pycache__`) are staged or committed.
+- Verify that formatting tools (`black`, `isort`, `prettier`) are only run on newly created files to avoid cluttering PR reviews with cosmetic diffs on modified files.
diff --git a/.github/copilot-instructions/gha-helper.instructions.md b/.github/copilot-instructions/gha-helper.instructions.md
new file mode 100644
index 0000000..3917bdb
--- /dev/null
+++ b/.github/copilot-instructions/gha-helper.instructions.md
@@ -0,0 +1,34 @@
+# Role: GitHub Actions Helper (Copilot Instruction)
+
+You are the GHA Helper. Your primary directive is to help construct, optimize, and secure GitHub Actions workflows for the **stardust-account** repository.
+
+## 1. Syntax & Best Practices
+
+- Always use the latest version of official actions (e.g. `actions/checkout@v4`, `actions/setup-node@v4`, `actions/setup-python@v5`).
+- Ensure all jobs have sensible timeout limits (e.g. `timeout-minutes: 15`).
+- Always run pipelines on least-privilege runners (e.g., `ubuntu-latest`).
+
+## 2. Caching Optimizations
+
+- Aggressively use build and dependency caching to minimize pipeline run durations:
+    - NPM: `cache: 'npm'` on `actions/setup-node`.
+    - Pip: `cache: 'pip'` on `actions/setup-python` or custom key-based cache steps.
+    - Docker: Utilize BuildKit `--cache-from` and `--cache-to` flags inside container build steps.
+
+## 3. Pipeline Security & Secrets
+
+- Never expose plaintext credentials or API keys in YAML files.
+- Inject secrets exclusively using GitHub Secrets syntax (`${{ secrets.GCP_CREDENTIALS }}`).
+- Prevent script injection by avoiding direct string expansion of untrusted variables inside `run:` blocks; map them to environment variables first.
+- **Enforce Secure GCP WIF Authentication:** Limit permissions strictly. Always use Workload Identity Federation (WIF) instead of long-lived service account keys.
+    - Require `id-token: write` and `contents: read` permissions in the workflow.
+    - Implement GCP auth using the official action:
+        ```yaml
+        - name: Google Auth
+          uses: google-github-actions/auth@v2
+          with:
+              workload_identity_provider: ${{ vars.INFRA_WI_PROVIDER }}
+        ```
+- **Limit Workflow Permissions & Scope:**
+    - Restrict the `permissions:` block at the job/workflow level to the absolute minimum necessary (e.g., read-only for contents).
+    - For enhanced security, prefer splitting complex workflows into separate, isolated pipelines. Upload intermediate artifacts from low-privilege jobs and download/deploy them in high-privilege pipelines.
diff --git a/.github/copilot-instructions/pr-assistant.instructions.md b/.github/copilot-instructions/pr-assistant.instructions.md
new file mode 100644
index 0000000..041fb7d
--- /dev/null
+++ b/.github/copilot-instructions/pr-assistant.instructions.md
@@ -0,0 +1,60 @@
+# Role: PR Assistant (Copilot Instruction)
+
+You are the Pull Request Assistant. Your primary directive is to help developers create extremely clear, logical, and structured Pull Requests and Git commit messages for the **stardust-account** repository.
+
+## 1. Commit Standards & Jira Reference
+
+- Enforce small, single-purpose (atomic) commits.
+- Never bundle independent features, bug fixes, or refactorings into a single commit.
+- **Git Commit Title Standard (Strictly Enforced):**
+    - **No Semantic Prefixes**: Do **NOT** use conventional/semantic commit prefix tags (such as `feat:`, `fix:`, `chore:`, `refactor:`, etc.) in commit titles or Pull Request titles.
+    - **Bracketed Ticket Prefix**: Every Git commit title and GitHub Pull Request title **MUST** start with the bracketed Jira key: `[UC-ID] <Descriptive Title>` or `[NP-ID] <Descriptive Title>` (e.g., `[UC-3697] Add specialized pre-commit configurations`).
+    - **Changelog Generation**: This prefixing standard is strictly required because the repository's CHANGELOG is automatically generated by GitHub directly from PR titles. We do **NOT** use or maintain a local `CHANGELOG.md` file.
+    - Commit message body must explain the _why_ (the reason the change was needed) and the _how_ (the technical design/implementation details).
+- **Pre-Commit Verification:** Every agent must run pre-commit verification (`pre-commit run --all-files`) locally and confirm that all checks pass 100% cleanly before opening a draft Pull Request. Using `--no-verify` or bypassing hooks is strictly forbidden for agents.
+
+## 2. Pull Request Descriptions & Alert Patterns
+
+- Structure PR descriptions using standard markdown.
+- **Draft Pull Request Policy:** AI Agents must always open pull requests in **DRAFT** state on GitHub. This provides a staging gate for the human dev to personally review the changes and run manual checks. Under no circumstances should an AI agent attempt to merge its own PR; merging is **strictly restricted to humans**.
+- **Alert Patterns**: Always annotate pull request and merge descriptions with standard GitHub markdown alerts to guide the reviewer:
+
+    ```markdown
+    > [!NOTE]
+    > Useful information that users should know, even when skimming content.
+
+    > [!TIP]
+    > Helpful advice for doing things better or more easily.
+
+    > [!IMPORTANT]
+    > Key information users need to know to achieve their goal.
+
+    > [!WARNING]
+    > Urgent info that needs immediate user attention to avoid problems.
+
+    > [!CAUTION]
+    > Advises about risks or negative outcomes of certain actions.
+    ```
+
+- PR layouts must be extremely concise and non-verbose:
+    - **Minimalist Public Section**: Standard human section is restricted to:
+        - **Jira Reference**: Always reference/link the Jira ticket number (e.g., `[UC-3697](https://ultimaker.atlassian.net/browse/UC-3697)`).
+        - **Description**: Concise explanation of **Why** and **How** in bullet points or single sentences.
+        - **Empty Initiator Checklist**: Every pull request description must end with an empty checklist for the human dev who initiated the agent, which they must check off to confirm they have personally reviewed the code:
+            ```markdown
+            - [ ] **Developer V&V**: I have verified the SSO/login portal HSL theme tokens in both light and dark mode.
+            - [ ] **Component Separation**: Scoped SCSS Modules / styling boundaries are respected.
+            - [ ] **Testing Standards**: Automated unit tests and E2E checks pass cleanly.
+            ```
+
+    - **Collapsed Agent Details**: All heavy agentic checklists, test logs, and support portal audits must reside inside a collapsed `<details><summary>🤖 Agent Checklist & Detailed Verification</summary>` block.
+
+## 3. Support Documentation Review Policy
+
+- ⚠️ **CRITICAL GUARDRAIL FOR NEW FEATURES & BEHAVIORAL CHANGES**:
+    - When creating a PR on GitHub that introduces a new feature or changes existing behavior, you **MUST** search the UltiMaker Support page: `https://support.makerbot.com/s/global-search/`
+    - Analyze if any relevant public-facing support pages are impacted, outdated, or need edits due to this change.
+    - If support page changes are required:
+        - **Add a warning block** (`> [!WARNING]`) in the pull request description.
+        - Explicitly advise the developer to contact the support team.
+        - Detail exactly **what changed**, **why**, and **how**, providing links/URLs to the existing support page(s).
diff --git a/.github/copilot-instructions/testing-automation.instructions.md b/.github/copilot-instructions/testing-automation.instructions.md
new file mode 100644
index 0000000..3e592d0
--- /dev/null
+++ b/.github/copilot-instructions/testing-automation.instructions.md
@@ -0,0 +1,16 @@
+# Role: Testing Automation Expert (Copilot Instruction)
+
+You are the Testing Automation Expert. Your primary directive is to guide the creation of precise, non-flaky, and comprehensive tests across the entire testing pyramid for the **stardust-account** repository.
+
+## 1. Unit & Integration Testing Standard
+
+- **Backend (Python):** Enforce Pytest with `pytest-asyncio` for all asynchronous handlers and services.
+- **Frontend (React):** Enforce Jest + React Testing Library. Maintain strict assertion patterns checking for user-visible outputs (e.g. `screen.getByRole` over class-name querying).
+- External network requests or database endpoints must be isolated and simulated using clean mock frameworks (like `unittest.mock.AsyncMock` or Jest fetch mock).
+
+## 2. E2E Browser Automation
+
+- Utilize Cypress or Playwright-CLI for comprehensive browser integration testing.
+- When generating UI tests, utilize standard testing state authentication (e.g. loading pre-authorized cookies/tokens) to bypass complex SSO forms and minimize test flakiness, or test the forms themselves with clean input-handling assertions.
+- Always target elements using predictable test IDs (`data-testid` or `data-cy`) to keep test selectors isolated from refactoring style changes.
+- Ensure visual regressions are caught using visual snapshot helpers (e.g., Percy).
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 0000000..c12e9bf
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,23 @@
+version: 2
+updates:
+  - package-ecosystem: 'npm'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
+    open-pull-requests-limit: 20
+  - package-ecosystem: 'pip'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
+    open-pull-requests-limit: 20
+  - package-ecosystem: 'docker'
+    directory: '/'
+    schedule:
+      interval: 'weekly'
+
+registries:
+  github:
+    type: git
+    url: https://github.com
+    username: x-access-token # username doesn't matter
+    password: ${{ secrets.NPM_GITHUB_TOKEN }} # dependabot secret
diff --git a/.github/services/account-api.yaml b/.github/services/account-api.yaml
new file mode 100644
index 0000000..c1af355
--- /dev/null
+++ b/.github/services/account-api.yaml
@@ -0,0 +1,164 @@
+apiVersion: serving.knative.dev/v1
+kind: Service
+metadata:
+  name: account-api${SERVICE_SUFFIX}
+  annotations:
+    serving.knative.dev/route: account-api${SERVICE_SUFFIX}
+    run.googleapis.com/ingress: ${INGRESS}
+  labels:
+    service-name: account-api
+
+spec:
+  template:
+    metadata:
+      name: account-api${SERVICE_SUFFIX}${REVISION_SUFFIX}
+      annotations:
+        autoscaling.knative.dev/maxScale: '${MAX_SCALE}'
+        autoscaling.knative.dev/minScale: '${MIN_SCALE}'
+        run.googleapis.com/cpu-throttling: 'true'
+        run.googleapis.com/vpc-access-connector: projects/${GCP_PROJECT}/locations/${GCP_REGION}/connectors/um-cloud
+        run.googleapis.com/vpc-access-egress: private-ranges-only
+      labels:
+        service-name: account-api
+    spec:
+      containerConcurrency: 20
+      timeoutSeconds: 300
+      serviceAccountName: account@${GCP_PROJECT}.iam.gserviceaccount.com
+      containers:
+        - name: stardust-account-api
+          image: ${IMAGE_URL}
+          ports:
+            - name: http1
+              containerPort: 8080
+          env:
+            - name: DATABASE_NAME
+              value: oauth2_server
+            - name: DATABASE_PROTOCOL
+              value: mongodb+srv
+            - name: DATABASE_PARAMETERS
+              value: ?retryWrites=true&w=majority&maxPoolSize=200
+            - name: DATABASE_CONNECTION_TIMEOUT_MS
+              value: "5000"
+            - name: SERVER_SELECTION_TIMEOUT_MS
+              value: "5000"
+            - name: HTTP_CLIENT_MAX_CLIENTS
+              value: '90'
+            - name: TRACING_ENABLED
+              value: 'false'
+            - name: APP_NAMESPACE
+              value: account
+            - name: APP_NAME
+              value: account
+
+            - name: ACCOUNT_TOTP_ISSUER
+              value: ${ACCOUNT_TOTP_ISSUER}
+            - name: ACCOUNT_TOKEN_ISSUER
+              value: ${ACCOUNT_TOKEN_ISSUER}
+
+            - name: ACCOUNT_EVENT_PUBSUB_TOPIC
+              value: account-events
+            - name: EMAIL_QUEUE_PUBSUB_TOPIC
+              value: send-mail-requests
+            - name: BULK_ACCOUNT_CREATION_PUBSUB_TOPIC
+              value: bulk-account-creation
+            - name: PUBSUB_VERIFICATION_TOKEN
+              value: ${PUBSUB_VERIFICATION_TOKEN}
+            - name: RIGHT_SIGNATURE_WEBHOOK_VALIDATION
+              value: ${RIGHT_SIGNATURE_WEBHOOK_VALIDATION}
+
+            - name: FRONT_END_PROXY_HOST
+              value: ${FRONT_END_PROXY_HOST}
+            - name: ACCOUNT_URL
+              value: ${ACCOUNT_URL}
+            - name: DIGITAL_FACTORY_URL
+              value: ${DIGITAL_FACTORY_URL}
+            - name: REPORT_API_URL
+              value: ${REPORT_API_URL}
+            - name: MARKETPLACE_URL
+              value: ${MARKETPLACE_URL}
+            - name: ULTIMAKER_PROVISIONING_API_URL
+              value: ${ULTIMAKER_PROVISIONING_API_URL}
+            - name: CLOUD_API_URL
+              value: ${CLOUD_API_URL}
+            - name: CONNECT_API_URL
+              value: ${CONNECT_API_URL}
+
+            - name: BUCKET_NAME_BULK_ACCOUNT_CREATION
+              value: ${BUCKET_NAME_BULK_ACCOUNT_CREATION}
+            - name: BUCKET_NAME_TEAM_IMAGES
+              value: ${BUCKET_NAME_TEAM_IMAGES}
+            - name: BUCKET_NAME_PROFILE_IMAGES
+              value: ${BUCKET_NAME_PROFILE_IMAGES}
+            - name: BUCKET_NAME_ORGANIZATION_IMAGES
+              value: ${BUCKET_NAME_ORGANIZATION_IMAGES}
+
+            - name: DEMO_PROJECT_DOCUMENT_URL
+              value: ${DEMO_PROJECT_DOCUMENT_URL}
+            - name: DEMO_PROJECT_IMAGE_URL
+              value: ${DEMO_PROJECT_IMAGE_URL}
+
+            - name: MONGO_CONFIG
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-mongodb
+            - name: ACCOUNT_FEDERATION_SEED
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-account_federation_seed
+            - name: COOKIE_SECRET
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-cookie_secret
+            - name: JWT_PRIVATE_KEY
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: jwt-private-key
+            - name: JWT_PUBLIC_KEY
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: jwt-public-key
+            - name: SALESFORCE_CONFIG
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: salesforce-config
+            - name: ZENDESK_CREDENTIALS
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-zendesk_credentials
+            - name: NOTIFICATIONS_API_KEY
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: notifications-account-api-key
+            - name: SUBSCRIPTIONS_API_KEY
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-subscriptions-api-key
+            - name: BETA_FEATURES
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-alpha_features
+            - name: RIGHT_SIGNATURE_TOKEN
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: rightsignature_token
+            - name: MONGO_CONFIGS
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-mongodb-global
+
+          resources:
+            limits:
+              cpu: 1000m
+              memory: 256Mi
diff --git a/.github/services/account-frontend.yaml b/.github/services/account-frontend.yaml
new file mode 100644
index 0000000..d691144
--- /dev/null
+++ b/.github/services/account-frontend.yaml
@@ -0,0 +1,36 @@
+apiVersion: serving.knative.dev/v1
+kind: Service
+metadata:
+  name: account-frontend${SERVICE_SUFFIX}
+  annotations:
+    serving.knative.dev/route: account-frontend${SERVICE_SUFFIX}
+    run.googleapis.com/ingress: ${INGRESS}
+  labels:
+    service-name: account-frontend
+
+spec:
+  template:
+    metadata:
+      name: account-frontend${SERVICE_SUFFIX}${REVISION_SUFFIX}
+      annotations:
+        autoscaling.knative.dev/maxScale: '${MAX_SCALE}'
+        autoscaling.knative.dev/minScale: '${MIN_SCALE}'
+        run.googleapis.com/cpu-throttling: 'true'
+        run.googleapis.com/vpc-access-connector: projects/${GCP_PROJECT}/locations/${GCP_REGION}/connectors/um-cloud
+        run.googleapis.com/vpc-access-egress: private-ranges-only
+      labels:
+        service-name: account-frontend
+    spec:
+      containerConcurrency: 512
+      timeoutSeconds: 300
+      serviceAccountName: account@${GCP_PROJECT}.iam.gserviceaccount.com
+      containers:
+        - name: stardust-account-frontend
+          image: ${IMAGE_URL}
+          ports:
+            - name: http1
+              containerPort: 80
+          resources:
+            limits:
+              cpu: 1000m
+              memory: 128Mi
diff --git a/.github/services/account-worker.yaml b/.github/services/account-worker.yaml
new file mode 100644
index 0000000..db750a4
--- /dev/null
+++ b/.github/services/account-worker.yaml
@@ -0,0 +1,115 @@
+apiVersion: serving.knative.dev/v1
+kind: Service
+metadata:
+  name: account-worker${SERVICE_SUFFIX}
+  annotations:
+    serving.knative.dev/route: account-worker-lab
+    run.googleapis.com/ingress: internal
+  labels:
+    service-name: account-worker
+
+spec:
+  template:
+    metadata:
+      name: account-worker${SERVICE_SUFFIX}${REVISION_SUFFIX}
+      annotations:
+        autoscaling.knative.dev/maxScale: '${MAX_SCALE}'
+        autoscaling.knative.dev/minScale: '${MIN_SCALE}'
+        run.googleapis.com/cpu-throttling: 'true'
+        run.googleapis.com/vpc-access-connector: projects/${GCP_PROJECT}/locations/${GCP_REGION}/connectors/um-cloud
+        run.googleapis.com/vpc-access-egress: private-ranges-only
+      labels:
+        service-name: account-worker
+    spec:
+      containerConcurrency: 80
+      timeoutSeconds: 300
+      serviceAccountName: account-worker@${GCP_PROJECT}.iam.gserviceaccount.com
+      containers:
+        - name: stardust-account-worker
+          image: ${IMAGE_URL}
+          args:
+            - --run-listener
+          ports:
+            - name: http1
+              containerPort: 8080
+          env:
+            - name: DATABASE_NAME
+              value: oauth2_server
+            - name: DATABASE_PROTOCOL
+              value: mongodb+srv
+            - name: DATABASE_PARAMETERS
+              value: ?retryWrites=true&w=majority&maxPoolSize=200
+            - name: DATABASE_CONNECTION_TIMEOUT_MS
+              value: "5000"
+            - name: SERVER_SELECTION_TIMEOUT_MS
+              value: "5000"
+            - name: HTTP_CLIENT_MAX_CLIENTS
+              value: '90'
+            - name: TRACING_ENABLED
+              value: 'false'
+            - name: APP_NAMESPACE
+              value: account
+            - name: APP_NAME
+              value: account-worker
+
+            - name: ACCOUNT_TOTP_ISSUER
+              value: ${ACCOUNT_TOTP_ISSUER}
+            - name: ACCOUNT_TOKEN_ISSUER
+              value: ${ACCOUNT_TOKEN_ISSUER}
+
+            - name: ACCOUNT_EVENT_PUBSUB_TOPIC
+              value: account-events
+            - name: EMAIL_QUEUE_PUBSUB_TOPIC
+              value: send-mail-requests
+            - name: BULK_ACCOUNT_CREATION_PUBSUB_TOPIC
+              value: bulk-account-creation
+            - name: PUBSUB_VERIFICATION_TOKEN
+              value: ${PUBSUB_VERIFICATION_TOKEN}
+
+            - name: DIGITAL_FACTORY_URL
+              value: ${DIGITAL_FACTORY_URL}
+            - name: REPORT_API_URL
+              value: ${REPORT_API_URL}
+            - name: MARKETPLACE_URL
+              value: ${MARKETPLACE_URL}
+            - name: ACCOUNT_URL
+              value: ${ACCOUNT_URL}
+            - name: ULTIMAKER_PROVISIONING_API_URL
+              value: ${ULTIMAKER_PROVISIONING_API_URL}
+            - name: SUBSCRIPTIONS_API_KEY
+              value: ${SUBSCRIPTIONS_API_KEY}
+
+            - name: BUCKET_NAME_BULK_ACCOUNT_CREATION
+              value: ${BUCKET_NAME_BULK_ACCOUNT_CREATION}
+            - name: BUCKET_NAME_TEAM_IMAGES
+              value: ${BUCKET_NAME_TEAM_IMAGES}
+            - name: BUCKET_NAME_PROFILE_IMAGES
+              value: ${BUCKET_NAME_PROFILE_IMAGES}
+            - name: BUCKET_NAME_ORGANIZATION_IMAGES
+              value: ${BUCKET_NAME_ORGANIZATION_IMAGES}
+
+            - name: MONGO_CONFIG
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-worker-mongodb
+            - name: JWT_PUBLIC_KEY
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: jwt-public-key
+            - name: SENDGRID_API_KEY
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: sendgrid_api_key
+            - name: MONGO_CONFIGS
+              valueFrom:
+                secretKeyRef:
+                  key: latest
+                  name: account-mongodb-global
+
+          resources:
+            limits:
+              cpu: 1000m
+              memory: 256Mi
diff --git a/.github/services/lab.env b/.github/services/lab.env
new file mode 100644
index 0000000..ae4188e
--- /dev/null
+++ b/.github/services/lab.env
@@ -0,0 +1,26 @@
+MAX_SCALE=1
+MIN_SCALE=0
+INGRESS=all
+
+ACCOUNT_TOTP_ISSUER="Ultimaker Account (lab)"
+ACCOUNT_TOKEN_ISSUER=staging.Ultimaker.com
+
+PUBSUB_VERIFICATION_TOKEN=pcgMl2XOqz0KVvDcjoH6c9agqfGBcGNg
+RIGHT_SIGNATURE_WEBHOOK_VALIDATION=NoUTrlYCx32Pxc-j6Qkg9DOCBfVsw4e4T1vC34FJHOHU
+SUBSCRIPTIONS_API_KEY="fe41ece07a8b538db56bb509e19c408d06972c0593005ca04a62118b588363838ae4978a907430c0"
+
+ACCOUNT_URL=https://account-staging.ultimaker.com
+REPORT_API_URL=https://api-staging.ultimaker.com/report/v1
+DIGITAL_FACTORY_URL=https://digitalfactory-staging.ultimaker.com
+ULTIMAKER_PROVISIONING_API_URL="https://subscription-service-staging.ultimaker.com"
+MARKETPLACE_URL=https://marketplace-staging.ultimaker.com
+CLOUD_API_URL=https://api-staging.ultimaker.com/cura/v1
+CONNECT_API_URL=https://api-staging.ultimaker.com/connect/v1
+
+BUCKET_NAME_BULK_ACCOUNT_CREATION='{"main": "um-cloud-staging-account-bulk-account-creation", "us-edu": "um-cloud-staging-us-edu-account-bulk-account-creation"}'
+BUCKET_NAME_TEAM_IMAGES='{"main": "um-cloud-staging-team-images", "us-edu": "um-cloud-staging-es-edu-team-images"}'
+BUCKET_NAME_PROFILE_IMAGES='{"main": "um-cloud-staging-organization-images", "us-edu": "um-cloud-staging-us-edu-organization-images"}'
+BUCKET_NAME_ORGANIZATION_IMAGES='{"main": "um-cloud-staging-organization-images", "us-edu": "um-cloud-staging-us-edu-organization-images"}'
+
+DEMO_PROJECT_DOCUMENT_URL="https://digitalfactory-cdn.ultimaker.com/example-project/Project_Instructions_-_Build_a_Cell_City.pdf"
+DEMO_PROJECT_IMAGE_URL="https://digitalfactory-cdn.ultimaker.com/example-project/cell_1.png"
diff --git a/.github/services/production.env b/.github/services/production.env
new file mode 100644
index 0000000..14b14aa
--- /dev/null
+++ b/.github/services/production.env
@@ -0,0 +1,25 @@
+MAX_SCALE=500
+MIN_SCALE=1
+INGRESS=internal-and-cloud-load-balancing
+
+ACCOUNT_TOTP_ISSUER="Ultimaker Account"
+ACCOUNT_TOKEN_ISSUER=Ultimaker.com
+
+PUBSUB_VERIFICATION_TOKEN=3T18rqjDlPwoKZSw2dpGpfqlabr86GsL
+RIGHT_SIGNATURE_WEBHOOK_VALIDATION=F1dSDICcQC3ZALK-VXnJjjxfwvU34Y4xY5AjSyKl0ErY
+
+ACCOUNT_URL=https://account.ultimaker.com
+REPORT_API_URL=https://api.ultimaker.com/report/v1
+DIGITAL_FACTORY_URL=https://digitalfactory.ultimaker.com
+ULTIMAKER_PROVISIONING_API_URL=https://subscription-service.ultimaker.com
+MARKETPLACE_URL=https://marketplace.ultimaker.com
+CLOUD_API_URL=https://api.ultimaker.com/cura/v1
+CONNECT_API_URL=https://api.ultimaker.com/connect/v1
+
+BUCKET_NAME_BULK_ACCOUNT_CREATION=um-cloud-production-account-bulk-account-creation
+BUCKET_NAME_TEAM_IMAGES=um-cloud-production-team-images
+BUCKET_NAME_PROFILE_IMAGES=um-cloud-production-account-images
+BUCKET_NAME_ORGANIZATION_IMAGES=um-cloud-production-organization-images
+
+DEMO_PROJECT_DOCUMENT_URL="https://digitalfactory-cdn.ultimaker.com/example-project/Project_Instructions_-_Build_a_Cell_City.pdf"
+DEMO_PROJECT_IMAGE_URL="https://digitalfactory-cdn.ultimaker.com/example-project/cell_1.png"
diff --git a/.github/services/staging.env b/.github/services/staging.env
new file mode 100644
index 0000000..a23251e
--- /dev/null
+++ b/.github/services/staging.env
@@ -0,0 +1,25 @@
+MAX_SCALE=2
+MIN_SCALE=1
+INGRESS=internal-and-cloud-load-balancing
+
+ACCOUNT_TOTP_ISSUER="Ultimaker Account (staging)"
+ACCOUNT_TOKEN_ISSUER=staging.Ultimaker.com
+
+PUBSUB_VERIFICATION_TOKEN=pcgMl2XOqz0KVvDcjoH6c9agqfGBcGNg
+RIGHT_SIGNATURE_WEBHOOK_VALIDATION=z0BFnfa1yg-XBtxHQ55Fi3ZVRxtlkeTg4T9Z9i7GlPHI
+
+ACCOUNT_URL=https://account-staging.ultimaker.com
+REPORT_API_URL=https://api-staging.ultimaker.com/report/v1
+DIGITAL_FACTORY_URL=https://digitalfactory-staging.ultimaker.com
+ULTIMAKER_PROVISIONING_API_URL=https://subscription-service-staging.ultimaker.com
+MARKETPLACE_URL=https://marketplace-staging.ultimaker.com
+CLOUD_API_URL=https://api-staging.ultimaker.com/cura/v1
+CONNECT_API_URL=https://api-staging.ultimaker.com/connect/v1
+
+BUCKET_NAME_BULK_ACCOUNT_CREATION=um-cloud-staging-account-bulk-account-creation
+BUCKET_NAME_TEAM_IMAGES=um-cloud-staging-team-images
+BUCKET_NAME_PROFILE_IMAGES=um-cloud-staging-account-images
+BUCKET_NAME_ORGANIZATION_IMAGES=um-cloud-staging-organization-images
+
+DEMO_PROJECT_DOCUMENT_URL="https://digitalfactory-cdn.ultimaker.com/example-project/Project_Instructions_-_Build_a_Cell_City.pdf"
+DEMO_PROJECT_IMAGE_URL="https://digitalfactory-cdn.ultimaker.com/example-project/cell_1.png"
diff --git a/.github/workflows/build.yaml b/.github/workflows/build.yaml
new file mode 100644
index 0000000..b5d39f8
--- /dev/null
+++ b/.github/workflows/build.yaml
@@ -0,0 +1,52 @@
+name: Build
+
+on:
+  push:
+
+permissions:
+  contents: read
+  packages: read
+  id-token: write
+  pull-requests: read  # for check-pr-labels
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        service:
+          - frontend
+          - backend
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+          token: ${{ secrets.NPM_GITHUB_TOKEN }}
+          fetch-depth: 0
+      - name: Google Auth
+        uses: google-github-actions/auth@v2
+        with:
+          workload_identity_provider: ${{ vars.INFRA_WI_PROVIDER }}
+      - name: Use gcloud auth for Docker
+        run: gcloud auth configure-docker europe-west4-docker.pkg.dev
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v5
+        with:
+          images: europe-west4-docker.pkg.dev/um-cloud-infra/stardust/account-${{ matrix.service }}
+          tags: |
+            type=sha
+            type=raw,value=latest,enable=${{github.ref == 'refs/heads/main' }}
+            type=raw,value=staging,enable=${{github.ref == 'refs/heads/staging' }}
+      - name: Build and push
+        uses: docker/build-push-action@v5
+        with:
+          platforms: linux/amd64
+          context: ./${{ matrix.service }}
+          target: release
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          secrets: |
+            "github_token=${{ secrets.GITHUB_TOKEN }}"
diff --git a/.github/workflows/combine.yaml b/.github/workflows/combine.yaml
new file mode 100644
index 0000000..50d898b
--- /dev/null
+++ b/.github/workflows/combine.yaml
@@ -0,0 +1,8 @@
+---
+name: "Combine Dependabot PRs"
+on:
+  workflow_dispatch:  # can be run manually via github actions
+
+jobs:
+  combine-prs:
+    uses: Ultimaker/stardust-workflows/.github/workflows/services-combine.yaml@master
diff --git a/.github/workflows/dependabot.yaml b/.github/workflows/dependabot.yaml
new file mode 100644
index 0000000..8a8d864
--- /dev/null
+++ b/.github/workflows/dependabot.yaml
@@ -0,0 +1,15 @@
+---
+name: Dependabot
+on:
+  pull_request:
+    types: [opened, synchronize, reopened, labeled, unlabeled]
+    branches-ignore:
+    - main
+
+permissions:
+  # Needed for Workload Identity
+  id-token: write
+
+jobs:
+  dependabot_auto_merge:
+    uses: Ultimaker/stardust-workflows/.github/workflows/dependabot.yaml@master
diff --git a/.github/workflows/deploy.yaml b/.github/workflows/deploy.yaml
new file mode 100644
index 0000000..4fdefe2
--- /dev/null
+++ b/.github/workflows/deploy.yaml
@@ -0,0 +1,53 @@
+name: Deploy
+
+on:
+  workflow_run:
+    workflows:
+      - Build
+    branches:
+      - staging
+      - main
+    types:
+      - completed
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: read
+    environment: ${{ github.event.workflow_run.head_branch == 'main' && 'production' || 'staging' }}
+    strategy:
+      matrix:
+        service:
+          - frontend
+          - api
+          - worker
+        region:
+          - short: eu
+            full: europe-west1
+          - short: us
+            full: us-east1
+        include:
+          - service: worker
+            region:
+              short: us-geo
+              full: us-east1
+    name: Deploy ${{ matrix.service }} (${{ matrix.region.short }})
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+      - uses: google-github-actions/auth@v2
+        with:
+          workload_identity_provider: ${{ vars.INFRA_WI_PROVIDER }}
+      - name: Create YAML from Helm
+        run: |
+          curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
+          cd helm
+          helm template cloudrun -s templates/${{ matrix.service }}.yaml -f values-${{ vars.ENV_NAME }}.yaml -f values-${{ matrix.region.short }}.yaml --set gitSHA=${{ github.sha }} --set imageTag=${{ vars.ENV_NAME == 'production' && 'latest' || 'staging' }} . > ../deployment.yaml
+      - name: Deploy to Cloud Run
+        uses: google-github-actions/deploy-cloudrun@v2
+        with:
+          project_id: ${{ vars.GCP_PROJECT_ID }}
+          region: ${{ matrix.region.full }}
+          metadata: deployment.yaml
diff --git a/.github/workflows/lab-delete.yaml b/.github/workflows/lab-delete.yaml
new file mode 100644
index 0000000..c2593d9
--- /dev/null
+++ b/.github/workflows/lab-delete.yaml
@@ -0,0 +1,33 @@
+---
+name: Delete lab
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+  packages: write
+  id-token: write
+
+jobs:
+  delete-lab:
+    name: Delete ${{ matrix.service }}
+    strategy:
+      fail-fast: false
+      matrix:
+        service:
+          - account-api
+          - account-worker
+          - account-frontend
+        include:
+          - service: account-api
+            share-url: true
+          - service: account-worker
+            share-url: false
+          - service: account-frontend
+            share-url: false
+    uses: Ultimaker/stardust-workflows/.github/workflows/lab-delete.yaml@master
+    with:
+      service: ${{ matrix.service }}
+      share-url: ${{ matrix.share-url }}
+    secrets: inherit
diff --git a/.github/workflows/lab-deploy.yaml b/.github/workflows/lab-deploy.yaml
new file mode 100644
index 0000000..50c81bc
--- /dev/null
+++ b/.github/workflows/lab-deploy.yaml
@@ -0,0 +1,40 @@
+---
+name: Lab Deployment
+
+on:
+  workflow_call:
+
+permissions:
+  contents: read
+  packages: write
+  id-token: write
+
+jobs:
+  deploy-lab:
+    name: Deploy ${{ matrix.service }}
+    strategy:
+      fail-fast: false
+      matrix:
+        service:
+          - account-api
+          - account-worker
+          - account-frontend
+        include:
+          - service: account-api
+            image-name: account-backend
+            share-url: true
+          - service: account-worker
+            image-name: account-backend
+            share-url: false
+          - service: account-frontend
+            image-name: account-frontend
+            share-url: false
+    uses: Ultimaker/stardust-workflows/.github/workflows/lab-deploy.yaml@master
+    with:
+      image-name: ${{ matrix.image-name }}
+      service: ${{ matrix.service }}
+      share-url: ${{ matrix.share-url }}
+      app-name: account
+      app-url: https://account-api-${{ github.event.pull_request.number }}-ec3feeu5ma-ew.a.run.app
+      front-end-proxy-host: https://account-frontend-${{ github.event.pull_request.number }}-ec3feeu5ma-ew.a.run.app
+    secrets: inherit
diff --git a/.github/workflows/pull-request.yaml b/.github/workflows/pull-request.yaml
new file mode 100644
index 0000000..24849d1
--- /dev/null
+++ b/.github/workflows/pull-request.yaml
@@ -0,0 +1,80 @@
+---
+name: Pull Request
+
+on:
+  pull_request:
+    types: [ opened, synchronize, reopened, labeled, unlabeled, closed ]
+
+permissions:
+  contents: read
+  packages: write
+  id-token: write
+  pull-requests: read  # for check-pr-labels
+
+jobs:
+  ref-check:
+    name: Submodule ref check
+    uses: Ultimaker/stardust-workflows/.github/workflows/submodule-ref-check.yaml@master
+    secrets: inherit
+
+  # run deployment when labeled or when PR with label is changed
+  deploy-lab:
+    if: |
+      (github.event.action == 'labeled' && github.event.label.name == 'LAB_ENV') ||
+      (contains('opened synchronize reopened', github.event.action) && contains(github.event.pull_request.labels.*.name, 'LAB_ENV'))
+    name: Deploy lab
+    uses: ./.github/workflows/lab-deploy.yaml
+    secrets: inherit
+
+  # remove deployment when label is removed or PR is closed
+  delete-lab:
+    name: Delete lab
+    if: (github.event.action == 'unlabeled' && github.event.label.name == 'LAB_ENV') || github.event.action == 'closed'
+    uses: ./.github/workflows/lab-delete.yaml
+    secrets: inherit
+
+  # Add list of PRs included to the production PR
+  comment-main-pr:
+    runs-on: ubuntu-latest
+    if: github.event.pull_request.base.ref == 'main' && github.event.action == 'opened'
+    name: Comment on main PR
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          submodules: true
+          token: ${{ secrets.NPM_GITHUB_TOKEN }}
+          fetch-depth: 0
+      - name: Compose message
+        id: compose-message
+        run: |
+          # Write a list of PRs
+          echo "This PR includes the following PRs:" | tee message.txt
+          git log origin/${{github.event.pull_request.base.ref}}.. | grep -e '#[0-9]\+' -o | sed 's/^/- /' | tee --append message.txt
+
+          # Retrieve the JSON specs
+          curl https://account.ultimaker.com/spec --output production-spec.json --no-progress-meter
+          curl https://account-staging.ultimaker.com/spec --output staging-spec.json --no-progress-meter
+
+          # Compare the specs and write them in a code block (```diff ... ```)
+          echo -e "\nThe following changes were made to the API in staging:\n\`\`\`diff" | tee --append message.txt
+          diff <(jq --sort-keys . production-spec.json) <(jq --sort-keys . staging-spec.json) | tee --append message.txt
+          echo -e "\`\`\`\n" | tee --append message.txt
+
+          # Multiline string in GitHub output is just ugly!
+          DELIMITER=$(openssl rand -hex 12)
+          echo "message<<$DELIMITER" >> $GITHUB_OUTPUT
+          cat message.txt | head -c 2500 >> $GITHUB_OUTPUT  # slack messages are max 3k characters
+          echo "$DELIMITER" >> $GITHUB_OUTPUT
+      - name: Comment on main PR
+        uses: actions/github-script@v6
+        continue-on-error: true
+        with:
+          github-token: ${{ secrets.NPM_GITHUB_TOKEN }}
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: ${{ toJSON(steps.compose-message.outputs.message) }}
+            })
diff --git a/.github/workflows/test.yaml b/.github/workflows/test.yaml
new file mode 100644
index 0000000..c15d783
--- /dev/null
+++ b/.github/workflows/test.yaml
@@ -0,0 +1,69 @@
+name: Test
+
+on:
+  push:
+
+permissions:
+  contents: read
+  packages: read
+  id-token: write
+  pull-requests: read # for check-pr-labels
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - service: frontend
+            command: lint
+          - service: frontend
+            command: test
+          - service: backend
+            command: coverage
+          - service: backend
+            command: styling
+          - service: backend
+            command: lint
+    name: Test ${{ matrix.service }} (${{ matrix.command }})
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+          token: ${{ secrets.NPM_GITHUB_TOKEN }} # This needs a better solution
+          fetch-depth: 0
+      - name: Build tests
+        uses: docker/build-push-action@v4
+        with:
+          context: ${{ matrix.service }}
+          target: tests
+          push: false
+          tags: account-${{ matrix.service }}-tests
+          # cache-from: type=gha
+          # cache-to: type=gha,mode=max
+          secrets: |
+            "github_token=${{ secrets.GITHUB_TOKEN }}"
+      - name: Test ${{ matrix.service }}
+        run: docker compose -f docker-compose-test.yaml run -e FORCE_COLOR=1 ${{ matrix.service }}-${{ matrix.command }}
+  cypress:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./frontend
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          cache: 'npm'
+          node-version-file: 'frontend/.nvmrc'
+          cache-dependency-path: 'frontend/package-lock.json'
+      - name: Cypress run
+        uses: cypress-io/github-action@v6
+        with:
+          working-directory: frontend
+          start: npm start
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
\ No newline at end of file
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
new file mode 100644
index 0000000..2ae4537
--- /dev/null
+++ b/.pre-commit-config.yaml
@@ -0,0 +1,66 @@
+# pre-commit configuration for CuraFormulaeEngine
+default_stages: [commit]
+
+repos:
+  - repo: https://github.com/thoughtworks/talisman
+    rev: v1.32.0
+    hooks:
+      - id: talisman-commit
+
+  - repo: local
+    hooks:
+      - id: check-yaml
+        name: Check YAML Syntax
+        entry: |-
+          bash -c 'if [ "$SKIP_PRE_COMMIT" = "1" ]; then exit 0; fi; exec python3 -c "
+          import sys
+          try:
+              import yaml
+              [yaml.safe_load(open(f)) for f in sys.argv[1:]]
+          except ImportError:
+              print(\"WARNING: PyYAML not found. Skipping YAML syntax check.\")
+          " "$@"' --
+        language: system
+        files: \.(yaml|yml)$
+
+      - id: check-json
+        name: Check JSON Syntax
+        entry: >-
+          bash -c 'if [ "$SKIP_PRE_COMMIT" = "1" ]; then exit 0; fi; exec python3 -c "import json, sys; [json.load(open(f)) for f in sys.argv[1:]]" "$@"' --
+        language: system
+        files: \.json$
+
+      - id: check-agent-artifacts
+        name: Check for Agent Artifacts
+        entry: >-
+          bash -c 'if [ "$SKIP_PRE_COMMIT" = "1" ]; then exit 0; fi; for f in "$@"; do if [[ "$f" =~ (task(_.*)?\.md|task\..*|implementation_plan(_.*)?\.md|implementation_plan\..*|walkthrough(_.*)?\.md|walkthrough\..*|\.playwright-cli|__pycache__|scratch_.*|scratch\..*|temp_.*|temp\..*|test_scratch_.*|test_scratch\..*|test_agent_.*|test_agent\..*|test_temp_.*|test_temp\..*|test_run_.*|test_run\..*|test_debug_.*|test_debug\..*|test_mock_.*|test_mock\..*|test_quick_.*|test_quick\..*|test_sandbox_.*|test_sandbox\..*|test_test_.*|test_test\..*|^test_[^/]+\.(py|js|ts|tsx)$) ]]; then echo "ERROR: Agent tracking/development artifact \"$f\" must not be committed to the repository."; exit 1; fi; done' --
+        language: system
+
+      - id: clang-format
+        name: Format C++ Code (clang-format)
+        entry: >-
+          bash -c 'if [ "$SKIP_PRE_COMMIT" = "1" ]; then exit 0; fi; if ! command -v clang-format &>/dev/null; then echo "WARNING: clang-format not found. Skipping formatting."; exit 0; fi; exec clang-format -i "$@"' --
+        language: system
+        files: \.(cpp|h|hpp)$
+
+      - id: cppcheck
+        name: Fast Static Analysis (cppcheck)
+        entry: >-
+          bash -c 'if [ "$SKIP_PRE_COMMIT" = "1" ]; then exit 0; fi; if ! command -v cppcheck &>/dev/null; then echo "WARNING: cppcheck not found. Skipping static analysis."; exit 0; fi; exec cppcheck --enable=warning,performance,portability --inline-suppr --suppress=missingIncludeSystem --quiet "$@"' --
+        language: system
+        files: \.(cpp|h|hpp)$
+
+      - id: check-local-paths
+        name: Check for Local Path References
+        entry: >-
+          bash -c 'if [ "$SKIP_PRE_COMMIT" = "1" ]; then exit 0; fi; if [ -n "$HOME" ] && grep -FIn "$HOME" "$@" >/dev/stderr; then echo "ERROR: Staged files contain references to your local home directory ($HOME). Please use relative paths instead."; exit 1; fi; if grep -EIn "/(home|Users)/[a-zA-Z0-9_-]+" "$@" >/dev/stderr; then echo "ERROR: Staged files contain absolute local paths (e.g., /home/USER/ or /Users/USER/). Please use relative paths instead."; exit 1; fi' --
+        language: system
+        files: \.(py|js|jsx|ts|tsx|sh|bash|md|cpp|h|hpp|txt|cmake|yml|yaml)$
+        exclude: ^(\.agents/|\.pre-commit-config\.yaml)
+
+      - id: check-jira-ticket
+        name: Check Jira Ticket in Commit Message
+        entry: >-
+          bash -c 'if [ "$SKIP_PRE_COMMIT" = "1" ]; then exit 0; fi; if ! grep -Ei "(EMB|CES|COL|STYX|UC|NP)-[0-9]+" "$1" >/dev/null; then echo "ERROR: Commit message must reference a valid Jira ticket from authorized projects (e.g., EMB-XXXX, CES-XXXX, COL-XXXX, STYX-XXXX, UC-XXXX, NP-XXXX)."; exit 1; fi' --
+        language: system
+        stages: [commit-msg]
diff --git a/.talismanrc b/.talismanrc
new file mode 100644
index 0000000..787a22a
--- /dev/null
+++ b/.talismanrc
@@ -0,0 +1,42 @@
+fileignoreconfig:
+- filename: .github/services/lab.env
+  checksum: c0b8bb3533008b27bc59c6713156b079dfde3c0a7d28cd5d8642876e92bd905a
+- filename: .github/services/production.env
+  checksum: 6723cd733b3d8f6b99096f8a2362d2bc2e828661b76d8338dd432097b80277b1
+- filename: .github/services/staging.env
+  checksum: 5c500ea4e0fdd54d151a34b706333075f6c2ff7acc7d585a76f263658067fc26
+- filename: .github/dependabot.yml
+  checksum: f6f8c58bfaac2bcb17410e314bbb82bd4a50393979671602ca65b1d86da2b1e7
+- filename: .github/copilot-instructions/accessibility-auditor.instructions.md
+  checksum: c40fcf19e1ae5ac15e21046c3f2682ee7381b0f2d68af46e345bdcdc373cc0d9
+- filename: .github/workflows/lab-delete.yaml
+  checksum: b43d0f6190c0f90c567d7dc7d6e30c9c72104b9df246d49912110616ee03bb4a
+- filename: .github/copilot-instructions/testing-automation.instructions.md
+  checksum: d1c4fc9b8579d5a7648e0d3d9076410d97fe25031f558b500b0eccecd258e0da
+- filename: .github/copilot-instructions.md
+  checksum: e81cac7a8100a919eea6a20b8e00119cfa75490a42fe170547b4ae84fe85fc51
+- filename: .github/workflows/lab-deploy.yaml
+  checksum: e11975b55ee53835adb3ca83477d91aad472454172db4059608d957ce2434805
+- filename: .github/copilot-instructions/code-reviewer.instructions.md
+  checksum: 90949bb7f79167b10c12be61fc8293e3deba60dfafa0d72c4bb023ea45c8961f
+- filename: .github/workflows/pull-request.yaml
+  checksum: 65313710db6d09de8e5829f08e13a4b97beb6eb1b5b5f1a249bbc335314c2e35
+- filename: AGENTS.md
+  checksum: df626e44109d3983a5cdaad05aa77198ae5370f988a3147d0b6ff001862e5c13
+- filename: .github/copilot-instructions/pr-assistant.instructions.md
+  checksum: 8cd77d9648f41bed3e8f94ba6101f3854916f82b78c192e9954873e3d7f722bb
+- filename: include/cura-formulae-engine/env/env.h
+  checksum: febbe9de68ac4c916799e8acfd110e4cf06c39e55d9caf141c41c7f026f27c3c
+- filename: src/env/env.cpp
+  checksum: d9abb81fc2de80b80860d32b162b5f85af8a78a924a936bc70ea23801838285e
+- filename: include/cura-formulae-engine/ast/list_comprehension_expr.h
+  checksum: 32c4f101a16b09cc4697dc4bb114cc0a748d1a1ebc105a7192cba176e1eb4747
+- filename: include/cura-formulae-engine/ast/ast.h
+  checksum: a908dee2c0fee05b590ddb5979e9dbec705e8ceb637ea716ecfbfd95b2b389bd
+- filename: include/cura-formulae-engine/parser/list_comprehension_grammar.h
+  checksum: e2bb8cfc059b937e0f0d5f9aee443abd11d279b8e1dfa5ece1ced01fe999d765
+- filename: src/ast/ast.cpp
+  checksum: 05891e1f28a93f03def4b7d88d52d37941345d0788ae417824039fccae67a394
+- filename: src/ast/list_comprehension_expr.cpp
+  checksum: b840dd7ae2474eaaf010b858c19e721b06bf0938ea1673e245983d335d2d2297
+version: ""
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..525dd8d
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,130 @@
+# Agent Operational & Onboarding Guide (AGENTS.md)
+
+Welcome, AI Agent! This document defines the operational boundaries, design patterns, testing strategies, and collaborative conventions for the `CuraFormulaeEngine` repository.
+
+As a dynamic assistant, you must adhere strictly to these principles to maintain codebase sanity and ensure future developers can build upon your work efficiently.
+
+---
+
+## 1. SaaS Context, Sibling Services & AI Skill Discovery
+
+### CuraFormulaeEngine Context
+
+**CuraFormulaeEngine** is a high-performance C++ mathematical expression parsing and evaluation engine. It is designed to safely parse and resolve Python-like setting dependency expressions for Cura/NeoPrep 3D printing configurations.
+
+- **Formula Resolution**: Safely parses and evaluates algebraic, conditional, and boolean dependency formulas (e.g. `min_layer_time if min_layer_time > 0 else 0`).
+- **WASM compilation**: Integrates via submodules/WASM inside **Curator** to supply settings resolvers with dynamic evaluation routines running in-browser.
+- **Architectural Boundaries**: Completely stateless and purely computational. It handles no PII or network connectivity.
+
+### Sibling Services & Relative Paths
+
+To collaborate on cross-repository features or platform emulation, locate and link with sibling services in this local workspace. Use the following relative paths and consult their corresponding `AGENTS.md` operational guides:
+
+- **[Curator](../Curator/)**: The settings resolver layer consuming this math engine.
+- **[neoprep](../neoprep/audit-stardust-atlas-submodules/)**: The interactive React 3D prep workspace.
+- **[stardust-atlas](../stardust-atlas/audit-stardust-atlas-submodules/)**: Meta-repository and orchestration layer compiling the full Digital Factory stack.
+
+### 🔍 Dynamic AI Skill Discovery & Installation
+
+To obtain expert domain knowledge and specific runtime tools, agents **must** dynamically discover and install specialized engineering skills from `Ultimaker/UltiCortex` on branch `UC-3695_improve_code_base_for_agentic_development`:
+
+```bash
+# Discover and install specialized skills
+gh skill install Ultimaker/UltiCortex ultimaker-curator-development --branch UC-3695_improve_code_base_for_agentic_development
+gh skill install Ultimaker/UltiCortex ultimaker-neoprep-development --branch UC-3695_improve_code_base_for_agentic_development
+```
+
+---
+
+## 2. Work Tracking, Git & Pull Request Habits
+
+- **Jira Tracking**: All changes require an active Jira ticket starting with project key **`UC`** or **`NP`** (e.g., `UC-3697` or `NP-1325`). Branch names must be formatted as `[PROJECT_KEY]-[ID]_description`.
+- **Git Commit Standards**:
+  - **Bracketed Ticket Prefix**: Every Git commit title and GitHub Pull Request title **MUST** start with the active branch's Jira ticket key in bracketed format: `[PROJECT-KEY] <Description>`. For example: `[UC-3697] <Description>`.
+  - **No Semantic Prefixes**: Do **NOT** use conventional/semantic commit prefix tags (such as `feat:`, `fix:`, `chore:`, etc.) in commit titles or Pull Request titles.
+  - Commit message format:
+
+    ```
+    [UC-3697] Configure pre-commit and agentic enablement
+
+    Setup pre-commit hooks and custom copilot instructions for CuraFormulaeEngine development.
+
+    Contributes to UC-3697
+    ```
+
+- **PR Guidelines**:
+  - Always open PRs as **DRAFT** state. Merging is **strictly restricted to humans**.
+  - Monitor CI status checks. Ensure build, linter, formatting, and unit tests pass cleanly.
+
+---
+
+## 3. Directory Organization & Architecture Index
+
+### Core Directory Maps:
+
+- `/src/`: C++ parsing, AST nodes, environment bindings, and evaluation source files.
+- `/include/`: Public C++ headers exposing parser and AST interface.
+- `/tests/`: GoogleTest C++ unit testing suites.
+- `/apps/`: Simple command-line tool testing utilities.
+- `CMakeLists.txt` & `conanfile.py`: Compilation and package dependency manager configurations.
+
+---
+
+## 4. Deep Dive: Core Technical Architectures
+
+### 4.1. Formula Parser and AST Nodes
+
+- **AST Evaluation**: Formulas are compiled into an Abstract Syntax Tree (AST) representing operands, operators, and conditional logic.
+- **Reference Resolution**: Setting variables are resolved by looking up context bindings during tree traversal.
+- **Exception Safety**: Invalid syntax or division-by-zero is handled gracefully without crashing the executor thread.
+
+---
+
+## 5. Local Setup & Verification
+
+### 🚀 Quick Start
+
+1. Install dependencies and compile using Conan & CMake:
+   ```bash
+   conan install . --build=missing --update
+   source build/Release/generators/conanbuild.sh
+   cmake --preset conan-release
+   cmake --build --preset conan-release
+   ```
+
+---
+
+## 6. Quality Control, Tooling & Local Verification
+
+To maintain top-tier reliability, CuraFormulaeEngine enforces comprehensive Quality Control (QC) tools locally. Succeeding agents and developers **must** run and verify these tools before proposing any Pull Request:
+
+### 🎨 Formatting (clang-format)
+
+Check and write clean, standardized formatting across C++ code:
+
+- **Verification & Auto-fix**: `clang-format -i $(find src include tests -name '*.cpp' -o -name '*.h' -o -name '*.hpp')`
+
+### 🧹 Linting & Static Analysis (cppcheck)
+
+Enforce code quality and memory safety:
+
+- **cppcheck**: Fast static analysis for performance and portability issues:
+  ```bash
+  cppcheck --enable=warning,performance,portability --inline-suppr src/ include/
+  ```
+
+### 🧪 Automated Unit Testing (GoogleTest)
+
+Validate math evaluation precision:
+
+- **Run C++ Unit Tests**: `ctest` inside build directory.
+
+### ⚓ Pre-commit Hook Integration
+
+Pre-commit hooks automatically execute fast checks (clang-format, cppcheck, check-yaml, check-json, talisman, local path blocking, and agent artifact checks) on staged files.
+
+- **Manual Hook Audit**:
+  ```bash
+  pre-commit run --all-files
+  ```
+- **Opt-Out (Humans Only)**: Humans may prepend `SKIP_PRE_COMMIT=1` or run `git commit --no-verify`. AI agents **MUST** pass all pre-commit hooks cleanly.
diff --git a/apps/cmdline_parser/cmdline_parser.cpp b/apps/cmdline_parser/cmdline_parser.cpp
index 66e4070..e066d33 100644
--- a/apps/cmdline_parser/cmdline_parser.cpp
+++ b/apps/cmdline_parser/cmdline_parser.cpp
@@ -5,42 +5,37 @@
 #include <string>
 #include <string_view>
 
-int main(int argc, const char** argv)
-{
-    spdlog::set_level(spdlog::level::info);
-    spdlog::info("Formula REPL, type 'exit' to quit.");
-
-    while (true)
-    {
-        std::cout << "> ";
-        std::string command;
-        std::getline(std::cin, command);
-        if (command == "exit")
-        {
-            break;
-        }
-
-        const auto input = std::string_view(command.begin(), command.end());
-        auto message = CuraFormulaeEngine::parser::parse(input);
-
-        if (!message.has_value())
-        {
-            spdlog::warn("Failed to parse input.");
-            continue;
-        }
-
-        const auto& expr = message.value();
-        const auto eval_result = expr.evaluate(&CuraFormulaeEngine::env::std_env);
-
-        if (!eval_result.has_value())
-        {
-            spdlog::warn("Expr {} results in eval error", expr.toString());
-            continue;
-        }
-
-        const auto& eval = eval_result.value();
-        spdlog::info("{} = {}", expr.toString(), eval.toString());
+int main(int argc, const char **argv) {
+  spdlog::set_level(spdlog::level::info);
+  spdlog::info("Formula REPL, type 'exit' to quit.");
+
+  while (true) {
+    std::cout << "> ";
+    std::string command;
+    std::getline(std::cin, command);
+    if (command == "exit") {
+      break;
     }
 
-    return 0;
+    const auto input = std::string_view(command.begin(), command.end());
+    auto message = CuraFormulaeEngine::parser::parse(input);
+
+    if (!message.has_value()) {
+      spdlog::warn("Failed to parse input.");
+      continue;
+    }
+
+    const auto &expr = message.value();
+    const auto eval_result = expr.evaluate(&CuraFormulaeEngine::env::std_env);
+
+    if (!eval_result.has_value()) {
+      spdlog::warn("Expr {} results in eval error", expr.toString());
+      continue;
+    }
+
+    const auto &eval = eval_result.value();
+    spdlog::info("{} = {}", expr.toString(), eval.toString());
+  }
+
+  return 0;
 }
diff --git a/include/cura-formulae-engine/ast/ast.h b/include/cura-formulae-engine/ast/ast.h
index 64735a1..d875e45 100644
--- a/include/cura-formulae-engine/ast/ast.h
+++ b/include/cura-formulae-engine/ast/ast.h
@@ -8,8 +8,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::eval
-{
+namespace CuraFormulaeEngine::eval {
 
 enum class Error;
 
@@ -19,146 +18,146 @@ using Result = zeus::expected<Value, Error>;
 
 } // namespace CuraFormulaeEngine::eval
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-class Environment
-{
+class Environment {
 public:
-    virtual ~Environment() = default;
+  virtual ~Environment() = default;
 
-    [[nodiscard]] virtual std::optional<eval::Value> get(const std::string& key) const = 0;
-    [[nodiscard]] virtual bool has(const std::string& key) const = 0;
-    [[nodiscard]] virtual std::unordered_map<std::string, eval::Value> getAll() const = 0;
+  [[nodiscard]] virtual std::optional<eval::Value>
+  get(const std::string &key) const = 0;
+  [[nodiscard]] virtual bool has(const std::string &key) const = 0;
+  [[nodiscard]] virtual std::unordered_map<std::string, eval::Value>
+  getAll() const = 0;
 };
 
-class EnvironmentMap : public Environment
-{
+class EnvironmentMap : public Environment {
 private:
-    std::unordered_map<std::string, eval::Value> environment_ = {};
+  std::unordered_map<std::string, eval::Value> environment_ = {};
 
 public:
-    EnvironmentMap() = default;
-    explicit EnvironmentMap(const std::unordered_map<std::string, eval::Value>& map)
-        : environment_(map)
-    {
-    }
-    ~EnvironmentMap() override = default;
+  EnvironmentMap() = default;
+  explicit EnvironmentMap(
+      const std::unordered_map<std::string, eval::Value> &map)
+      : environment_(map) {}
+  ~EnvironmentMap() override = default;
 
-    [[nodiscard]] std::optional<eval::Value> get(const std::string& key) const noexcept override;
+  [[nodiscard]] std::optional<eval::Value>
+  get(const std::string &key) const noexcept override;
 
-    [[nodiscard]] bool has(const std::string& key) const noexcept override;
+  [[nodiscard]] bool has(const std::string &key) const noexcept override;
 
-    [[nodiscard]] std::unordered_map<std::string, eval::Value> getAll() const noexcept override;
+  [[nodiscard]] std::unordered_map<std::string, eval::Value>
+  getAll() const noexcept override;
 
-    bool erase(const std::string& key) noexcept;
+  bool erase(const std::string &key) noexcept;
 
-    void set(const std::string& key, const eval::Value& value) noexcept;
+  void set(const std::string &key, const eval::Value &value) noexcept;
 
-    void add(const std::unordered_map<std::string, eval::Value>& values);
+  void add(const std::unordered_map<std::string, eval::Value> &values);
 
-    [[nodiscard]] EnvironmentMap clone() const noexcept;
+  [[nodiscard]] EnvironmentMap clone() const noexcept;
 };
 
-class ChainableEnvironment : public Environment
-{
+class ChainableEnvironment : public Environment {
 private:
-    const Environment* shadow_environment_{ nullptr };
+  const Environment *shadow_environment_{nullptr};
 
 public:
-    explicit ChainableEnvironment(const Environment* shadow_environment = nullptr)
-        : shadow_environment_(shadow_environment)
-    {
-    }
-    ~ChainableEnvironment() override = default;
+  explicit ChainableEnvironment(const Environment *shadow_environment = nullptr)
+      : shadow_environment_(shadow_environment) {}
+  ~ChainableEnvironment() override = default;
 
-    [[nodiscard]] std::optional<eval::Value> get(const std::string& key) const noexcept override final;
+  [[nodiscard]] std::optional<eval::Value>
+  get(const std::string &key) const noexcept override final;
 
-    [[nodiscard]] bool has(const std::string& key) const noexcept override final;
+  [[nodiscard]] bool has(const std::string &key) const noexcept override final;
 
-    [[nodiscard]] std::unordered_map<std::string, eval::Value> getAll() const noexcept override final;
+  [[nodiscard]] std::unordered_map<std::string, eval::Value>
+  getAll() const noexcept override final;
 
 protected:
-    [[nodiscard]] virtual std::optional<eval::Value> getImpl(const std::string& key) const noexcept = 0;
+  [[nodiscard]] virtual std::optional<eval::Value>
+  getImpl(const std::string &key) const noexcept = 0;
 
-    [[nodiscard]] virtual bool hasImpl(const std::string& key) const noexcept = 0;
+  [[nodiscard]] virtual bool hasImpl(const std::string &key) const noexcept = 0;
 
-    [[nodiscard]] virtual std::unordered_map<std::string, eval::Value> getAllImpl() const noexcept = 0;
+  [[nodiscard]] virtual std::unordered_map<std::string, eval::Value>
+  getAllImpl() const noexcept = 0;
 };
 
-class LocalEnvironment : public ChainableEnvironment
-{
+class LocalEnvironment : public ChainableEnvironment {
 private:
-    EnvironmentMap local_environment_;
+  EnvironmentMap local_environment_;
 
 public:
-    explicit LocalEnvironment(const Environment* shadow_environment = nullptr)
-        : ChainableEnvironment(shadow_environment)
-    {
-    }
-    ~LocalEnvironment() override = default;
+  explicit LocalEnvironment(const Environment *shadow_environment = nullptr)
+      : ChainableEnvironment(shadow_environment) {}
+  ~LocalEnvironment() override = default;
 
-    [[nodiscard]] std::optional<eval::Value> getImpl(const std::string& key) const noexcept override;
+  [[nodiscard]] std::optional<eval::Value>
+  getImpl(const std::string &key) const noexcept override;
 
-    [[nodiscard]] bool hasImpl(const std::string& key) const noexcept override;
+  [[nodiscard]] bool hasImpl(const std::string &key) const noexcept override;
 
-    [[nodiscard]] std::unordered_map<std::string, eval::Value> getAllImpl() const noexcept override;
+  [[nodiscard]] std::unordered_map<std::string, eval::Value>
+  getAllImpl() const noexcept override;
 
-    void set(const std::string& key, const eval::Value& value);
+  void set(const std::string &key, const eval::Value &value);
 
-    void add(const std::unordered_map<std::string, eval::Value>& values);
+  void add(const std::unordered_map<std::string, eval::Value> &values);
 };
 
 } // namespace CuraFormulaeEngine::env
 
-namespace CuraFormulaeEngine::ast
-{
-
-struct Expr
-{
-    Expr() = default;
-    Expr(const Expr&) = default;
-    Expr(Expr&&) = default;
-    Expr& operator=(const Expr&) = default;
-    Expr& operator=(Expr&&) = default;
-    virtual ~Expr() = default;
-
-    /**
-     * @brief Evaluates the expression in the given environment.
-     *
-     * @param environment The environment to evaluate the expression in.
-     * @return eval_result The result of the evaluation.
-     */
-    [[nodiscard]] virtual eval::Result evaluate(const env::Environment* environment) const = 0;
-
-    /**
-     * @brief Returns the set of free variables in the expression.
-     *
-     * @return std::unordered_set<std::string> The set of free variables.
-     */
-    [[nodiscard]] virtual std::unordered_set<std::string> freeVariables() const = 0;
-
-    /**
-     * @brief Returns a string representation of the expression.
-     *
-     * @return std::string The string representation.
-     */
-    [[nodiscard]] virtual std::string toString() const = 0;
-
-    /**
-     * @brief Returns a deep copy of the expression.
-     *
-     * @return true if the expressions are equal, false otherwise.
-     */
-    [[nodiscard]] virtual bool deepEq(const Expr& other) const = 0;
-
-    /**
-     * @brief Traverses the expression tree and applies the visitor function to
-     * each node.
-     *
-     * @param visitor The visitor function to apply to each node.
-     */
-    virtual void visitAll(std::function<void(const Expr&)> visitor) const = 0;
+namespace CuraFormulaeEngine::ast {
+
+struct Expr {
+  Expr() = default;
+  Expr(const Expr &) = default;
+  Expr(Expr &&) = default;
+  Expr &operator=(const Expr &) = default;
+  Expr &operator=(Expr &&) = default;
+  virtual ~Expr() = default;
+
+  /**
+   * @brief Evaluates the expression in the given environment.
+   *
+   * @param environment The environment to evaluate the expression in.
+   * @return eval_result The result of the evaluation.
+   */
+  [[nodiscard]] virtual eval::Result
+  evaluate(const env::Environment *environment) const = 0;
+
+  /**
+   * @brief Returns the set of free variables in the expression.
+   *
+   * @return std::unordered_set<std::string> The set of free variables.
+   */
+  [[nodiscard]] virtual std::unordered_set<std::string>
+  freeVariables() const = 0;
+
+  /**
+   * @brief Returns a string representation of the expression.
+   *
+   * @return std::string The string representation.
+   */
+  [[nodiscard]] virtual std::string toString() const = 0;
+
+  /**
+   * @brief Returns a deep copy of the expression.
+   *
+   * @return true if the expressions are equal, false otherwise.
+   */
+  [[nodiscard]] virtual bool deepEq(const Expr &other) const = 0;
+
+  /**
+   * @brief Traverses the expression tree and applies the visitor function to
+   * each node.
+   *
+   * @param visitor The visitor function to apply to each node.
+   */
+  virtual void visitAll(std::function<void(const Expr &)> visitor) const = 0;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/binary_expr/add_expr.h b/include/cura-formulae-engine/ast/binary_expr/add_expr.h
index 4d1828b..679fb19 100644
--- a/include/cura-formulae-engine/ast/binary_expr/add_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/add_expr.h
@@ -6,18 +6,19 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct AddExpr final : BinaryExpr
-{
-    using BinaryExpr::BinaryExpr;
+struct AddExpr final : BinaryExpr {
+  using BinaryExpr::BinaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept final;
+  eval::Result evaluate(eval::Value &lhs,
+                        eval::Value &rhs) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator+(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator+(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs);
diff --git a/include/cura-formulae-engine/ast/binary_expr/and_expr.h b/include/cura-formulae-engine/ast/binary_expr/and_expr.h
index 42a1775..cf92a77 100644
--- a/include/cura-formulae-engine/ast/binary_expr/and_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/and_expr.h
@@ -6,18 +6,19 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct AndExpr final : BinaryExpr
-{
-    using BinaryExpr::BinaryExpr;
+struct AndExpr final : BinaryExpr {
+  using BinaryExpr::BinaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept final;
+  eval::Result evaluate(eval::Value &lhs,
+                        eval::Value &rhs) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator&&(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator&&(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs);
diff --git a/include/cura-formulae-engine/ast/binary_expr/binary_expr.h b/include/cura-formulae-engine/ast/binary_expr/binary_expr.h
index 0bf0437..aa4289a 100644
--- a/include/cura-formulae-engine/ast/binary_expr/binary_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/binary_expr.h
@@ -4,33 +4,30 @@
 #include "cura-formulae-engine/ast/expr_ptr.h"
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct BinaryExpr : Expr
-{
-    ExprPtr lhs;
-    ExprPtr rhs;
+struct BinaryExpr : Expr {
+  ExprPtr lhs;
+  ExprPtr rhs;
 
-    BinaryExpr(ExprPtr lhs, ExprPtr rhs)
-        : lhs(std::move(lhs))
-        , rhs(std::move(rhs))
-    {
-    }
+  BinaryExpr(ExprPtr lhs, ExprPtr rhs)
+      : lhs(std::move(lhs)), rhs(std::move(rhs)) {}
 
-    [[nodiscard]] virtual std::string getOpIdentifier() const = 0;
+  [[nodiscard]] virtual std::string getOpIdentifier() const = 0;
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    virtual eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const = 0;
+  virtual eval::Result evaluate(eval::Value &lhs, eval::Value &rhs) const = 0;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/binary_expr/div_expr.h b/include/cura-formulae-engine/ast/binary_expr/div_expr.h
index 73cd3f7..546c410 100644
--- a/include/cura-formulae-engine/ast/binary_expr/div_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/div_expr.h
@@ -6,18 +6,19 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct DivExpr final : BinaryExpr
-{
-    using BinaryExpr::BinaryExpr;
+struct DivExpr final : BinaryExpr {
+  using BinaryExpr::BinaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept final;
+  eval::Result evaluate(eval::Value &lhs,
+                        eval::Value &rhs) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator/(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator/(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs);
diff --git a/include/cura-formulae-engine/ast/binary_expr/mod_expr.h b/include/cura-formulae-engine/ast/binary_expr/mod_expr.h
index 0bf4025..a6943aa 100644
--- a/include/cura-formulae-engine/ast/binary_expr/mod_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/mod_expr.h
@@ -6,18 +6,19 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct ModExpr final : BinaryExpr
-{
-    using BinaryExpr::BinaryExpr;
+struct ModExpr final : BinaryExpr {
+  using BinaryExpr::BinaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept final;
+  eval::Result evaluate(eval::Value &lhs,
+                        eval::Value &rhs) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator%(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator%(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs);
diff --git a/include/cura-formulae-engine/ast/binary_expr/mul_expr.h b/include/cura-formulae-engine/ast/binary_expr/mul_expr.h
index 8d64836..f0d134d 100644
--- a/include/cura-formulae-engine/ast/binary_expr/mul_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/mul_expr.h
@@ -6,18 +6,19 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct MulExpr final : BinaryExpr
-{
-    using BinaryExpr::BinaryExpr;
+struct MulExpr final : BinaryExpr {
+  using BinaryExpr::BinaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept final;
+  eval::Result evaluate(eval::Value &lhs,
+                        eval::Value &rhs) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator*(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator*(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs);
diff --git a/include/cura-formulae-engine/ast/binary_expr/or_expr.h b/include/cura-formulae-engine/ast/binary_expr/or_expr.h
index 293f41d..f1e328e 100644
--- a/include/cura-formulae-engine/ast/binary_expr/or_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/or_expr.h
@@ -7,18 +7,19 @@
 #include <string>
 #include <variant>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct OrExpr final : BinaryExpr
-{
-    using BinaryExpr::BinaryExpr;
+struct OrExpr final : BinaryExpr {
+  using BinaryExpr::BinaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept final;
+  eval::Result evaluate(eval::Value &lhs,
+                        eval::Value &rhs) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator||(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator||(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs);
diff --git a/include/cura-formulae-engine/ast/binary_expr/pow_expr.h b/include/cura-formulae-engine/ast/binary_expr/pow_expr.h
index 85d757a..39e65fb 100644
--- a/include/cura-formulae-engine/ast/binary_expr/pow_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/pow_expr.h
@@ -5,16 +5,15 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct PowExpr final : BinaryExpr
-{
-    using BinaryExpr::BinaryExpr;
+struct PowExpr final : BinaryExpr {
+  using BinaryExpr::BinaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept final;
+  eval::Result evaluate(eval::Value &lhs,
+                        eval::Value &rhs) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/binary_expr/sub_expr.h b/include/cura-formulae-engine/ast/binary_expr/sub_expr.h
index 4c8a319..89d9215 100644
--- a/include/cura-formulae-engine/ast/binary_expr/sub_expr.h
+++ b/include/cura-formulae-engine/ast/binary_expr/sub_expr.h
@@ -6,18 +6,19 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct SubExpr final : BinaryExpr
-{
-    using BinaryExpr::BinaryExpr;
+struct SubExpr final : BinaryExpr {
+  using BinaryExpr::BinaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    eval::Result evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept final;
+  eval::Result evaluate(eval::Value &lhs,
+                        eval::Value &rhs) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator-(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator-(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs);
diff --git a/include/cura-formulae-engine/ast/comp_chain_expr.h b/include/cura-formulae-engine/ast/comp_chain_expr.h
index b869e1a..0f6fc3c 100644
--- a/include/cura-formulae-engine/ast/comp_chain_expr.h
+++ b/include/cura-formulae-engine/ast/comp_chain_expr.h
@@ -3,51 +3,60 @@
 #include "cura-formulae-engine/ast/ast.h"
 #include "expr_ptr.h"
 
-namespace CuraFormulaeEngine::ast
-{
-
-enum ComparisonOperators
-{
-    Equals,
-    NotEquals,
-    LessThan,
-    GreaterThan,
-    LessThenEqual,
-    GreaterThenEqual,
-    NotMember,
-    Member,
+namespace CuraFormulaeEngine::ast {
+
+enum ComparisonOperators {
+  Equals,
+  NotEquals,
+  LessThan,
+  GreaterThan,
+  LessThenEqual,
+  GreaterThenEqual,
+  NotMember,
+  Member,
 };
 
-struct ComparisonChainExpr final : Expr
-{
+struct ComparisonChainExpr final : Expr {
 
-    std::vector<ExprPtr> expressions;
-    std::vector<ComparisonOperators> operators;
+  std::vector<ExprPtr> expressions;
+  std::vector<ComparisonOperators> operators;
 
-    ComparisonChainExpr() = default;
+  ComparisonChainExpr() = default;
 
-    ComparisonChainExpr(std::vector<ExprPtr> &&expressions, std::vector<ComparisonOperators> &&operators)
-        : expressions(std::move(expressions))
-        , operators(std::move(operators))
-    {
-    }
+  ComparisonChainExpr(std::vector<ExprPtr> &&expressions,
+                      std::vector<ComparisonOperators> &&operators)
+      : expressions(std::move(expressions)), operators(std::move(operators)) {}
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator==(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
-CuraFormulaeEngine::ast::ExprPtr operator!=(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
-CuraFormulaeEngine::ast::ExprPtr operator>=(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
-CuraFormulaeEngine::ast::ExprPtr operator>(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
-CuraFormulaeEngine::ast::ExprPtr operator<=(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
-CuraFormulaeEngine::ast::ExprPtr operator<(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator==(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator!=(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator>=(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator>(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator<=(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs);
+CuraFormulaeEngine::ast::ExprPtr
+operator<(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs);
diff --git a/include/cura-formulae-engine/ast/condition_expr.h b/include/cura-formulae-engine/ast/condition_expr.h
index c2b18c0..a41ab6e 100644
--- a/include/cura-formulae-engine/ast/condition_expr.h
+++ b/include/cura-formulae-engine/ast/condition_expr.h
@@ -3,31 +3,28 @@
 #include "cura-formulae-engine/ast/ast.h"
 #include "expr_ptr.h"
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct ConditionExpr final : Expr
-{
-    ExprPtr then_expr;
-    ExprPtr condition;
-    ExprPtr else_expr;
+struct ConditionExpr final : Expr {
+  ExprPtr then_expr;
+  ExprPtr condition;
+  ExprPtr else_expr;
 
-    ConditionExpr(ExprPtr then_expr, ExprPtr condition, ExprPtr else_expr)
-        : then_expr(std::move(then_expr))
-        , condition(std::move(condition))
-        , else_expr(std::move(else_expr))
-    {
-    }
+  ConditionExpr(ExprPtr then_expr, ExprPtr condition, ExprPtr else_expr)
+      : then_expr(std::move(then_expr)), condition(std::move(condition)),
+        else_expr(std::move(else_expr)) {}
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/expr_ptr.h b/include/cura-formulae-engine/ast/expr_ptr.h
index 1db9a48..272bf96 100644
--- a/include/cura-formulae-engine/ast/expr_ptr.h
+++ b/include/cura-formulae-engine/ast/expr_ptr.h
@@ -2,45 +2,39 @@
 
 #include "cura-formulae-engine/ast/ast.h"
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct ExprPtr final : Expr
-{
-    ExprPtr() = default;
-    ExprPtr(const ExprPtr&) = delete;
-    ExprPtr(ExprPtr&&) = default;
-    ExprPtr& operator=(const ExprPtr&) = delete;
-    ExprPtr& operator=(ExprPtr&&) = default;
-    ~ExprPtr() override = default;
+struct ExprPtr final : Expr {
+  ExprPtr() = default;
+  ExprPtr(const ExprPtr &) = delete;
+  ExprPtr(ExprPtr &&) = default;
+  ExprPtr &operator=(const ExprPtr &) = delete;
+  ExprPtr &operator=(ExprPtr &&) = default;
+  ~ExprPtr() override = default;
 
-    std::unique_ptr<Expr> ptr;
+  std::unique_ptr<Expr> ptr;
 
-    ExprPtr(std::unique_ptr<Expr> ptr)
-        : ptr(std::move(ptr))
-    {
-    }
+  ExprPtr(std::unique_ptr<Expr> ptr) : ptr(std::move(ptr)) {}
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 
-    ExprPtr operator[](ExprPtr other);
+  ExprPtr operator[](ExprPtr other);
 
-    template<typename... Ts>
-    ExprPtr operator()(Ts... args);
+  template <typename... Ts> ExprPtr operator()(Ts... args);
 };
 
-template<typename T, typename... Ts>
-ExprPtr make_expr_ptr(Ts... args)
-{
-    return ExprPtr(std::move(std::make_unique<T>(std::forward<Ts>(args)...)));
+template <typename T, typename... Ts> ExprPtr make_expr_ptr(Ts... args) {
+  return ExprPtr(std::move(std::make_unique<T>(std::forward<Ts>(args)...)));
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/fn_application_expr.h b/include/cura-formulae-engine/ast/fn_application_expr.h
index bb9b0a6..ad4bd38 100644
--- a/include/cura-formulae-engine/ast/fn_application_expr.h
+++ b/include/cura-formulae-engine/ast/fn_application_expr.h
@@ -3,37 +3,35 @@
 #include "cura-formulae-engine/ast/ast.h"
 #include "expr_ptr.h"
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct FnApplicationExpr final : Expr
-{
-    ExprPtr fn;
-    std::vector<ExprPtr> args;
+struct FnApplicationExpr final : Expr {
+  ExprPtr fn;
+  std::vector<ExprPtr> args;
 
-    FnApplicationExpr(ExprPtr fn, std::vector<ExprPtr> args)
-        : fn(std::move(fn))
-        , args(std::move(args))
-    {
-    }
+  FnApplicationExpr(ExprPtr fn, std::vector<ExprPtr> args)
+      : fn(std::move(fn)), args(std::move(args)) {}
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-template<typename... Ts>
-CuraFormulaeEngine::ast::ExprPtr CuraFormulaeEngine::ast::ExprPtr::operator()(Ts... args)
-{
-    std::vector<ExprPtr> args_vec;
-    (args_vec.push_back(std::forward<Ts>(args)), ...);
-    return make_expr_ptr<FnApplicationExpr>(std::move(*this), std::move(args_vec));
+template <typename... Ts>
+CuraFormulaeEngine::ast::ExprPtr
+CuraFormulaeEngine::ast::ExprPtr::operator()(Ts... args) {
+  std::vector<ExprPtr> args_vec;
+  (args_vec.push_back(std::forward<Ts>(args)), ...);
+  return make_expr_ptr<FnApplicationExpr>(std::move(*this),
+                                          std::move(args_vec));
 }
diff --git a/include/cura-formulae-engine/ast/index_expr.h b/include/cura-formulae-engine/ast/index_expr.h
index 9038647..582e4b6 100644
--- a/include/cura-formulae-engine/ast/index_expr.h
+++ b/include/cura-formulae-engine/ast/index_expr.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "cura-formulae-engine/ast/ast.h"
-#include "expr_ptr.h"
 #include "cura-formulae-engine/eval.h"
+#include "expr_ptr.h"
 
 #include <fmt/format.h>
 #include <zeus/expected.hpp>
@@ -11,29 +11,26 @@
 #include <unordered_set>
 #include <variant>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct IndexExpr final : Expr
-{
-    ExprPtr array;
-    ExprPtr index;
+struct IndexExpr final : Expr {
+  ExprPtr array;
+  ExprPtr index;
 
-    IndexExpr(ExprPtr array, ExprPtr index)
-        : array(std::move(array))
-        , index(std::move(index))
-    {
-    }
+  IndexExpr(ExprPtr array, ExprPtr index)
+      : array(std::move(array)), index(std::move(index)) {}
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/list_comprehension_expr.h b/include/cura-formulae-engine/ast/list_comprehension_expr.h
index 07c2edd..2b4d222 100644
--- a/include/cura-formulae-engine/ast/list_comprehension_expr.h
+++ b/include/cura-formulae-engine/ast/list_comprehension_expr.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "cura-formulae-engine/ast/ast.h"
-#include "expr_ptr.h"
 #include "cura-formulae-engine/eval.h"
+#include "expr_ptr.h"
 
 #include <optional>
 #include <unordered_set>
@@ -10,46 +10,41 @@
 #include <vector>
 #include <zeus/expected.hpp>
 
-namespace CuraFormulaeEngine::ast
-{
-
-struct ListComprehensionExpr final : Expr
-{
-    struct loop
-    {
-        ExprPtr iterator_key;
-        ExprPtr iterable;
-        std::vector<ExprPtr> conditions;
+namespace CuraFormulaeEngine::ast {
 
-        loop(ExprPtr iterator_key, ExprPtr iterable, std::vector<ExprPtr> conditions)
-            : iterator_key(std::move(iterator_key))
-            , iterable(std::move(iterable))
-            , conditions(std::move(conditions))
-        {
-        }
-    };
+struct ListComprehensionExpr final : Expr {
+  struct loop {
+    ExprPtr iterator_key;
+    ExprPtr iterable;
+    std::vector<ExprPtr> conditions;
 
-    ExprPtr iterator;
-    std::vector<loop> loops;
+    loop(ExprPtr iterator_key, ExprPtr iterable,
+         std::vector<ExprPtr> conditions)
+        : iterator_key(std::move(iterator_key)), iterable(std::move(iterable)),
+          conditions(std::move(conditions)) {}
+  };
 
-    ListComprehensionExpr(ExprPtr iterator, std::vector<loop> loops)
-        : iterator(std::move(iterator))
-        , loops(std::move(loops))
-    {
-    }
+  ExprPtr iterator;
+  std::vector<loop> loops;
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  ListComprehensionExpr(ExprPtr iterator, std::vector<loop> loops)
+      : iterator(std::move(iterator)), loops(std::move(loops)) {}
 
-    std::optional<eval::Error> handle_loop(const size_t loop_index, env::LocalEnvironment& local_environment, std::vector<eval::Value>& results) const;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  std::optional<eval::Error>
+  handle_loop(const size_t loop_index, env::LocalEnvironment &local_environment,
+              std::vector<eval::Value> &results) const;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/list_expr.h b/include/cura-formulae-engine/ast/list_expr.h
index 3430904..35b55fc 100644
--- a/include/cura-formulae-engine/ast/list_expr.h
+++ b/include/cura-formulae-engine/ast/list_expr.h
@@ -1,40 +1,35 @@
 #pragma once
 
 #include "cura-formulae-engine/ast/ast.h"
-#include "expr_ptr.h"
 #include "cura-formulae-engine/eval.h"
+#include "expr_ptr.h"
 
 #include <zeus/expected.hpp>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct ListExpr final : Expr
-{
-    std::vector<ExprPtr> elements;
+struct ListExpr final : Expr {
+  std::vector<ExprPtr> elements;
 
-    ListExpr(std::vector<ExprPtr> elements)
-        : elements(std::move(elements))
-    {
-    }
+  ListExpr(std::vector<ExprPtr> elements) : elements(std::move(elements)) {}
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
-template<typename... Ts>
-ExprPtr make_list_expr(Ts&&... elements)
-{
-    std::vector<ExprPtr> elements_vec;
-    (elements_vec.push_back(std::forward<Ts>(elements)), ...);
-    return make_expr_ptr<ListExpr>(std::move(elements_vec));
+template <typename... Ts> ExprPtr make_list_expr(Ts &&...elements) {
+  std::vector<ExprPtr> elements_vec;
+  (elements_vec.push_back(std::forward<Ts>(elements)), ...);
+  return make_expr_ptr<ListExpr>(std::move(elements_vec));
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/primary_expr/bool_expr.h b/include/cura-formulae-engine/ast/primary_expr/bool_expr.h
index 53563f9..f8cb815 100644
--- a/include/cura-formulae-engine/ast/primary_expr/bool_expr.h
+++ b/include/cura-formulae-engine/ast/primary_expr/bool_expr.h
@@ -2,12 +2,10 @@
 
 #include "primary_expr.h"
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct BoolExpr final : PrimaryExpr<bool>
-{
-    using PrimaryExpr::PrimaryExpr;
+struct BoolExpr final : PrimaryExpr<bool> {
+  using PrimaryExpr::PrimaryExpr;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/primary_expr/float_expr.h b/include/cura-formulae-engine/ast/primary_expr/float_expr.h
index 65e8627..37af3dc 100644
--- a/include/cura-formulae-engine/ast/primary_expr/float_expr.h
+++ b/include/cura-formulae-engine/ast/primary_expr/float_expr.h
@@ -2,12 +2,10 @@
 
 #include "primary_expr.h"
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct FloatExpr final : PrimaryExpr<double>
-{
-    using PrimaryExpr::PrimaryExpr;
+struct FloatExpr final : PrimaryExpr<double> {
+  using PrimaryExpr::PrimaryExpr;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/primary_expr/int_expr.h b/include/cura-formulae-engine/ast/primary_expr/int_expr.h
index 9da9efb..35be8ae 100644
--- a/include/cura-formulae-engine/ast/primary_expr/int_expr.h
+++ b/include/cura-formulae-engine/ast/primary_expr/int_expr.h
@@ -4,12 +4,10 @@
 
 #include <cstdint>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct IntExpr final : PrimaryExpr<std::int64_t>
-{
-    using PrimaryExpr::PrimaryExpr;
+struct IntExpr final : PrimaryExpr<std::int64_t> {
+  using PrimaryExpr::PrimaryExpr;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/primary_expr/none_expr.h b/include/cura-formulae-engine/ast/primary_expr/none_expr.h
index 0d2ebb4..a16d723 100644
--- a/include/cura-formulae-engine/ast/primary_expr/none_expr.h
+++ b/include/cura-formulae-engine/ast/primary_expr/none_expr.h
@@ -2,17 +2,12 @@
 
 #include "primary_expr.h"
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct NoneExpr final : PrimaryExpr<std::nullptr_t>
-{
-    NoneExpr()
-        : PrimaryExpr(nullptr)
-    {
-    }
+struct NoneExpr final : PrimaryExpr<std::nullptr_t> {
+  NoneExpr() : PrimaryExpr(nullptr) {}
 
-    using PrimaryExpr::PrimaryExpr;
+  using PrimaryExpr::PrimaryExpr;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/primary_expr/primary_expr.h b/include/cura-formulae-engine/ast/primary_expr/primary_expr.h
index cb39a48..e5d3a36 100644
--- a/include/cura-formulae-engine/ast/primary_expr/primary_expr.h
+++ b/include/cura-formulae-engine/ast/primary_expr/primary_expr.h
@@ -9,47 +9,38 @@
 #include <string>
 #include <unordered_set>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-template<typename T>
-struct PrimaryExpr : public Expr
-{
-    T value;
+template <typename T> struct PrimaryExpr : public Expr {
+  T value;
 
-    explicit PrimaryExpr(T value)
-        : value(value)
-    {
-    }
+  explicit PrimaryExpr(T value) : value(value) {}
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment*) const noexcept final
-    {
-        return value;
-    }
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *) const noexcept final {
+    return value;
+  }
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final
-    {
-        return {};
-    };
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final {
+    return {};
+  };
 
-    [[nodiscard]] std::string toString() const noexcept override
-    {
-        return fmt::format("{}", value);
-    }
+  [[nodiscard]] std::string toString() const noexcept override {
+    return fmt::format("{}", value);
+  }
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final
-    {
-        if (auto other_number = dynamic_cast<const PrimaryExpr<T>*>(&other))
-        {
-            return value == other_number->value;
-        }
-        return false;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final {
+    if (auto other_number = dynamic_cast<const PrimaryExpr<T> *>(&other)) {
+      return value == other_number->value;
     }
+    return false;
+  }
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final
-    {
-        visitor(*this);
-    }
+  void
+  visitAll(std::function<void(const Expr &)> visitor) const noexcept final {
+    visitor(*this);
+  }
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/primary_expr/string_expr.h b/include/cura-formulae-engine/ast/primary_expr/string_expr.h
index 277336c..a175de7 100644
--- a/include/cura-formulae-engine/ast/primary_expr/string_expr.h
+++ b/include/cura-formulae-engine/ast/primary_expr/string_expr.h
@@ -2,14 +2,12 @@
 
 #include "primary_expr.h"
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct StringExpr final : PrimaryExpr<std::string>
-{
-    using PrimaryExpr::PrimaryExpr;
+struct StringExpr final : PrimaryExpr<std::string> {
+  using PrimaryExpr::PrimaryExpr;
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/slice_expr.h b/include/cura-formulae-engine/ast/slice_expr.h
index f8b1f01..efb0e68 100644
--- a/include/cura-formulae-engine/ast/slice_expr.h
+++ b/include/cura-formulae-engine/ast/slice_expr.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "cura-formulae-engine/ast/ast.h"
-#include "expr_ptr.h"
 #include "cura-formulae-engine/eval.h"
+#include "expr_ptr.h"
 
 #include <zeus/expected.hpp>
 
@@ -13,34 +13,30 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::ast
-{
-
-struct SliceExpr final : Expr
-{
-    ExprPtr array;
-    std::optional<ExprPtr> start_index;
-    std::optional<ExprPtr> end_index;
-    std::optional<ExprPtr> step_size;
+namespace CuraFormulaeEngine::ast {
 
-    SliceExpr(ExprPtr array, std::optional<ExprPtr> start_index, std::optional<ExprPtr> end_index, std::optional<ExprPtr> step_size)
-        : array(std::move(array))
-        , start_index(std::move(start_index))
-        , end_index(std::move(end_index))
-        , step_size(std::move(step_size))
-    {
-    }
+struct SliceExpr final : Expr {
+  ExprPtr array;
+  std::optional<ExprPtr> start_index;
+  std::optional<ExprPtr> end_index;
+  std::optional<ExprPtr> step_size;
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  SliceExpr(ExprPtr array, std::optional<ExprPtr> start_index,
+            std::optional<ExprPtr> end_index, std::optional<ExprPtr> step_size)
+      : array(std::move(array)), start_index(std::move(start_index)),
+        end_index(std::move(end_index)), step_size(std::move(step_size)) {}
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/tuple_expr.h b/include/cura-formulae-engine/ast/tuple_expr.h
index af8bc61..6fdca41 100644
--- a/include/cura-formulae-engine/ast/tuple_expr.h
+++ b/include/cura-formulae-engine/ast/tuple_expr.h
@@ -8,35 +8,30 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct TupleExpr final : Expr
-{
-    std::vector<ExprPtr> elements;
+struct TupleExpr final : Expr {
+  std::vector<ExprPtr> elements;
 
-    TupleExpr(std::vector<ExprPtr> elements)
-        : elements(std::move(elements))
-    {
-    }
+  TupleExpr(std::vector<ExprPtr> elements) : elements(std::move(elements)) {}
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
-template<typename... Ts>
-ExprPtr make_tuple_expr(Ts&&... elements)
-{
-    std::vector<ExprPtr> elements_vec;
-    (elements_vec.push_back(std::forward<Ts>(elements)), ...);
-    return make_expr_ptr<TupleExpr>(std::move(elements_vec));
+template <typename... Ts> ExprPtr make_tuple_expr(Ts &&...elements) {
+  std::vector<ExprPtr> elements_vec;
+  (elements_vec.push_back(std::forward<Ts>(elements)), ...);
+  return make_expr_ptr<TupleExpr>(std::move(elements_vec));
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/unary_expr/neg_expr.h b/include/cura-formulae-engine/ast/unary_expr/neg_expr.h
index c1845fc..728c35d 100644
--- a/include/cura-formulae-engine/ast/unary_expr/neg_expr.h
+++ b/include/cura-formulae-engine/ast/unary_expr/neg_expr.h
@@ -1,23 +1,23 @@
 #pragma once
 
 #include "cura-formulae-engine/ast/expr_ptr.h"
-#include "unary_expr.h"
 #include "cura-formulae-engine/eval.h"
+#include "unary_expr.h"
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct NegExpr final : UnaryExpr
-{
-    using UnaryExpr::UnaryExpr;
+struct NegExpr final : UnaryExpr {
+  using UnaryExpr::UnaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const eval::Value& eval_value) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const eval::Value &eval_value) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator-(CuraFormulaeEngine::ast::ExprPtr operand);
+CuraFormulaeEngine::ast::ExprPtr
+operator-(CuraFormulaeEngine::ast::ExprPtr operand);
diff --git a/include/cura-formulae-engine/ast/unary_expr/not_expr.h b/include/cura-formulae-engine/ast/unary_expr/not_expr.h
index d371f9b..5e76745 100644
--- a/include/cura-formulae-engine/ast/unary_expr/not_expr.h
+++ b/include/cura-formulae-engine/ast/unary_expr/not_expr.h
@@ -1,23 +1,23 @@
 #pragma once
 
 #include "cura-formulae-engine/ast/expr_ptr.h"
-#include "unary_expr.h"
 #include "cura-formulae-engine/eval.h"
+#include "unary_expr.h"
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct NotExpr final : UnaryExpr
-{
-    using UnaryExpr::UnaryExpr;
+struct NotExpr final : UnaryExpr {
+  using UnaryExpr::UnaryExpr;
 
-    [[nodiscard]] std::string getOpIdentifier() const noexcept final;
+  [[nodiscard]] std::string getOpIdentifier() const noexcept final;
 
-    [[nodiscard]] eval::Result evaluate(const eval::Value& eval_value) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const eval::Value &eval_value) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator!(CuraFormulaeEngine::ast::ExprPtr operand);
+CuraFormulaeEngine::ast::ExprPtr
+operator!(CuraFormulaeEngine::ast::ExprPtr operand);
diff --git a/include/cura-formulae-engine/ast/unary_expr/unary_expr.h b/include/cura-formulae-engine/ast/unary_expr/unary_expr.h
index 919210a..c720f35 100644
--- a/include/cura-formulae-engine/ast/unary_expr/unary_expr.h
+++ b/include/cura-formulae-engine/ast/unary_expr/unary_expr.h
@@ -12,31 +12,29 @@
 #include <unordered_set>
 #include <variant>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct UnaryExpr : Expr
-{
-    ExprPtr operand;
+struct UnaryExpr : Expr {
+  ExprPtr operand;
 
-    explicit UnaryExpr(ExprPtr operand)
-        : operand(std::move(operand))
-    {
-    }
+  explicit UnaryExpr(ExprPtr operand) : operand(std::move(operand)) {}
 
-    [[nodiscard]] virtual std::string getOpIdentifier() const = 0;
+  [[nodiscard]] virtual std::string getOpIdentifier() const = 0;
 
-    [[nodiscard]] std::string toString() const noexcept final;
+  [[nodiscard]] std::string toString() const noexcept final;
 
-    [[nodiscard]] virtual eval::Result evaluate(const eval::Value& eval_value) const = 0;
+  [[nodiscard]] virtual eval::Result
+  evaluate(const eval::Value &eval_value) const = 0;
 
-    [[nodiscard]] eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  [[nodiscard]] eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    [[nodiscard]] std::unordered_set<std::string> freeVariables() const noexcept final;
+  [[nodiscard]] std::unordered_set<std::string>
+  freeVariables() const noexcept final;
 
-    [[nodiscard]] bool deepEq(const Expr& other) const noexcept final;
+  [[nodiscard]] bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/ast/variable_expr.h b/include/cura-formulae-engine/ast/variable_expr.h
index 6350681..bc9399d 100644
--- a/include/cura-formulae-engine/ast/variable_expr.h
+++ b/include/cura-formulae-engine/ast/variable_expr.h
@@ -6,27 +6,23 @@
 
 #include <zeus/expected.hpp>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-struct VariableExpr final : Expr
-{
-    std::string name;
+struct VariableExpr final : Expr {
+  std::string name;
 
-    VariableExpr(std::string name)
-        : name(std::move(name))
-    {
-    }
+  VariableExpr(std::string name) : name(std::move(name)) {}
 
-    std::string toString() const noexcept final;
+  std::string toString() const noexcept final;
 
-    eval::Result evaluate(const env::Environment* environment) const noexcept final;
+  eval::Result
+  evaluate(const env::Environment *environment) const noexcept final;
 
-    std::unordered_set<std::string> freeVariables() const noexcept final;
+  std::unordered_set<std::string> freeVariables() const noexcept final;
 
-    bool deepEq(const Expr& other) const noexcept final;
+  bool deepEq(const Expr &other) const noexcept final;
 
-    void visitAll(std::function<void(const Expr&)> visitor) const noexcept final;
+  void visitAll(std::function<void(const Expr &)> visitor) const noexcept final;
 };
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/include/cura-formulae-engine/config.h b/include/cura-formulae-engine/config.h
index 8651a25..4a81dc2 100644
--- a/include/cura-formulae-engine/config.h
+++ b/include/cura-formulae-engine/config.h
@@ -1,11 +1,11 @@
 #pragma once
 
 #ifdef _WIN32
-#    ifdef cura_formulae_engine_EXPORTS
-#        define CURA_FORMULAE_ENGINE_API __declspec(dllexport)
-#    else
-#        define CURA_FORMULAE_ENGINE_API __declspec(dllimport)
-#    endif
+#ifdef cura_formulae_engine_EXPORTS
+#define CURA_FORMULAE_ENGINE_API __declspec(dllexport)
 #else
-#    define CURA_FORMULAE_ENGINE_API
+#define CURA_FORMULAE_ENGINE_API __declspec(dllimport)
+#endif
+#else
+#define CURA_FORMULAE_ENGINE_API
 #endif
diff --git a/include/cura-formulae-engine/env/abs.h b/include/cura-formulae-engine/env/abs.h
index 76c4d65..c8dd2f9 100644
--- a/include/cura-formulae-engine/env/abs.h
+++ b/include/cura-formulae-engine/env/abs.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t abs;
 
diff --git a/include/cura-formulae-engine/env/all.h b/include/cura-formulae-engine/env/all.h
index a78f5c4..9066842 100644
--- a/include/cura-formulae-engine/env/all.h
+++ b/include/cura-formulae-engine/env/all.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t all;
 
diff --git a/include/cura-formulae-engine/env/any.h b/include/cura-formulae-engine/env/any.h
index f60f255..869f04a 100644
--- a/include/cura-formulae-engine/env/any.h
+++ b/include/cura-formulae-engine/env/any.h
@@ -2,9 +2,8 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-    extern const eval::Value::fn_t any;
+extern const eval::Value::fn_t any;
 
 } // namespace CuraFormulaeEngine::env
diff --git a/include/cura-formulae-engine/env/env.h b/include/cura-formulae-engine/env/env.h
index 28169b2..ddbb581 100644
--- a/include/cura-formulae-engine/env/env.h
+++ b/include/cura-formulae-engine/env/env.h
@@ -3,8 +3,7 @@
 #include "cura-formulae-engine/ast/ast.h"
 #include "cura-formulae-engine/config.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 /**
  * @brief The standard environment.
diff --git a/include/cura-formulae-engine/env/float_fn.h b/include/cura-formulae-engine/env/float_fn.h
index e100cf9..564d3d7 100644
--- a/include/cura-formulae-engine/env/float_fn.h
+++ b/include/cura-formulae-engine/env/float_fn.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t float_fn;
 
diff --git a/include/cura-formulae-engine/env/int_fn.h b/include/cura-formulae-engine/env/int_fn.h
index 1997112..064fe23 100644
--- a/include/cura-formulae-engine/env/int_fn.h
+++ b/include/cura-formulae-engine/env/int_fn.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t int_fn;
 
diff --git a/include/cura-formulae-engine/env/len.h b/include/cura-formulae-engine/env/len.h
index 1d79c30..9c1afa4 100644
--- a/include/cura-formulae-engine/env/len.h
+++ b/include/cura-formulae-engine/env/len.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t len;
 
diff --git a/include/cura-formulae-engine/env/map.h b/include/cura-formulae-engine/env/map.h
index cf9b043..b4b2429 100644
--- a/include/cura-formulae-engine/env/map.h
+++ b/include/cura-formulae-engine/env/map.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t map;
 
diff --git a/include/cura-formulae-engine/env/math_atan.h b/include/cura-formulae-engine/env/math_atan.h
index 443bfc2..729e879 100644
--- a/include/cura-formulae-engine/env/math_atan.h
+++ b/include/cura-formulae-engine/env/math_atan.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_atan;
 
diff --git a/include/cura-formulae-engine/env/math_ceil.h b/include/cura-formulae-engine/env/math_ceil.h
index cd3fb71..518181f 100644
--- a/include/cura-formulae-engine/env/math_ceil.h
+++ b/include/cura-formulae-engine/env/math_ceil.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_ceil;
 
diff --git a/include/cura-formulae-engine/env/math_cos.h b/include/cura-formulae-engine/env/math_cos.h
index f2d5388..63ac7c4 100644
--- a/include/cura-formulae-engine/env/math_cos.h
+++ b/include/cura-formulae-engine/env/math_cos.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_cos;
 
diff --git a/include/cura-formulae-engine/env/math_degrees.h b/include/cura-formulae-engine/env/math_degrees.h
index 7ace2fc..576ff0a 100644
--- a/include/cura-formulae-engine/env/math_degrees.h
+++ b/include/cura-formulae-engine/env/math_degrees.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_degrees;
 
diff --git a/include/cura-formulae-engine/env/math_floor.h b/include/cura-formulae-engine/env/math_floor.h
index 374ac2a..d1c5b2d 100644
--- a/include/cura-formulae-engine/env/math_floor.h
+++ b/include/cura-formulae-engine/env/math_floor.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_floor;
 
diff --git a/include/cura-formulae-engine/env/math_log.h b/include/cura-formulae-engine/env/math_log.h
index 2f9356e..66bd3e6 100644
--- a/include/cura-formulae-engine/env/math_log.h
+++ b/include/cura-formulae-engine/env/math_log.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_log;
 
diff --git a/include/cura-formulae-engine/env/math_radians.h b/include/cura-formulae-engine/env/math_radians.h
index 200c620..d973a2c 100644
--- a/include/cura-formulae-engine/env/math_radians.h
+++ b/include/cura-formulae-engine/env/math_radians.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_radians;
 
diff --git a/include/cura-formulae-engine/env/math_sin.h b/include/cura-formulae-engine/env/math_sin.h
index 183af7c..d05bf85 100644
--- a/include/cura-formulae-engine/env/math_sin.h
+++ b/include/cura-formulae-engine/env/math_sin.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_sin;
 
diff --git a/include/cura-formulae-engine/env/math_sqrt.h b/include/cura-formulae-engine/env/math_sqrt.h
index e7c4740..a9459b5 100644
--- a/include/cura-formulae-engine/env/math_sqrt.h
+++ b/include/cura-formulae-engine/env/math_sqrt.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_sqrt;
 
diff --git a/include/cura-formulae-engine/env/math_tan.h b/include/cura-formulae-engine/env/math_tan.h
index c62bff4..53cfb05 100644
--- a/include/cura-formulae-engine/env/math_tan.h
+++ b/include/cura-formulae-engine/env/math_tan.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t math_tan;
 
diff --git a/include/cura-formulae-engine/env/max.h b/include/cura-formulae-engine/env/max.h
index 77e7cca..8fed2cd 100644
--- a/include/cura-formulae-engine/env/max.h
+++ b/include/cura-formulae-engine/env/max.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t max;
 
diff --git a/include/cura-formulae-engine/env/min.h b/include/cura-formulae-engine/env/min.h
index 5a03c6f..8c69406 100644
--- a/include/cura-formulae-engine/env/min.h
+++ b/include/cura-formulae-engine/env/min.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t min;
 
diff --git a/include/cura-formulae-engine/env/round.h b/include/cura-formulae-engine/env/round.h
index ef665b3..636b432 100644
--- a/include/cura-formulae-engine/env/round.h
+++ b/include/cura-formulae-engine/env/round.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t round;
 
diff --git a/include/cura-formulae-engine/env/str.h b/include/cura-formulae-engine/env/str.h
index b0a6285..7eee281 100644
--- a/include/cura-formulae-engine/env/str.h
+++ b/include/cura-formulae-engine/env/str.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t str;
 
diff --git a/include/cura-formulae-engine/env/sum.h b/include/cura-formulae-engine/env/sum.h
index e415c18..57af775 100644
--- a/include/cura-formulae-engine/env/sum.h
+++ b/include/cura-formulae-engine/env/sum.h
@@ -2,8 +2,7 @@
 
 #include "cura-formulae-engine/eval.h"
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 extern const eval::Value::fn_t sum;
 
diff --git a/include/cura-formulae-engine/eval.h b/include/cura-formulae-engine/eval.h
index 82626b2..5c73a39 100644
--- a/include/cura-formulae-engine/eval.h
+++ b/include/cura-formulae-engine/eval.h
@@ -17,97 +17,72 @@
 
 #include <cstddef>
 #include <functional>
+#include <spdlog/spdlog.h>
 #include <string>
 #include <variant>
 #include <vector>
 #include <zeus/expected.hpp>
-#include <spdlog/spdlog.h>
 
-namespace CuraFormulaeEngine::eval
-{
+namespace CuraFormulaeEngine::eval {
 
 struct Value;
 
-enum class Error
-{
-    TypeMismatch,
-    UndefinedVariable,
-    DivisionByZero,
-    InvalidNumberOfArguments,
-    IndexOutOfBounds,
-    ValueError
+enum class Error {
+  TypeMismatch,
+  UndefinedVariable,
+  DivisionByZero,
+  InvalidNumberOfArguments,
+  IndexOutOfBounds,
+  ValueError
 };
 
 using Result = zeus::expected<Value, Error>;
 
-struct Value
-{
-    using fn_t = std::function<Result(const std::vector<Value>&)>;
+struct Value {
+  using fn_t = std::function<Result(const std::vector<Value> &)>;
 
-    std::variant<bool, double, std::int64_t, std::string, std::vector<Value>, fn_t, std::nullptr_t> value = nullptr;
+  std::variant<bool, double, std::int64_t, std::string, std::vector<Value>,
+               fn_t, std::nullptr_t>
+      value = nullptr;
 
-    Value() noexcept = default;
+  Value() noexcept = default;
 
-    Value(const bool& value) noexcept
-        : value{ value }
-    {
-    }
+  Value(const bool &value) noexcept : value{value} {}
 
-    Value(const double& value) noexcept
-        : value{ value }
-    {
-    }
+  Value(const double &value) noexcept : value{value} {}
 
-    Value(const std::int64_t& value) noexcept
-        : value{ value }
-    {
-    }
+  Value(const std::int64_t &value) noexcept : value{value} {}
 
-    Value(const std::string& value) noexcept
-        : value{ value }
-    {
-    }
+  Value(const std::string &value) noexcept : value{value} {}
 
-    Value(const std::vector<Value>& value) noexcept
-        : value{ value }
-    {
-    }
+  Value(const std::vector<Value> &value) noexcept : value{value} {}
 
-    Value(const fn_t& value) noexcept
-        : value{ value }
-    {
-    }
+  Value(const fn_t &value) noexcept : value{value} {}
 
-    Value(const std::nullptr_t& value) noexcept
-        : value{ value }
-    {
-    }
+  Value(const std::nullptr_t &value) noexcept : value{value} {}
 
-    static Value none() noexcept
-    {
-        return Value(nullptr);
-    }
+  static Value none() noexcept { return Value(nullptr); }
 
-    ~Value() = default;
+  ~Value() = default;
 
-    Value(Value&& other) noexcept = default;
-    Value(const Value& other) noexcept = default;
-    Value& operator=(const Value& other) noexcept = default;
-    Value& operator=(Value&& other) noexcept = default;
+  Value(Value &&other) noexcept = default;
+  Value(const Value &other) noexcept = default;
+  Value &operator=(const Value &other) noexcept = default;
+  Value &operator=(Value &&other) noexcept = default;
 
-    [[nodiscard]] std::string toString() const noexcept;
+  [[nodiscard]] std::string toString() const noexcept;
 
-    [[nodiscard]] bool deepEq(const Value& other) const noexcept;
+  [[nodiscard]] bool deepEq(const Value &other) const noexcept;
 
-    [[nodiscard]] bool isTruthy() const noexcept;
+  [[nodiscard]] bool isTruthy() const noexcept;
 
-    [[nodiscard]] zeus::expected<double, Error> numeric() const noexcept;
+  [[nodiscard]] zeus::expected<double, Error> numeric() const noexcept;
 
 #ifdef EMSCRIPTEN
-    [[nodiscard]] emscripten::val toEmscripten() const;
+  [[nodiscard]] emscripten::val toEmscripten() const;
 #endif
 
-    Result operator[](const Value&) const noexcept;
+  Result operator[](const Value &) const noexcept;
 };
 
 /**
@@ -118,39 +93,62 @@ struct Value
  * @param result
  * @return
  */
-template<typename ExpectedType>
-zeus::expected<ExpectedType, Error> try_get(const Result& result)
-{
-    if (! result.has_value())
-    {
-        return zeus::unexpected(result.error());
-    }
-
-    const auto& type_result = result.value();
-    if (! std::holds_alternative<ExpectedType>(type_result.value))
-    {
-        return zeus::unexpected(Error::TypeMismatch);
-    }
-
-    return std::get<ExpectedType>(type_result.value);
+template <typename ExpectedType>
+zeus::expected<ExpectedType, Error> try_get(const Result &result) {
+  if (!result.has_value()) {
+    return zeus::unexpected(result.error());
+  }
+
+  const auto &type_result = result.value();
+  if (!std::holds_alternative<ExpectedType>(type_result.value)) {
+    return zeus::unexpected(Error::TypeMismatch);
+  }
+
+  return std::get<ExpectedType>(type_result.value);
 }
 
-Result pow(const Value& lhs, const Value& rhs);
+Result pow(const Value &lhs, const Value &rhs);
 
 } // namespace CuraFormulaeEngine::eval
 
-bool operator==(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-bool operator!=(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator<(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator<=(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator>=(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator>(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator&&(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator||(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-CuraFormulaeEngine::eval::Result operator+(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-CuraFormulaeEngine::eval::Result operator-(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-CuraFormulaeEngine::eval::Result operator*(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-CuraFormulaeEngine::eval::Result operator/(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-CuraFormulaeEngine::eval::Result operator%(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept;
-CuraFormulaeEngine::eval::Result operator!(const CuraFormulaeEngine::eval::Value& operand) noexcept;
-CuraFormulaeEngine::eval::Result operator-(const CuraFormulaeEngine::eval::Value& operand) noexcept;
+bool operator==(const CuraFormulaeEngine::eval::Value &lhs,
+                const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+bool operator!=(const CuraFormulaeEngine::eval::Value &lhs,
+                const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator<(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator<=(const CuraFormulaeEngine::eval::Value &lhs,
+           const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator>=(const CuraFormulaeEngine::eval::Value &lhs,
+           const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator>(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator&&(const CuraFormulaeEngine::eval::Value &lhs,
+           const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator||(const CuraFormulaeEngine::eval::Value &lhs,
+           const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+CuraFormulaeEngine::eval::Result
+operator+(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+CuraFormulaeEngine::eval::Result
+operator-(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+CuraFormulaeEngine::eval::Result
+operator*(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+CuraFormulaeEngine::eval::Result
+operator/(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+CuraFormulaeEngine::eval::Result
+operator%(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept;
+CuraFormulaeEngine::eval::Result
+operator!(const CuraFormulaeEngine::eval::Value &operand) noexcept;
+CuraFormulaeEngine::eval::Result
+operator-(const CuraFormulaeEngine::eval::Value &operand) noexcept;
diff --git a/include/cura-formulae-engine/parser/bool_grammar.h b/include/cura-formulae-engine/parser/bool_grammar.h
index faea851..d8805bb 100644
--- a/include/cura-formulae-engine/parser/bool_grammar.h
+++ b/include/cura-formulae-engine/parser/bool_grammar.h
@@ -7,25 +7,24 @@
 #include <lexy/dsl.hpp>
 #include <memory>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct BoolGrammar : lexy::token_production
-{
-    struct TrueGrammar
-    {
-        static constexpr auto rule = LEXY_LIT("True");
-        static constexpr auto value = lexy::callback<ast::ExprPtr>([]() { return ast::ExprPtr(std::make_unique<ast::BoolExpr>(true)); });
-    };
+struct BoolGrammar : lexy::token_production {
+  struct TrueGrammar {
+    static constexpr auto rule = LEXY_LIT("True");
+    static constexpr auto value = lexy::callback<ast::ExprPtr>(
+        []() { return ast::ExprPtr(std::make_unique<ast::BoolExpr>(true)); });
+  };
 
-    struct FalseGrammar
-    {
-        static constexpr auto rule = LEXY_LIT("False");
-        static constexpr auto value = lexy::callback<ast::ExprPtr>([]() { return ast::ExprPtr(std::make_unique<ast::BoolExpr>(false)); });
-    };
+  struct FalseGrammar {
+    static constexpr auto rule = LEXY_LIT("False");
+    static constexpr auto value = lexy::callback<ast::ExprPtr>(
+        []() { return ast::ExprPtr(std::make_unique<ast::BoolExpr>(false)); });
+  };
 
-    static constexpr auto rule = lexy::dsl::p<TrueGrammar> | lexy::dsl::p<FalseGrammar>;
-    static constexpr auto value = lexy::forward<ast::ExprPtr>;
+  static constexpr auto rule =
+      lexy::dsl::p<TrueGrammar> | lexy::dsl::p<FalseGrammar>;
+  static constexpr auto value = lexy::forward<ast::ExprPtr>;
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/expr_grammar.h b/include/cura-formulae-engine/parser/expr_grammar.h
index 6fcf90a..4497303 100644
--- a/include/cura-formulae-engine/parser/expr_grammar.h
+++ b/include/cura-formulae-engine/parser/expr_grammar.h
@@ -8,28 +8,29 @@
 #include <lexy/callback.hpp>
 #include <lexy/dsl.hpp>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct ExprGrammar : lexy::expression_production
-{
-    static constexpr auto whitespace = lexy::dsl::ascii::space;
+struct ExprGrammar : lexy::expression_production {
+  static constexpr auto whitespace = lexy::dsl::ascii::space;
 
-    static constexpr auto atom = lexy::dsl::p<ListComprehensionGrammar>;
+  static constexpr auto atom = lexy::dsl::p<ListComprehensionGrammar>;
 
-    static constexpr auto op_condition = lexy::dsl::op(LEXY_LIT("if") >> lexy::dsl::p<NestedGrammar> + LEXY_LIT("else"));
-    struct Condition : lexy::dsl::infix_op_right
-    {
-        static constexpr auto op = op_condition;
-        using operand = lexy::dsl::atom;
-    };
+  static constexpr auto op_condition = lexy::dsl::op(
+      LEXY_LIT("if") >> lexy::dsl::p<NestedGrammar> + LEXY_LIT("else"));
+  struct Condition : lexy::dsl::infix_op_right {
+    static constexpr auto op = op_condition;
+    using operand = lexy::dsl::atom;
+  };
 
-    using operation = Condition;
+  using operation = Condition;
 
-    static constexpr auto value = lexy::callback<ast::ExprPtr>(
-        lexy::forward<ast::ExprPtr>,
-        [](ast::ExprPtr&& lhs, lexy::op<op_condition>, ast::ExprPtr&& condition, ast::ExprPtr&& rhs)
-        { return ast::ExprPtr(std::make_unique<ast::ConditionExpr>(std::move(lhs), std::move(condition), std::move(rhs))); });
+  static constexpr auto value = lexy::callback<ast::ExprPtr>(
+      lexy::forward<ast::ExprPtr>,
+      [](ast::ExprPtr &&lhs, lexy::op<op_condition>, ast::ExprPtr &&condition,
+         ast::ExprPtr &&rhs) {
+        return ast::ExprPtr(std::make_unique<ast::ConditionExpr>(
+            std::move(lhs), std::move(condition), std::move(rhs)));
+      });
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/list_comprehension_grammar.h b/include/cura-formulae-engine/parser/list_comprehension_grammar.h
index 4a805c7..647f39e 100644
--- a/include/cura-formulae-engine/parser/list_comprehension_grammar.h
+++ b/include/cura-formulae-engine/parser/list_comprehension_grammar.h
@@ -10,40 +10,59 @@
 #include <memory>
 #include <vector>
 
-namespace CuraFormulaeEngine::parser
-{
-
-struct ListComprehensionGrammar : lexy::token_production
-{
-    static constexpr auto whitespace = lexy::dsl::ascii::space;
-
-    struct condition_chain : token_production
-    {
-        static constexpr auto rule = lexy::dsl::list(LEXY_LIT("if") >> lexy::dsl::whitespace(lexy::dsl::ascii::space) + lexy::dsl::p<MathExprGrammar>);
-        static constexpr auto value = lexy::fold_inplace<std::vector<ast::ExprPtr>>(
-            []() { return std::vector<ast::ExprPtr>{}; },
-            [](auto&& conditions, ast::ExprPtr&& condition) { conditions.emplace_back(std::move(condition)); });
-    };
-
-    struct loop : token_production
-    {
-        static constexpr auto rule = lexy::dsl::list(
-            LEXY_LIT("for") >> lexy::dsl::whitespace(lexy::dsl::ascii::space) + lexy::dsl::p<VariableGrammar> + lexy::dsl::whitespace(lexy::dsl::ascii::space) + LEXY_LIT("in")
-                                   + lexy::dsl::whitespace(lexy::dsl::ascii::space) + lexy::dsl::p<MathExprGrammar>
-                                   + lexy::dsl::whitespace(lexy::dsl::ascii::space) + lexy::dsl::opt(lexy::dsl::p<condition_chain>));
-
-        static constexpr auto value = lexy::fold_inplace<std::vector<ast::ListComprehensionExpr::loop>>(
+namespace CuraFormulaeEngine::parser {
+
+struct ListComprehensionGrammar : lexy::token_production {
+  static constexpr auto whitespace = lexy::dsl::ascii::space;
+
+  struct condition_chain : token_production {
+    static constexpr auto rule = lexy::dsl::list(
+        LEXY_LIT("if") >> lexy::dsl::whitespace(lexy::dsl::ascii::space) +
+                              lexy::dsl::p<MathExprGrammar>);
+    static constexpr auto value = lexy::fold_inplace<std::vector<ast::ExprPtr>>(
+        []() { return std::vector<ast::ExprPtr>{}; },
+        [](auto &&conditions, ast::ExprPtr &&condition) {
+          conditions.emplace_back(std::move(condition));
+        });
+  };
+
+  struct loop : token_production {
+    static constexpr auto rule = lexy::dsl::list(
+        LEXY_LIT("for") >> lexy::dsl::whitespace(lexy::dsl::ascii::space) +
+                               lexy::dsl::p<VariableGrammar> +
+                               lexy::dsl::whitespace(lexy::dsl::ascii::space) +
+                               LEXY_LIT("in") +
+                               lexy::dsl::whitespace(lexy::dsl::ascii::space) +
+                               lexy::dsl::p<MathExprGrammar> +
+                               lexy::dsl::whitespace(lexy::dsl::ascii::space) +
+                               lexy::dsl::opt(lexy::dsl::p<condition_chain>));
+
+    static constexpr auto value =
+        lexy::fold_inplace<std::vector<ast::ListComprehensionExpr::loop>>(
             []() { return std::vector<ast::ListComprehensionExpr::loop>{}; },
-            [](auto&& loops, ast::ExprPtr&& iterator_key, ast::ExprPtr&& iterable, lexy::nullopt)
-            { loops.emplace_back(ast::ListComprehensionExpr::loop(std::move(iterator_key), std::move(iterable), std::vector<ast::ExprPtr>{})); },
-            [](auto&& loops, ast::ExprPtr&& iterator_key, ast::ExprPtr&& iterable, std::vector<ast::ExprPtr>&& conditions)
-            { loops.emplace_back(ast::ListComprehensionExpr::loop(std::move(iterator_key), std::move(iterable), std::move(conditions))); });
-    };
-
-    static constexpr auto rule = lexy::dsl::p<MathExprGrammar> + lexy::dsl::opt(lexy::dsl::p<loop>);
-    static constexpr auto value = lexy::callback<ast::ExprPtr>(
-        [](auto&& expr, lexy::nullopt) { return std::move(expr); },
-        [](auto&& expr, auto&& loops) { return ast::ExprPtr(std::make_unique<ast::ListComprehensionExpr>(std::move(expr), std::move(loops))); });
+            [](auto &&loops, ast::ExprPtr &&iterator_key,
+               ast::ExprPtr &&iterable, lexy::nullopt) {
+              loops.emplace_back(ast::ListComprehensionExpr::loop(
+                  std::move(iterator_key), std::move(iterable),
+                  std::vector<ast::ExprPtr>{}));
+            },
+            [](auto &&loops, ast::ExprPtr &&iterator_key,
+               ast::ExprPtr &&iterable,
+               std::vector<ast::ExprPtr> &&conditions) {
+              loops.emplace_back(ast::ListComprehensionExpr::loop(
+                  std::move(iterator_key), std::move(iterable),
+                  std::move(conditions)));
+            });
+  };
+
+  static constexpr auto rule =
+      lexy::dsl::p<MathExprGrammar> + lexy::dsl::opt(lexy::dsl::p<loop>);
+  static constexpr auto value = lexy::callback<ast::ExprPtr>(
+      [](auto &&expr, lexy::nullopt) { return std::move(expr); },
+      [](auto &&expr, auto &&loops) {
+        return ast::ExprPtr(std::make_unique<ast::ListComprehensionExpr>(
+            std::move(expr), std::move(loops)));
+      });
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/list_grammar.h b/include/cura-formulae-engine/parser/list_grammar.h
index 15ddf4a..9d19eab 100644
--- a/include/cura-formulae-engine/parser/list_grammar.h
+++ b/include/cura-formulae-engine/parser/list_grammar.h
@@ -8,30 +8,37 @@
 #include <lexy/dsl.hpp>
 #include <vector>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct ListGrammar : lexy::token_production
-{
-    struct ListGrammarInner : token_production
-    {
-        static constexpr auto whitespace = lexy::dsl::ascii::space;
-        static constexpr auto rule = lexy::dsl::square_bracketed.opt_list(lexy::dsl::p<NestedGrammar>, lexy::dsl::ignore_trailing_sep(lexy::dsl::comma));
-        static constexpr auto value = lexy::as_list<std::vector<ast::ExprPtr>> >> lexy::callback<ast::ExprPtr>(
-                                          [](std::vector<ast::ExprPtr> exprs)
-                                          {
-                                              // special case if the list contains a single list comprehension, we evaluate it and return the result
-                                              if (exprs.size() == 1 && dynamic_cast<const ast::ListComprehensionExpr*>(exprs[0].ptr.get()) != nullptr)
-                                              {
-                                                  return std::move(exprs[0]);
-                                              }
-                                              return ast::ExprPtr(std::make_unique<ast::ListExpr>(std::move(exprs)));
-                                          },
-                                          [](lexy::nullopt = {}) { return ast::ExprPtr(std::make_unique<ast::ListExpr>(std::vector<ast::ExprPtr>{})); });
-    };
+struct ListGrammar : lexy::token_production {
+  struct ListGrammarInner : token_production {
+    static constexpr auto whitespace = lexy::dsl::ascii::space;
+    static constexpr auto rule = lexy::dsl::square_bracketed.opt_list(
+        lexy::dsl::p<NestedGrammar>,
+        lexy::dsl::ignore_trailing_sep(lexy::dsl::comma));
+    static constexpr auto
+        value = lexy::as_list<std::vector<ast::ExprPtr>> >>
+                lexy::callback<ast::ExprPtr>(
+                    [](std::vector<ast::ExprPtr> exprs) {
+                      // special case if the list contains a single list
+                      // comprehension, we evaluate it and return the result
+                      if (exprs.size() == 1 &&
+                          dynamic_cast<const ast::ListComprehensionExpr *>(
+                              exprs[0].ptr.get()) != nullptr) {
+                        return std::move(exprs[0]);
+                      }
+                      return ast::ExprPtr(
+                          std::make_unique<ast::ListExpr>(std::move(exprs)));
+                    },
+                    [](lexy::nullopt = {}) {
+                      return ast::ExprPtr(std::make_unique<ast::ListExpr>(
+                          std::vector<ast::ExprPtr>{}));
+                    });
+  };
 
-    static constexpr auto rule = lexy::dsl::peek(lexy::dsl::lit_c<'['>) >> lexy::dsl::p<ListGrammarInner>;
-    static constexpr auto value = lexy::forward<ast::ExprPtr>;
+  static constexpr auto rule =
+      lexy::dsl::peek(lexy::dsl::lit_c<'['>) >> lexy::dsl::p<ListGrammarInner>;
+  static constexpr auto value = lexy::forward<ast::ExprPtr>;
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/math_expr_grammar.h b/include/cura-formulae-engine/parser/math_expr_grammar.h
index f05ab9c..a0c306e 100644
--- a/include/cura-formulae-engine/parser/math_expr_grammar.h
+++ b/include/cura-formulae-engine/parser/math_expr_grammar.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "bool_grammar.h"
 #include "cura-formulae-engine/ast/binary_expr/add_expr.h"
 #include "cura-formulae-engine/ast/binary_expr/and_expr.h"
 #include "cura-formulae-engine/ast/binary_expr/div_expr.h"
@@ -12,7 +13,6 @@
 #include "cura-formulae-engine/ast/expr_ptr.h"
 #include "cura-formulae-engine/ast/unary_expr/neg_expr.h"
 #include "cura-formulae-engine/ast/unary_expr/not_expr.h"
-#include "bool_grammar.h"
 #include "list_grammar.h"
 #include "none_grammar.h"
 #include "number_grammar.h"
@@ -26,14 +26,12 @@
 #include <memory>
 #include <utility>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct MathExprGrammar : lexy::expression_production
-{
-    static constexpr auto whitespace = lexy::dsl::ascii::space;
+struct MathExprGrammar : lexy::expression_production {
+  static constexpr auto whitespace = lexy::dsl::ascii::space;
 
-    // clang-format off
+  // clang-format off
     static constexpr auto atom
         = lexy::dsl::p<BoolGrammar>
         | lexy::dsl::p<NoneGrammar>
@@ -42,79 +40,71 @@ struct MathExprGrammar : lexy::expression_production
         | lexy::dsl::p<StringGrammar>
         | lexy::dsl::p<ListGrammar>
         | lexy::dsl::p<VariableOrFnApplicationGrammarOrArrayIndexingGrammar>;
-    // clang-format on
-
-    static constexpr auto op_pow = lexy::dsl::op(LEXY_LIT("**"));
-    struct number_power : lexy::dsl::infix_op_right
-    {
-        static constexpr auto op = op_pow;
-        using operand = lexy::dsl::atom;
-    };
-
-    static constexpr auto op_neg = lexy::dsl::op(LEXY_LIT("-"));
-    struct number_prefix : lexy::dsl::prefix_op
-    {
-        static constexpr auto op = op_neg;
-        using operand = number_power;
-    };
-
-    static constexpr auto op_mul = lexy::dsl::op(LEXY_LIT("*"));
-    static constexpr auto op_div = lexy::dsl::op(LEXY_LIT("/"));
-    static constexpr auto op_mod = lexy::dsl::op(LEXY_LIT("%"));
-    struct number_product : lexy::dsl::infix_op_left
-    {
-        using operand = number_prefix;
-        static constexpr auto op = op_mul / op_div / op_mod;
-    };
-
-
-    static constexpr auto op_add = lexy::dsl::op(LEXY_LIT("+"));
-    static constexpr auto op_sub = lexy::dsl::op(LEXY_LIT("-"));
-    struct number_sum : lexy::dsl::infix_op_left
-    {
-        using operand = number_product;
-        static constexpr auto op = op_add / op_sub;
-    };
-
-    static constexpr auto op_eq = lexy::dsl::op(LEXY_LIT("=="));
-    static constexpr auto op_neq = lexy::dsl::op(LEXY_LIT("!="));
-    static constexpr auto op_lt = lexy::dsl::op(LEXY_LIT("<"));
-    static constexpr auto op_gt = lexy::dsl::op(LEXY_LIT(">"));
-    static constexpr auto op_leq = lexy::dsl::op(LEXY_LIT("<="));
-    static constexpr auto op_geq = lexy::dsl::op(LEXY_LIT(">="));
-    static constexpr auto op_not_member = lexy::dsl::op(LEXY_LIT("not in"));
-    static constexpr auto op_member = lexy::dsl::op(LEXY_LIT("in"));
-
-    struct number_compare : lexy::dsl::infix_op_list
-    {
-        using operand = number_sum;
-        static constexpr auto op = op_eq / op_neq / op_lt / op_gt / op_leq / op_geq / op_not_member / op_member;
-    };
-
-    static constexpr auto op_not = lexy::dsl::op(LEXY_LIT("not"));
-    struct bool_prefix : lexy::dsl::prefix_op
-    {
-        static constexpr auto op = op_not;
-        using operand = number_compare;
-    };
-
-    static constexpr auto op_and = lexy::dsl::op(LEXY_LIT("and"));
-    struct bool_and : lexy::dsl::infix_op_left
-    {
-        static constexpr auto op = op_and;
-        using operand = bool_prefix;
-    };
-
-    static constexpr auto op_or = lexy::dsl::op(LEXY_LIT("or"));
-    struct bool_or : lexy::dsl::infix_op_left
-    {
-        static constexpr auto op = op_or;
-        using operand = bool_and;
-    };
-
-    using operation = bool_or;
-
-    // clang-format off
+  // clang-format on
+
+  static constexpr auto op_pow = lexy::dsl::op(LEXY_LIT("**"));
+  struct number_power : lexy::dsl::infix_op_right {
+    static constexpr auto op = op_pow;
+    using operand = lexy::dsl::atom;
+  };
+
+  static constexpr auto op_neg = lexy::dsl::op(LEXY_LIT("-"));
+  struct number_prefix : lexy::dsl::prefix_op {
+    static constexpr auto op = op_neg;
+    using operand = number_power;
+  };
+
+  static constexpr auto op_mul = lexy::dsl::op(LEXY_LIT("*"));
+  static constexpr auto op_div = lexy::dsl::op(LEXY_LIT("/"));
+  static constexpr auto op_mod = lexy::dsl::op(LEXY_LIT("%"));
+  struct number_product : lexy::dsl::infix_op_left {
+    using operand = number_prefix;
+    static constexpr auto op = op_mul / op_div / op_mod;
+  };
+
+  static constexpr auto op_add = lexy::dsl::op(LEXY_LIT("+"));
+  static constexpr auto op_sub = lexy::dsl::op(LEXY_LIT("-"));
+  struct number_sum : lexy::dsl::infix_op_left {
+    using operand = number_product;
+    static constexpr auto op = op_add / op_sub;
+  };
+
+  static constexpr auto op_eq = lexy::dsl::op(LEXY_LIT("=="));
+  static constexpr auto op_neq = lexy::dsl::op(LEXY_LIT("!="));
+  static constexpr auto op_lt = lexy::dsl::op(LEXY_LIT("<"));
+  static constexpr auto op_gt = lexy::dsl::op(LEXY_LIT(">"));
+  static constexpr auto op_leq = lexy::dsl::op(LEXY_LIT("<="));
+  static constexpr auto op_geq = lexy::dsl::op(LEXY_LIT(">="));
+  static constexpr auto op_not_member = lexy::dsl::op(LEXY_LIT("not in"));
+  static constexpr auto op_member = lexy::dsl::op(LEXY_LIT("in"));
+
+  struct number_compare : lexy::dsl::infix_op_list {
+    using operand = number_sum;
+    static constexpr auto op = op_eq / op_neq / op_lt / op_gt / op_leq /
+                               op_geq / op_not_member / op_member;
+  };
+
+  static constexpr auto op_not = lexy::dsl::op(LEXY_LIT("not"));
+  struct bool_prefix : lexy::dsl::prefix_op {
+    static constexpr auto op = op_not;
+    using operand = number_compare;
+  };
+
+  static constexpr auto op_and = lexy::dsl::op(LEXY_LIT("and"));
+  struct bool_and : lexy::dsl::infix_op_left {
+    static constexpr auto op = op_and;
+    using operand = bool_prefix;
+  };
+
+  static constexpr auto op_or = lexy::dsl::op(LEXY_LIT("or"));
+  struct bool_or : lexy::dsl::infix_op_left {
+    static constexpr auto op = op_or;
+    using operand = bool_and;
+  };
+
+  using operation = bool_or;
+
+  // clang-format off
     static constexpr auto value = lexy::fold_inplace<std::unique_ptr<CuraFormulaeEngine::ast::ComparisonChainExpr>>(
         [] { return std::make_unique<CuraFormulaeEngine::ast::ComparisonChainExpr>(); },
         [](auto&& node, lexy::op<op_eq>) { node->operators.emplace_back(CuraFormulaeEngine::ast::ComparisonOperators::Equals); },
@@ -139,7 +129,7 @@ struct MathExprGrammar : lexy::expression_production
         [](ast::ExprPtr&& lhs, lexy::op<op_and>, ast::ExprPtr&& rhs) { return std::move(lhs) && std::move(rhs); },
         [](ast::ExprPtr&& lhs, lexy::op<op_or>, ast::ExprPtr&& rhs) { return std::move(lhs) || std::move(rhs); }
     );
-    // clang-format on
+  // clang-format on
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/nested_grammar.h b/include/cura-formulae-engine/parser/nested_grammar.h
index 1c5ffca..7e9bdaf 100644
--- a/include/cura-formulae-engine/parser/nested_grammar.h
+++ b/include/cura-formulae-engine/parser/nested_grammar.h
@@ -5,15 +5,13 @@
 #include <lexy/callback.hpp>
 #include <lexy/dsl.hpp>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
 // for recursive grammars, equivalent to `struct expr_grammar` but
 // written with a forward declaration
-struct NestedGrammar : lexy::transparent_production
-{
-    static constexpr auto rule = lexy::dsl::recurse<struct ExprGrammar>;
-    static constexpr auto value = lexy::forward<ast::ExprPtr>;
+struct NestedGrammar : lexy::transparent_production {
+  static constexpr auto rule = lexy::dsl::recurse<struct ExprGrammar>;
+  static constexpr auto value = lexy::forward<ast::ExprPtr>;
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/none_grammar.h b/include/cura-formulae-engine/parser/none_grammar.h
index 503ac15..c8f7f20 100644
--- a/include/cura-formulae-engine/parser/none_grammar.h
+++ b/include/cura-formulae-engine/parser/none_grammar.h
@@ -6,13 +6,12 @@
 #include <lexy/callback.hpp>
 #include <lexy/dsl.hpp>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct NoneGrammar
-{
-    static constexpr auto rule = LEXY_LIT("None");
-    static constexpr auto value = lexy::callback<ast::ExprPtr>([]() { return ast::ExprPtr(std::make_unique<ast::NoneExpr>()); });
+struct NoneGrammar {
+  static constexpr auto rule = LEXY_LIT("None");
+  static constexpr auto value = lexy::callback<ast::ExprPtr>(
+      []() { return ast::ExprPtr(std::make_unique<ast::NoneExpr>()); });
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/number_grammar.h b/include/cura-formulae-engine/parser/number_grammar.h
index 1059ee8..75250b6 100644
--- a/include/cura-formulae-engine/parser/number_grammar.h
+++ b/include/cura-formulae-engine/parser/number_grammar.h
@@ -9,22 +9,21 @@
 #include <memory>
 #include <string>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct NumberGrammar : lexy::token_production
-{
-    static constexpr auto rule = lexy::dsl::identifier(lexy::dsl::ascii::digit / lexy::dsl::lit_c<'.'>);
-    static constexpr auto value = lexy::callback<ast::ExprPtr>(
-        [](const auto number)
-        {
-            const auto number_str = std::string(number.begin(), number.end());
-            if (number_str.find('.') != std::string::npos)
-            {
-                return static_cast<ast::ExprPtr>(std::make_unique<ast::FloatExpr>(std::stod(number_str)));
-            }
-            return static_cast<ast::ExprPtr>(std::make_unique<ast::IntExpr>(std::stod(number_str)));
-        });
+struct NumberGrammar : lexy::token_production {
+  static constexpr auto rule =
+      lexy::dsl::identifier(lexy::dsl::ascii::digit / lexy::dsl::lit_c<'.'>);
+  static constexpr auto value =
+      lexy::callback<ast::ExprPtr>([](const auto number) {
+        const auto number_str = std::string(number.begin(), number.end());
+        if (number_str.find('.') != std::string::npos) {
+          return static_cast<ast::ExprPtr>(
+              std::make_unique<ast::FloatExpr>(std::stod(number_str)));
+        }
+        return static_cast<ast::ExprPtr>(
+            std::make_unique<ast::IntExpr>(std::stod(number_str)));
+      });
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/parens_grammar.h b/include/cura-formulae-engine/parser/parens_grammar.h
index d9c579c..b285d1a 100644
--- a/include/cura-formulae-engine/parser/parens_grammar.h
+++ b/include/cura-formulae-engine/parser/parens_grammar.h
@@ -9,23 +9,27 @@
 #include <memory>
 #include <vector>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct ParensGrammar : lexy::token_production
-{
-    static constexpr auto rule
-        = lexy::dsl::round_bracketed.opt_list(lexy::dsl::p<NestedGrammar>, lexy::dsl::ignore_trailing_sep(lexy::dsl::comma >> lexy::dsl::whitespace(lexy::dsl::ascii::space)));
-    static constexpr auto value = lexy::as_list<std::vector<ast::ExprPtr>> >> lexy::callback<ast::ExprPtr>(
-                                      [](std::vector<ast::ExprPtr> exprs)
-                                      {
-                                          if (exprs.size() == 1)
-                                          {
-                                              return std::move(exprs[0]);
-                                          }
-                                          return ast::ExprPtr(std::make_unique<ast::TupleExpr>(std::move(exprs)));
-                                      },
-                                      [](lexy::nullopt = {}) { return ast::ExprPtr(std::make_unique<ast::TupleExpr>(std::vector<ast::ExprPtr>{})); });
+struct ParensGrammar : lexy::token_production {
+  static constexpr auto rule = lexy::dsl::round_bracketed.opt_list(
+      lexy::dsl::p<NestedGrammar>,
+      lexy::dsl::ignore_trailing_sep(
+          lexy::dsl::comma >> lexy::dsl::whitespace(lexy::dsl::ascii::space)));
+  static constexpr auto
+      value = lexy::as_list<std::vector<ast::ExprPtr>> >>
+              lexy::callback<ast::ExprPtr>(
+                  [](std::vector<ast::ExprPtr> exprs) {
+                    if (exprs.size() == 1) {
+                      return std::move(exprs[0]);
+                    }
+                    return ast::ExprPtr(
+                        std::make_unique<ast::TupleExpr>(std::move(exprs)));
+                  },
+                  [](lexy::nullopt = {}) {
+                    return ast::ExprPtr(std::make_unique<ast::TupleExpr>(
+                        std::vector<ast::ExprPtr>{}));
+                  });
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/parser.h b/include/cura-formulae-engine/parser/parser.h
index 118e541..bc3a62a 100644
--- a/include/cura-formulae-engine/parser/parser.h
+++ b/include/cura-formulae-engine/parser/parser.h
@@ -15,13 +15,11 @@
 #include <lexy/input/string_input.hpp>
 #include <string_view>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct Grammar : public lexy::token_production
-{
-    static constexpr auto rule = lexy::dsl::p<ExprGrammar> + lexy::dsl::eof;
-    static constexpr auto value = lexy::forward<ast::ExprPtr>;
+struct Grammar : public lexy::token_production {
+  static constexpr auto rule = lexy::dsl::p<ExprGrammar> + lexy::dsl::eof;
+  static constexpr auto value = lexy::forward<ast::ExprPtr>;
 };
 
 using error_t = typename lexy::validate_result<lexy::_noop>::error_type;
diff --git a/include/cura-formulae-engine/parser/string_grammar.h b/include/cura-formulae-engine/parser/string_grammar.h
index 9ca02b0..d8026f4 100644
--- a/include/cura-formulae-engine/parser/string_grammar.h
+++ b/include/cura-formulae-engine/parser/string_grammar.h
@@ -11,51 +11,49 @@
 #include <lexy/grammar.hpp>
 #include <string>
 
-namespace CuraFormulaeEngine::parser
-{
-
-struct StringGrammar : lexy::token_production
-{
-    static constexpr auto InnerStrGrammar
-        = lexy::dsl::ascii::alpha_digit_underscore
-        / lexy::dsl::lit_c<' '>
-        / lexy::dsl::lit_c<','>
-        / lexy::dsl::lit_c<'/'>
-        / lexy::dsl::lit_c<'.'>
-        / lexy::dsl::lit_c<'_'>
-        / lexy::dsl::lit_c<'-'>
-        / lexy::dsl::lit_c<'+'>
-        / lexy::dsl::lit_c<'('>
-        / lexy::dsl::lit_c<')'>
-        / lexy::dsl::lit_c<';'>
-        / lexy::dsl::lit_c<'\\'>
-        / lexy::dsl::lit_c<'\n'>
-        / lexy::dsl::lit_c<'='>
-        / lexy::dsl::lit_c<'{'>
-        / lexy::dsl::lit_c<'}'>
-        / lexy::dsl::lit_c<'>'>
-        / lexy::dsl::lit_c<'<'>
-        / lexy::dsl::lit_c<':'>
-        / lexy::dsl::lit_c<'/'>
-        / lexy::dsl::lit_c<'!'>;
-    // clang-format on
-
-    struct DoubleQuoteStringGrammar : token_production
-    {
-        static constexpr auto rule = lexy::dsl::lit_c<'\"'> >> lexy::dsl::opt(lexy::dsl::identifier(InnerStrGrammar / lexy::dsl::lit_c<'\''>)) >> lexy::dsl::lit_c<'\"'>;
-        static constexpr auto value = lexy::as_string<std::string>;
-    };
-
-    struct SingleQuoteStringGrammar : token_production
-    {
-        static constexpr auto rule = lexy::dsl::lit_c<'\''> >> lexy::dsl::opt(lexy::dsl::identifier(InnerStrGrammar / lexy::dsl::lit_c<'\"'>)) >> lexy::dsl::lit_c<'\''>;
-        static constexpr auto value = lexy::as_string<std::string>;
-    };
-
-    static constexpr auto rule = DoubleQuoteStringGrammar::rule | SingleQuoteStringGrammar::rule;
-    static constexpr auto value = lexy::callback<ast::ExprPtr>(
-        [](lexy::nullopt = {}) { return CuraFormulaeEngine::ast::make_expr_ptr<ast::StringExpr>(std::string("")); },
-        [](const auto& str) { return CuraFormulaeEngine::ast::make_expr_ptr<ast::StringExpr>(std::string(str.begin(), str.end())); });
+namespace CuraFormulaeEngine::parser {
+
+struct StringGrammar : lexy::token_production {
+  static constexpr auto InnerStrGrammar =
+      lexy::dsl::ascii::alpha_digit_underscore / lexy::dsl::lit_c<' '> /
+      lexy::dsl::lit_c<','> / lexy::dsl::lit_c<'/'> / lexy::dsl::lit_c<'.'> /
+      lexy::dsl::lit_c<'_'> / lexy::dsl::lit_c<'-'> / lexy::dsl::lit_c<'+'> /
+      lexy::dsl::lit_c<'('> / lexy::dsl::lit_c<')'> / lexy::dsl::lit_c<';'> /
+      lexy::dsl::lit_c<'\\'> / lexy::dsl::lit_c<'\n'> / lexy::dsl::lit_c<'='> /
+      lexy::dsl::lit_c<'{'> / lexy::dsl::lit_c<'}'> / lexy::dsl::lit_c<'>'> /
+      lexy::dsl::lit_c<'<'> / lexy::dsl::lit_c<':'> / lexy::dsl::lit_c<'/'> /
+      lexy::dsl::lit_c<'!'>;
+  // clang-format on
+
+  struct DoubleQuoteStringGrammar : token_production {
+    static constexpr auto
+        rule = lexy::dsl::lit_c<'\"'> >>
+               lexy::dsl::opt(lexy::dsl::identifier(InnerStrGrammar /
+                                                    lexy::dsl::lit_c<'\''>)) >>
+               lexy::dsl::lit_c<'\"'>;
+    static constexpr auto value = lexy::as_string<std::string>;
+  };
+
+  struct SingleQuoteStringGrammar : token_production {
+    static constexpr auto
+        rule = lexy::dsl::lit_c<'\''> >>
+               lexy::dsl::opt(lexy::dsl::identifier(InnerStrGrammar /
+                                                    lexy::dsl::lit_c<'\"'>)) >>
+               lexy::dsl::lit_c<'\''>;
+    static constexpr auto value = lexy::as_string<std::string>;
+  };
+
+  static constexpr auto rule =
+      DoubleQuoteStringGrammar::rule | SingleQuoteStringGrammar::rule;
+  static constexpr auto value = lexy::callback<ast::ExprPtr>(
+      [](lexy::nullopt = {}) {
+        return CuraFormulaeEngine::ast::make_expr_ptr<ast::StringExpr>(
+            std::string(""));
+      },
+      [](const auto &str) {
+        return CuraFormulaeEngine::ast::make_expr_ptr<ast::StringExpr>(
+            std::string(str.begin(), str.end()));
+      });
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/variable_grammar.h b/include/cura-formulae-engine/parser/variable_grammar.h
index a25262a..7a5280f 100644
--- a/include/cura-formulae-engine/parser/variable_grammar.h
+++ b/include/cura-formulae-engine/parser/variable_grammar.h
@@ -6,16 +6,16 @@
 #include <lexy/callback.hpp>
 #include <lexy/dsl.hpp>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-struct VariableGrammar : lexy::token_production
-{
-    static constexpr auto rule = lexy::dsl::identifier(lexy::dsl::ascii::alpha_digit_underscore / lexy::dsl::lit_c<'.'>);
-    static constexpr auto value = lexy::callback<ast::ExprPtr>([](const auto&& variable)
-    {
-        return ast::ExprPtr(std::make_unique<ast::VariableExpr>(std::string(variable.begin(), variable.end())));
-    });
+struct VariableGrammar : lexy::token_production {
+  static constexpr auto rule = lexy::dsl::identifier(
+      lexy::dsl::ascii::alpha_digit_underscore / lexy::dsl::lit_c<'.'>);
+  static constexpr auto value =
+      lexy::callback<ast::ExprPtr>([](const auto &&variable) {
+        return ast::ExprPtr(std::make_unique<ast::VariableExpr>(
+            std::string(variable.begin(), variable.end())));
+      });
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/include/cura-formulae-engine/parser/variable_or_fn_application_grammar_or_array_indexing_grammar.h b/include/cura-formulae-engine/parser/variable_or_fn_application_grammar_or_array_indexing_grammar.h
index 3ddbe81..9ee780e 100644
--- a/include/cura-formulae-engine/parser/variable_or_fn_application_grammar_or_array_indexing_grammar.h
+++ b/include/cura-formulae-engine/parser/variable_or_fn_application_grammar_or_array_indexing_grammar.h
@@ -15,131 +15,154 @@
 #include <memory>
 #include <optional>
 
-namespace CuraFormulaeEngine::parser
-{
-
-struct ApplyExpr
-{
-    ApplyExpr() = default;
-    ApplyExpr(const ApplyExpr&) = default;
-    ApplyExpr(ApplyExpr&&) = default;
-    ApplyExpr& operator=(const ApplyExpr&) = default;
-    ApplyExpr& operator=(ApplyExpr&&) = default;
-
-    virtual ~ApplyExpr() = default;
-    virtual ast::ExprPtr apply(ast::ExprPtr&&) = 0;
-};
+namespace CuraFormulaeEngine::parser {
 
-struct IndexExpr final : ApplyExpr
-{
-    IndexExpr() = default;
+struct ApplyExpr {
+  ApplyExpr() = default;
+  ApplyExpr(const ApplyExpr &) = default;
+  ApplyExpr(ApplyExpr &&) = default;
+  ApplyExpr &operator=(const ApplyExpr &) = default;
+  ApplyExpr &operator=(ApplyExpr &&) = default;
 
-    IndexExpr(std::optional<ast::ExprPtr>&& index)
-        : index(std::move(index))
-    {
-    }
+  virtual ~ApplyExpr() = default;
+  virtual ast::ExprPtr apply(ast::ExprPtr &&) = 0;
+};
 
-    std::optional<ast::ExprPtr> index;
+struct IndexExpr final : ApplyExpr {
+  IndexExpr() = default;
 
-    ast::ExprPtr apply(ast::ExprPtr&& array) override { return std::move(array)[std::move(index.value())]; }
-};
+  IndexExpr(std::optional<ast::ExprPtr> &&index) : index(std::move(index)) {}
 
-struct ApplySliceExpr final : ApplyExpr
-{
-    ApplySliceExpr() = default;
-
-    ApplySliceExpr(std::optional<ast::ExprPtr>&& start_index, std::optional<ast::ExprPtr>&& end_index, std::optional<ast::ExprPtr>&& step)
-        : start_index(std::move(start_index))
-        , end_index(std::move(end_index))
-        , step(std::move(step))
-    {
-    }
-
-    std::optional<ast::ExprPtr> start_index;
-    std::optional<ast::ExprPtr> end_index;
-    std::optional<ast::ExprPtr> step;
-
-    ast::ExprPtr apply(ast::ExprPtr&& array) override
-    {
-        return { std::make_unique<ast::SliceExpr>(std::move(array), std::move(start_index), std::move(end_index), std::move(step)) };
-    }
+  std::optional<ast::ExprPtr> index;
+
+  ast::ExprPtr apply(ast::ExprPtr &&array) override {
+    return std::move(array)[std::move(index.value())];
+  }
 };
 
-struct ApplyFnApplicationExpr final : ApplyExpr
-{
-    ApplyFnApplicationExpr() = default;
+struct ApplySliceExpr final : ApplyExpr {
+  ApplySliceExpr() = default;
 
-    ApplyFnApplicationExpr(std::vector<ast::ExprPtr>&& args)
-        : args(std::move(args))
-    {
-    }
+  ApplySliceExpr(std::optional<ast::ExprPtr> &&start_index,
+                 std::optional<ast::ExprPtr> &&end_index,
+                 std::optional<ast::ExprPtr> &&step)
+      : start_index(std::move(start_index)), end_index(std::move(end_index)),
+        step(std::move(step)) {}
 
-    std::vector<ast::ExprPtr> args;
+  std::optional<ast::ExprPtr> start_index;
+  std::optional<ast::ExprPtr> end_index;
+  std::optional<ast::ExprPtr> step;
 
-    ast::ExprPtr apply(ast::ExprPtr&& variable) override { return { std::make_unique<ast::FnApplicationExpr>(std::move(variable), std::move(args)) }; }
+  ast::ExprPtr apply(ast::ExprPtr &&array) override {
+    return {std::make_unique<ast::SliceExpr>(
+        std::move(array), std::move(start_index), std::move(end_index),
+        std::move(step))};
+  }
 };
 
-struct VariableOrFnApplicationGrammarOrArrayIndexingGrammar : lexy::token_production
-{
-    struct SliceElementColon : token_production
-    {
-        static constexpr auto rule = lexy::dsl::if_(lexy::dsl::peek_not(lexy::dsl::colon) >> lexy::dsl::p<NestedGrammar>);
-        static constexpr auto value = lexy::callback<std::optional<ast::ExprPtr>>([](ast::ExprPtr expr) { return expr; }, []() { return std::nullopt; });
-    };
+struct ApplyFnApplicationExpr final : ApplyExpr {
+  ApplyFnApplicationExpr() = default;
 
-    struct SliceElementColonOrBracket : token_production
-    {
-        static constexpr auto rule = lexy::dsl::if_(lexy::dsl::peek_not(lexy::dsl::colon | lexy::dsl::lit_c<']'>) >> lexy::dsl::p<NestedGrammar>);
-        static constexpr auto value = lexy::callback<std::optional<ast::ExprPtr>>([](ast::ExprPtr expr) { return expr; }, []() { return std::nullopt; });
-    };
+  ApplyFnApplicationExpr(std::vector<ast::ExprPtr> &&args)
+      : args(std::move(args)) {}
 
-    struct FnApplicationGrammar : token_production
-    {
-        struct FnApplicationGrammarInner : token_production
-        {
-            static constexpr auto whitespace = lexy::dsl::whitespace(lexy::dsl::ascii::space);
-            static constexpr auto rule = lexy::dsl::round_bracketed.opt_list(lexy::dsl::p<NestedGrammar>, lexy::dsl::ignore_trailing_sep(lexy::dsl::comma));
-            static constexpr auto value
-                = lexy::as_list<std::vector<ast::ExprPtr>> >> lexy::callback<std::unique_ptr<ApplyExpr>>(
-                      [](lexy::nullopt = {}) -> std::unique_ptr<ApplyExpr> { return std::make_unique<ApplyFnApplicationExpr>(); },
-                      [](std::vector<ast::ExprPtr> args) -> std::unique_ptr<ApplyExpr> { return std::make_unique<ApplyFnApplicationExpr>(std::move(args)); });
-        };
-
-        static constexpr auto rule = lexy::dsl::peek(lexy::dsl::lit_c<'('>) >> lexy::dsl::p<FnApplicationGrammarInner>;
-        static constexpr auto value = lexy::forward<std::unique_ptr<ApplyExpr>>;
-    };
+  std::vector<ast::ExprPtr> args;
 
-    struct IndexOrSliceGrammar : token_production
-    {
-        static constexpr auto rule
-            = lexy::dsl::peek(lexy::dsl::lit_c<'['>)
-           >> lexy::dsl::square_bracketed(lexy::dsl::p<SliceElementColon> + lexy::dsl::times<2>(lexy::dsl::if_(lexy::dsl::colon >> lexy::dsl::p<SliceElementColonOrBracket>)));
-        static constexpr auto value = lexy::callback<std::unique_ptr<ApplyExpr>>(
-            [](std::optional<ast::ExprPtr>&& index) { return std::make_unique<IndexExpr>(std::move(index)); },
-            [](std::optional<ast::ExprPtr>&& start_index, std::optional<ast::ExprPtr>&& end_index)
-            { return std::make_unique<ApplySliceExpr>(std::move(start_index), std::move(end_index), std::nullopt); },
-            [](std::optional<ast::ExprPtr>&& start_index, std::optional<ast::ExprPtr>&& end_index, std::optional<ast::ExprPtr>&& step)
-            { return std::make_unique<ApplySliceExpr>(std::move(start_index), std::move(end_index), std::move(step)); });
-    };
+  ast::ExprPtr apply(ast::ExprPtr &&variable) override {
+    return {std::make_unique<ast::FnApplicationExpr>(std::move(variable),
+                                                     std::move(args))};
+  }
+};
 
-    struct List : token_production
-    {
-        static constexpr auto rule = lexy::dsl::list(lexy::dsl::p<FnApplicationGrammar> | lexy::dsl::p<IndexOrSliceGrammar>);
-        static constexpr auto value = lexy::as_list<std::vector<std::unique_ptr<ApplyExpr>>>;
+struct VariableOrFnApplicationGrammarOrArrayIndexingGrammar
+    : lexy::token_production {
+  struct SliceElementColon : token_production {
+    static constexpr auto rule = lexy::dsl::if_(
+        lexy::dsl::peek_not(lexy::dsl::colon) >> lexy::dsl::p<NestedGrammar>);
+    static constexpr auto value = lexy::callback<std::optional<ast::ExprPtr>>(
+        [](ast::ExprPtr expr) { return expr; }, []() { return std::nullopt; });
+  };
+
+  struct SliceElementColonOrBracket : token_production {
+    static constexpr auto rule = lexy::dsl::if_(
+        lexy::dsl::peek_not(lexy::dsl::colon | lexy::dsl::lit_c<']'>) >>
+        lexy::dsl::p<NestedGrammar>);
+    static constexpr auto value = lexy::callback<std::optional<ast::ExprPtr>>(
+        [](ast::ExprPtr expr) { return expr; }, []() { return std::nullopt; });
+  };
+
+  struct FnApplicationGrammar : token_production {
+    struct FnApplicationGrammarInner : token_production {
+      static constexpr auto whitespace =
+          lexy::dsl::whitespace(lexy::dsl::ascii::space);
+      static constexpr auto rule = lexy::dsl::round_bracketed.opt_list(
+          lexy::dsl::p<NestedGrammar>,
+          lexy::dsl::ignore_trailing_sep(lexy::dsl::comma));
+      static constexpr auto value =
+          lexy::as_list<std::vector<ast::ExprPtr>> >>
+          lexy::callback<std::unique_ptr<ApplyExpr>>(
+              [](lexy::nullopt = {}) -> std::unique_ptr<ApplyExpr> {
+                return std::make_unique<ApplyFnApplicationExpr>();
+              },
+              [](std::vector<ast::ExprPtr> args) -> std::unique_ptr<ApplyExpr> {
+                return std::make_unique<ApplyFnApplicationExpr>(
+                    std::move(args));
+              });
     };
 
-    static constexpr auto rule = lexy::dsl::p<VariableGrammar> >> lexy::dsl::if_(lexy::dsl::peek(lexy::dsl::lit_c<'['> | lexy::dsl::lit_c<'('>) >> lexy::dsl::p<List>);
-    static constexpr auto value = lexy::callback<ast::ExprPtr>(
-        [](auto&& expr) { return std::forward<decltype(expr)>(expr); },
-        [](auto&& expr, lexy::nullopt) { return std::forward<decltype(expr)>(expr); },
-        [](auto&& expr, const std::vector<std::unique_ptr<ApplyExpr>>& apply_exprs)
-        {
-            for (const std::unique_ptr<ApplyExpr>& apply_expr : apply_exprs)
-            {
-                expr = apply_expr->apply(std::forward<decltype(expr)>(expr));
-            }
-            return std::forward<decltype(expr)>(expr);
+    static constexpr auto rule = lexy::dsl::peek(lexy::dsl::lit_c<'('>) >>
+                                 lexy::dsl::p<FnApplicationGrammarInner>;
+    static constexpr auto value = lexy::forward<std::unique_ptr<ApplyExpr>>;
+  };
+
+  struct IndexOrSliceGrammar : token_production {
+    static constexpr auto rule =
+        lexy::dsl::peek(lexy::dsl::lit_c<'['>) >>
+        lexy::dsl::square_bracketed(
+            lexy::dsl::p<SliceElementColon> +
+            lexy::dsl::times<2>(lexy::dsl::if_(
+                lexy::dsl::colon >> lexy::dsl::p<SliceElementColonOrBracket>)));
+    static constexpr auto value = lexy::callback<std::unique_ptr<ApplyExpr>>(
+        [](std::optional<ast::ExprPtr> &&index) {
+          return std::make_unique<IndexExpr>(std::move(index));
+        },
+        [](std::optional<ast::ExprPtr> &&start_index,
+           std::optional<ast::ExprPtr> &&end_index) {
+          return std::make_unique<ApplySliceExpr>(
+              std::move(start_index), std::move(end_index), std::nullopt);
+        },
+        [](std::optional<ast::ExprPtr> &&start_index,
+           std::optional<ast::ExprPtr> &&end_index,
+           std::optional<ast::ExprPtr> &&step) {
+          return std::make_unique<ApplySliceExpr>(
+              std::move(start_index), std::move(end_index), std::move(step));
         });
+  };
+
+  struct List : token_production {
+    static constexpr auto rule = lexy::dsl::list(
+        lexy::dsl::p<FnApplicationGrammar> | lexy::dsl::p<IndexOrSliceGrammar>);
+    static constexpr auto value =
+        lexy::as_list<std::vector<std::unique_ptr<ApplyExpr>>>;
+  };
+
+  static constexpr auto
+      rule = lexy::dsl::p<VariableGrammar> >>
+             lexy::dsl::if_(lexy::dsl::peek(lexy::dsl::lit_c<'['> |
+                                            lexy::dsl::lit_c<'('>) >>
+                            lexy::dsl::p<List>);
+  static constexpr auto value = lexy::callback<ast::ExprPtr>(
+      [](auto &&expr) { return std::forward<decltype(expr)>(expr); },
+      [](auto &&expr, lexy::nullopt) {
+        return std::forward<decltype(expr)>(expr);
+      },
+      [](auto &&expr,
+         const std::vector<std::unique_ptr<ApplyExpr>> &apply_exprs) {
+        for (const std::unique_ptr<ApplyExpr> &apply_expr : apply_exprs) {
+          expr = apply_expr->apply(std::forward<decltype(expr)>(expr));
+        }
+        return std::forward<decltype(expr)>(expr);
+      });
 };
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/src/ast/ast.cpp b/src/ast/ast.cpp
index 9b775e2..6d990f0 100644
--- a/src/ast/ast.cpp
+++ b/src/ast/ast.cpp
@@ -1,99 +1,89 @@
 #include "cura-formulae-engine/ast/ast.h"
 
-namespace CuraFormulaeEngine::env
-{
-
-std::optional<eval::Value> EnvironmentMap::get(const std::string& key) const noexcept
-{
-    auto iterator = environment_.find(key);
-    if (iterator == environment_.end())
-    {
-        return std::nullopt;
-    }
-    return iterator->second;
+namespace CuraFormulaeEngine::env {
+
+std::optional<eval::Value>
+EnvironmentMap::get(const std::string &key) const noexcept {
+  auto iterator = environment_.find(key);
+  if (iterator == environment_.end()) {
+    return std::nullopt;
+  }
+  return iterator->second;
 }
 
-bool EnvironmentMap::has(const std::string& key) const noexcept
-{
-    return environment_.find(key) != environment_.end();
+bool EnvironmentMap::has(const std::string &key) const noexcept {
+  return environment_.find(key) != environment_.end();
 }
 
-std::unordered_map<std::string, eval::Value> EnvironmentMap::getAll() const noexcept
-{
-    return environment_;
+std::unordered_map<std::string, eval::Value>
+EnvironmentMap::getAll() const noexcept {
+  return environment_;
 }
 
-bool EnvironmentMap::erase(const std::string& key) noexcept
-{
-    return environment_.erase(key) > 0;
+bool EnvironmentMap::erase(const std::string &key) noexcept {
+  return environment_.erase(key) > 0;
 }
 
-void EnvironmentMap::set(const std::string& key, const eval::Value& value) noexcept
-{
-    environment_.insert_or_assign(key, value);
+void EnvironmentMap::set(const std::string &key,
+                         const eval::Value &value) noexcept {
+  environment_.insert_or_assign(key, value);
 }
 
-void EnvironmentMap::add(const std::unordered_map<std::string, eval::Value>& values)
-{
-    environment_.insert(values.begin(), values.end());
+void EnvironmentMap::add(
+    const std::unordered_map<std::string, eval::Value> &values) {
+  environment_.insert(values.begin(), values.end());
 }
 
-EnvironmentMap EnvironmentMap::clone() const noexcept
-{
-    return EnvironmentMap{ environment_ };
+EnvironmentMap EnvironmentMap::clone() const noexcept {
+  return EnvironmentMap{environment_};
 }
 
-std::optional<eval::Value> LocalEnvironment::getImpl(const std::string& key) const noexcept
-{
-    return local_environment_.get(key);
+std::optional<eval::Value>
+LocalEnvironment::getImpl(const std::string &key) const noexcept {
+  return local_environment_.get(key);
 }
 
-bool LocalEnvironment::hasImpl(const std::string& key) const noexcept
-{
-    return local_environment_.has(key);
+bool LocalEnvironment::hasImpl(const std::string &key) const noexcept {
+  return local_environment_.has(key);
 }
 
-std::unordered_map<std::string, eval::Value> LocalEnvironment::getAllImpl() const noexcept
-{
-    return local_environment_.getAll();
+std::unordered_map<std::string, eval::Value>
+LocalEnvironment::getAllImpl() const noexcept {
+  return local_environment_.getAll();
 }
 
-void LocalEnvironment::set(const std::string& key, const eval::Value& value)
-{
-    local_environment_.set(key, value);
+void LocalEnvironment::set(const std::string &key, const eval::Value &value) {
+  local_environment_.set(key, value);
 }
 
-void LocalEnvironment::add(const std::unordered_map<std::string, eval::Value>& values)
-{
-    local_environment_.add(values);
+void LocalEnvironment::add(
+    const std::unordered_map<std::string, eval::Value> &values) {
+  local_environment_.add(values);
 }
 
-std::optional<eval::Value> ChainableEnvironment::get(const std::string& key) const noexcept
-{
-    std::optional<eval::Value> value = getImpl(key);
-    if (! value.has_value() && shadow_environment_)
-    {
-        value = shadow_environment_->get(key);
-    }
-    return value;
+std::optional<eval::Value>
+ChainableEnvironment::get(const std::string &key) const noexcept {
+  std::optional<eval::Value> value = getImpl(key);
+  if (!value.has_value() && shadow_environment_) {
+    value = shadow_environment_->get(key);
+  }
+  return value;
 }
 
-bool ChainableEnvironment::has(const std::string& key) const noexcept
-{
-    return hasImpl(key) || (shadow_environment_ && shadow_environment_->has(key));
+bool ChainableEnvironment::has(const std::string &key) const noexcept {
+  return hasImpl(key) || (shadow_environment_ && shadow_environment_->has(key));
 }
 
-std::unordered_map<std::string, eval::Value> ChainableEnvironment::getAll() const noexcept
-{
-    std::unordered_map<std::string, eval::Value> all;
-    if (shadow_environment_)
-    {
-        all = shadow_environment_->getAll();
-    }
-
-    auto scoped = getAllImpl();
-    all.insert(scoped.begin(), scoped.end());
-    return all;
+std::unordered_map<std::string, eval::Value>
+ChainableEnvironment::getAll() const noexcept {
+  std::unordered_map<std::string, eval::Value> all;
+  if (shadow_environment_) {
+    all = shadow_environment_->getAll();
+  }
+
+  auto scoped = getAllImpl();
+  all.insert(scoped.begin(), scoped.end());
+  return all;
 }
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/ast/binary_expr/add_expr.cpp b/src/ast/binary_expr/add_expr.cpp
index b8348e4..815a09e 100644
--- a/src/ast/binary_expr/add_expr.cpp
+++ b/src/ast/binary_expr/add_expr.cpp
@@ -4,22 +4,22 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string AddExpr::getOpIdentifier() const noexcept
-{
-    return "+";
+[[nodiscard]] std::string AddExpr::getOpIdentifier() const noexcept {
+  return "+";
 }
 
-eval::Result AddExpr::evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept
-{
-    return lhs + rhs;
+eval::Result AddExpr::evaluate(eval::Value &lhs,
+                               eval::Value &rhs) const noexcept {
+  return lhs + rhs;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator+(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::AddExpr>(std::move(lhs), std::move(rhs));
+CuraFormulaeEngine::ast::ExprPtr
+operator+(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::AddExpr>(std::move(lhs), std::move(rhs));
 }
diff --git a/src/ast/binary_expr/and_expr.cpp b/src/ast/binary_expr/and_expr.cpp
index 5a8c588..39f1629 100644
--- a/src/ast/binary_expr/and_expr.cpp
+++ b/src/ast/binary_expr/and_expr.cpp
@@ -5,22 +5,22 @@
 #include <string>
 #include <variant>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string AndExpr::getOpIdentifier() const noexcept
-{
-    return "and";
+[[nodiscard]] std::string AndExpr::getOpIdentifier() const noexcept {
+  return "and";
 }
 
-eval::Result AndExpr::evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept
-{
-    return lhs && rhs;
+eval::Result AndExpr::evaluate(eval::Value &lhs,
+                               eval::Value &rhs) const noexcept {
+  return lhs && rhs;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator&&(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::AndExpr>(std::move(lhs), std::move(rhs));
+CuraFormulaeEngine::ast::ExprPtr
+operator&&(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::AndExpr>(std::move(lhs), std::move(rhs));
 }
diff --git a/src/ast/binary_expr/binary_expr.cpp b/src/ast/binary_expr/binary_expr.cpp
index e7f0b41..790f6b0 100644
--- a/src/ast/binary_expr/binary_expr.cpp
+++ b/src/ast/binary_expr/binary_expr.cpp
@@ -7,57 +7,53 @@
 #include <string>
 #include <unordered_set>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string BinaryExpr::toString() const noexcept
-{
-    return fmt::format("({} {} {})", lhs.toString(), getOpIdentifier(), rhs.toString());
+[[nodiscard]] std::string BinaryExpr::toString() const noexcept {
+  return fmt::format("({} {} {})", lhs.toString(), getOpIdentifier(),
+                     rhs.toString());
 }
 
-[[nodiscard]] eval::Result BinaryExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    const auto lhs_result = lhs.evaluate(environment);
-    if (! lhs_result.has_value())
-    {
-        return zeus::unexpected(lhs_result.error());
-    }
-    auto lhs_eval = lhs_result.value();
-
-    const auto rhs_result = rhs.evaluate(environment);
-    if (! rhs_result.has_value())
-    {
-        return zeus::unexpected(rhs_result.error());
-    }
-    auto rhs_eval = rhs_result.value();
-
-    return evaluate(lhs_eval, rhs_eval);
+[[nodiscard]] eval::Result
+BinaryExpr::evaluate(const env::Environment *environment) const noexcept {
+  const auto lhs_result = lhs.evaluate(environment);
+  if (!lhs_result.has_value()) {
+    return zeus::unexpected(lhs_result.error());
+  }
+  auto lhs_eval = lhs_result.value();
+
+  const auto rhs_result = rhs.evaluate(environment);
+  if (!rhs_result.has_value()) {
+    return zeus::unexpected(rhs_result.error());
+  }
+  auto rhs_eval = rhs_result.value();
+
+  return evaluate(lhs_eval, rhs_eval);
 }
 
-[[nodiscard]] std::unordered_set<std::string> BinaryExpr::freeVariables() const noexcept
-{
-    auto lhs_free_variables = lhs.freeVariables();
-    auto rhs_free_variables = rhs.freeVariables();
-    lhs_free_variables.insert(rhs_free_variables.begin(), rhs_free_variables.end());
-    return lhs_free_variables;
+[[nodiscard]] std::unordered_set<std::string>
+BinaryExpr::freeVariables() const noexcept {
+  auto lhs_free_variables = lhs.freeVariables();
+  auto rhs_free_variables = rhs.freeVariables();
+  lhs_free_variables.insert(rhs_free_variables.begin(),
+                            rhs_free_variables.end());
+  return lhs_free_variables;
 }
 
-[[nodiscard]] bool BinaryExpr::deepEq(const Expr& other) const noexcept
-{
-    if (typeid(*this) != typeid(other))
-    {
-        return false;
-    }
-    const auto& other_binary_expr = static_cast<const BinaryExpr&>(other);
-    return lhs.deepEq(other_binary_expr.lhs) && rhs.deepEq(other_binary_expr.rhs);
+[[nodiscard]] bool BinaryExpr::deepEq(const Expr &other) const noexcept {
+  if (typeid(*this) != typeid(other)) {
+    return false;
+  }
+  const auto &other_binary_expr = static_cast<const BinaryExpr &>(other);
+  return lhs.deepEq(other_binary_expr.lhs) && rhs.deepEq(other_binary_expr.rhs);
 }
 
-void BinaryExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+void BinaryExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
 
-    lhs.visitAll(visitor);
-    rhs.visitAll(visitor);
+  lhs.visitAll(visitor);
+  rhs.visitAll(visitor);
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/binary_expr/div_expr.cpp b/src/ast/binary_expr/div_expr.cpp
index 8250b16..0196c78 100644
--- a/src/ast/binary_expr/div_expr.cpp
+++ b/src/ast/binary_expr/div_expr.cpp
@@ -4,22 +4,22 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string DivExpr::getOpIdentifier() const noexcept
-{
-    return "/";
+[[nodiscard]] std::string DivExpr::getOpIdentifier() const noexcept {
+  return "/";
 }
 
-eval::Result DivExpr::evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept
-{
-    return lhs / rhs;
+eval::Result DivExpr::evaluate(eval::Value &lhs,
+                               eval::Value &rhs) const noexcept {
+  return lhs / rhs;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator/(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::DivExpr>(std::move(lhs), std::move(rhs));
+CuraFormulaeEngine::ast::ExprPtr
+operator/(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::DivExpr>(std::move(lhs), std::move(rhs));
 }
diff --git a/src/ast/binary_expr/mod_expr.cpp b/src/ast/binary_expr/mod_expr.cpp
index 7c51e96..d0bbae8 100644
--- a/src/ast/binary_expr/mod_expr.cpp
+++ b/src/ast/binary_expr/mod_expr.cpp
@@ -4,22 +4,22 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string ModExpr::getOpIdentifier() const noexcept
-{
-    return "%";
+[[nodiscard]] std::string ModExpr::getOpIdentifier() const noexcept {
+  return "%";
 }
 
-eval::Result ModExpr::evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept
-{
-    return lhs % rhs;
+eval::Result ModExpr::evaluate(eval::Value &lhs,
+                               eval::Value &rhs) const noexcept {
+  return lhs % rhs;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator%(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::ModExpr>(std::move(lhs), std::move(rhs));
+CuraFormulaeEngine::ast::ExprPtr
+operator%(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::ModExpr>(std::move(lhs), std::move(rhs));
 }
diff --git a/src/ast/binary_expr/mul_expr.cpp b/src/ast/binary_expr/mul_expr.cpp
index 1a71d95..2a9bc0d 100644
--- a/src/ast/binary_expr/mul_expr.cpp
+++ b/src/ast/binary_expr/mul_expr.cpp
@@ -3,22 +3,22 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string MulExpr::getOpIdentifier() const noexcept
-{
-    return "*";
+[[nodiscard]] std::string MulExpr::getOpIdentifier() const noexcept {
+  return "*";
 }
 
-eval::Result MulExpr::evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept
-{
-    return lhs * rhs;
+eval::Result MulExpr::evaluate(eval::Value &lhs,
+                               eval::Value &rhs) const noexcept {
+  return lhs * rhs;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator*(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::MulExpr>(std::move(lhs), std::move(rhs));
+CuraFormulaeEngine::ast::ExprPtr
+operator*(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::MulExpr>(std::move(lhs), std::move(rhs));
 }
diff --git a/src/ast/binary_expr/or_expr.cpp b/src/ast/binary_expr/or_expr.cpp
index b778dc6..3d78343 100644
--- a/src/ast/binary_expr/or_expr.cpp
+++ b/src/ast/binary_expr/or_expr.cpp
@@ -4,22 +4,22 @@
 #include <string>
 #include <variant>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string OrExpr::getOpIdentifier() const noexcept
-{
-    return "or";
+[[nodiscard]] std::string OrExpr::getOpIdentifier() const noexcept {
+  return "or";
 }
 
-eval::Result OrExpr::evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept
-{
-    return lhs || rhs;
+eval::Result OrExpr::evaluate(eval::Value &lhs,
+                              eval::Value &rhs) const noexcept {
+  return lhs || rhs;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator||(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::OrExpr>(std::move(lhs), std::move(rhs));
+CuraFormulaeEngine::ast::ExprPtr
+operator||(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::OrExpr>(std::move(lhs), std::move(rhs));
 }
diff --git a/src/ast/binary_expr/pow_expr.cpp b/src/ast/binary_expr/pow_expr.cpp
index c84cd25..8e58d41 100644
--- a/src/ast/binary_expr/pow_expr.cpp
+++ b/src/ast/binary_expr/pow_expr.cpp
@@ -3,17 +3,15 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string PowExpr::getOpIdentifier() const noexcept
-{
-    return "**";
+[[nodiscard]] std::string PowExpr::getOpIdentifier() const noexcept {
+  return "**";
 }
 
-eval::Result PowExpr::evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept
-{
-    return eval::pow(lhs, rhs);
+eval::Result PowExpr::evaluate(eval::Value &lhs,
+                               eval::Value &rhs) const noexcept {
+  return eval::pow(lhs, rhs);
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/binary_expr/sub_expr.cpp b/src/ast/binary_expr/sub_expr.cpp
index 4df0cd7..0e3235f 100644
--- a/src/ast/binary_expr/sub_expr.cpp
+++ b/src/ast/binary_expr/sub_expr.cpp
@@ -3,22 +3,22 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string SubExpr::getOpIdentifier() const noexcept
-{
-    return "-";
+[[nodiscard]] std::string SubExpr::getOpIdentifier() const noexcept {
+  return "-";
 }
 
-eval::Result SubExpr::evaluate(eval::Value& lhs, eval::Value& rhs) const noexcept
-{
-    return lhs - rhs;
+eval::Result SubExpr::evaluate(eval::Value &lhs,
+                               eval::Value &rhs) const noexcept {
+  return lhs - rhs;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator-(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::SubExpr>(std::move(lhs), std::move(rhs));
+CuraFormulaeEngine::ast::ExprPtr
+operator-(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::SubExpr>(std::move(lhs), std::move(rhs));
 }
diff --git a/src/ast/comp_chain_expr.cpp b/src/ast/comp_chain_expr.cpp
index 7304f09..0cf8b87 100644
--- a/src/ast/comp_chain_expr.cpp
+++ b/src/ast/comp_chain_expr.cpp
@@ -6,243 +6,228 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::ast
-{
-
-[[nodiscard]] std::string ComparisonChainExpr::toString() const noexcept
-{
-    std::string result;
-    for (size_t i = 0; i < operators.size(); ++i)
-    {
-        result += expressions[i].toString();
-        switch (operators[i])
-        {
-        case Equals:
-            result += " == ";
-            break;
-        case NotEquals:
-            result += " != ";
-            break;
-        case LessThan:
-            result += " < ";
-            break;
-        case GreaterThan:
-            result += " > ";
-            break;
-        case LessThenEqual:
-            result += " <= ";
-            break;
-        case GreaterThenEqual:
-            result += " >= ";
-            break;
-        case NotMember:
-            result += " not in ";
-            break;
-        case Member:
-            result += " in ";
-            break;
-        }
+namespace CuraFormulaeEngine::ast {
+
+[[nodiscard]] std::string ComparisonChainExpr::toString() const noexcept {
+  std::string result;
+  for (size_t i = 0; i < operators.size(); ++i) {
+    result += expressions[i].toString();
+    switch (operators[i]) {
+    case Equals:
+      result += " == ";
+      break;
+    case NotEquals:
+      result += " != ";
+      break;
+    case LessThan:
+      result += " < ";
+      break;
+    case GreaterThan:
+      result += " > ";
+      break;
+    case LessThenEqual:
+      result += " <= ";
+      break;
+    case GreaterThenEqual:
+      result += " >= ";
+      break;
+    case NotMember:
+      result += " not in ";
+      break;
+    case Member:
+      result += " in ";
+      break;
     }
-    result += expressions.back().toString();
-    return result;
+  }
+  result += expressions.back().toString();
+  return result;
 }
 
-[[nodiscard]] eval::Result ComparisonChainExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    assert(expressions.size() == operators.size() + 1);
+[[nodiscard]] eval::Result ComparisonChainExpr::evaluate(
+    const env::Environment *environment) const noexcept {
+  assert(expressions.size() == operators.size() + 1);
 
-    const auto left_value_result = expressions[0].evaluate(environment);
-    if (!left_value_result.has_value())
-    {
-        return zeus::unexpected(left_value_result.error());
-    }
-    auto left_value = left_value_result.value();
-
-    for (size_t i = 0; i < operators.size(); i ++)
-    {
-        const auto right_value_result = expressions[i + 1].evaluate(environment);
-        if (!right_value_result.has_value())
-        {
-            return zeus::unexpected(right_value_result.error());
-        }
-       const auto& right_value = right_value_result.value();
-
-        eval::Result comparison_result;
-        switch (operators[i])
-        {
-        case Equals:
-            comparison_result = left_value == right_value;
-            break;
-        case NotEquals:
-            comparison_result = !(left_value == right_value);
-            break;
-        case LessThan:
-            comparison_result = left_value < right_value;
-            break;
-        case GreaterThan:
-            comparison_result = left_value > right_value;
-            break;
-        case LessThenEqual:
-            comparison_result = left_value_result.value() <= right_value_result.value();
-            break;
-        case GreaterThenEqual:
-            comparison_result = left_value_result.value() >= right_value_result.value();
-            break;
-        case Member:
-        case NotMember:
-            if (!right_value_result.has_value())
-            {
-                return zeus::unexpected(right_value_result.error());
-            }
-
-            const auto& rhs_value = right_value_result.value();
-            if (!std::holds_alternative<std::vector<eval::Value>>(rhs_value.value))
-            {
-                return zeus::unexpected(eval::Error::TypeMismatch);
-            }
-
-            comparison_result = operators[i] == NotMember;
-
-            const auto& list = std::get<std::vector<eval::Value>>(rhs_value.value);
-            for (const auto& item : list)
-            {
-                if (left_value == item)
-                {
-                    comparison_result = operators[i] == Member;
-                    break;
-                }
-            }
-            break;
-        }
+  const auto left_value_result = expressions[0].evaluate(environment);
+  if (!left_value_result.has_value()) {
+    return zeus::unexpected(left_value_result.error());
+  }
+  auto left_value = left_value_result.value();
 
-        if (!comparison_result.has_value())
-        {
-            return zeus::unexpected(comparison_result.error());
+  for (size_t i = 0; i < operators.size(); i++) {
+    const auto right_value_result = expressions[i + 1].evaluate(environment);
+    if (!right_value_result.has_value()) {
+      return zeus::unexpected(right_value_result.error());
+    }
+    const auto &right_value = right_value_result.value();
+
+    eval::Result comparison_result;
+    switch (operators[i]) {
+    case Equals:
+      comparison_result = left_value == right_value;
+      break;
+    case NotEquals:
+      comparison_result = !(left_value == right_value);
+      break;
+    case LessThan:
+      comparison_result = left_value < right_value;
+      break;
+    case GreaterThan:
+      comparison_result = left_value > right_value;
+      break;
+    case LessThenEqual:
+      comparison_result =
+          left_value_result.value() <= right_value_result.value();
+      break;
+    case GreaterThenEqual:
+      comparison_result =
+          left_value_result.value() >= right_value_result.value();
+      break;
+    case Member:
+    case NotMember:
+      if (!right_value_result.has_value()) {
+        return zeus::unexpected(right_value_result.error());
+      }
+
+      const auto &rhs_value = right_value_result.value();
+      if (!std::holds_alternative<std::vector<eval::Value>>(rhs_value.value)) {
+        return zeus::unexpected(eval::Error::TypeMismatch);
+      }
+
+      comparison_result = operators[i] == NotMember;
+
+      const auto &list = std::get<std::vector<eval::Value>>(rhs_value.value);
+      for (const auto &item : list) {
+        if (left_value == item) {
+          comparison_result = operators[i] == Member;
+          break;
         }
+      }
+      break;
+    }
 
-        if (!comparison_result.value().isTruthy())
-        {
-            return false;
-        }
+    if (!comparison_result.has_value()) {
+      return zeus::unexpected(comparison_result.error());
+    }
 
-        left_value = right_value;
+    if (!comparison_result.value().isTruthy()) {
+      return false;
     }
 
-    return true;
+    left_value = right_value;
+  }
+
+  return true;
 }
 
-[[nodiscard]] std::unordered_set<std::string> ComparisonChainExpr::freeVariables() const noexcept
-{
-    std::unordered_set<std::string> free_vars;
-    for (const auto& expr : expressions)
-    {
-        const auto expr_free_vars = expr.freeVariables();
-        free_vars.insert(expr_free_vars.begin(), expr_free_vars.end());
-    }
-    return free_vars;
+[[nodiscard]] std::unordered_set<std::string>
+ComparisonChainExpr::freeVariables() const noexcept {
+  std::unordered_set<std::string> free_vars;
+  for (const auto &expr : expressions) {
+    const auto expr_free_vars = expr.freeVariables();
+    free_vars.insert(expr_free_vars.begin(), expr_free_vars.end());
+  }
+  return free_vars;
 }
 
-[[nodiscard]] bool ComparisonChainExpr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto other_comp_chain_expr = dynamic_cast<const ComparisonChainExpr*>(&other))
-    {
-        if (operators.size() != other_comp_chain_expr->operators.size() || expressions.size() != other_comp_chain_expr->expressions.size())
-        {
-            return false;
-        }
-        for (size_t i = 0; i < operators.size(); ++i)
-        {
-            if (operators[i] != other_comp_chain_expr->operators[i])
-            {
-                return false;
-            }
-        }
-        for (size_t i = 0; i < expressions.size(); ++i)
-        {
-            if (!expressions[i].deepEq(other_comp_chain_expr->expressions[i]))
-            {
-                return false;
-            }
-        }
-        return true;
+[[nodiscard]] bool
+ComparisonChainExpr::deepEq(const Expr &other) const noexcept {
+  if (const auto other_comp_chain_expr =
+          dynamic_cast<const ComparisonChainExpr *>(&other)) {
+    if (operators.size() != other_comp_chain_expr->operators.size() ||
+        expressions.size() != other_comp_chain_expr->expressions.size()) {
+      return false;
     }
-    return false;
+    for (size_t i = 0; i < operators.size(); ++i) {
+      if (operators[i] != other_comp_chain_expr->operators[i]) {
+        return false;
+      }
+    }
+    for (size_t i = 0; i < expressions.size(); ++i) {
+      if (!expressions[i].deepEq(other_comp_chain_expr->expressions[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
 }
 
-void ComparisonChainExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+void ComparisonChainExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
 
-    for (const auto& expr : expressions)
-    {
-        expr.visitAll(visitor);
-    }
+  for (const auto &expr : expressions) {
+    expr.visitAll(visitor);
+  }
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator==(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
-    expressions.push_back(std::move(lhs));
-    expressions.push_back(std::move(rhs));
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::ComparisonChainExpr>(
-        std::move(expressions),
-        std::vector{ CuraFormulaeEngine::ast::Equals }
-    );
+CuraFormulaeEngine::ast::ExprPtr
+operator==(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs) {
+  std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
+  expressions.push_back(std::move(lhs));
+  expressions.push_back(std::move(rhs));
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::ComparisonChainExpr>(
+      std::move(expressions), std::vector{CuraFormulaeEngine::ast::Equals});
 }
 
-CuraFormulaeEngine::ast::ExprPtr operator!=(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
-    expressions.push_back(std::move(lhs));
-    expressions.push_back(std::move(rhs));
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::ComparisonChainExpr>(
-        std::move(expressions),
-        std::vector{ CuraFormulaeEngine::ast::NotEquals }
-    );
+CuraFormulaeEngine::ast::ExprPtr
+operator!=(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs) {
+  std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
+  expressions.push_back(std::move(lhs));
+  expressions.push_back(std::move(rhs));
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::ComparisonChainExpr>(
+      std::move(expressions), std::vector{CuraFormulaeEngine::ast::NotEquals});
 }
 
-CuraFormulaeEngine::ast::ExprPtr operator>=(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
-    expressions.push_back(std::move(lhs));
-    expressions.push_back(std::move(rhs));
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::ComparisonChainExpr>(
-        std::move(expressions),
-        std::vector{ CuraFormulaeEngine::ast::GreaterThenEqual }
-    );
+CuraFormulaeEngine::ast::ExprPtr
+operator>=(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs) {
+  std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
+  expressions.push_back(std::move(lhs));
+  expressions.push_back(std::move(rhs));
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::ComparisonChainExpr>(
+      std::move(expressions),
+      std::vector{CuraFormulaeEngine::ast::GreaterThenEqual});
 }
 
-CuraFormulaeEngine::ast::ExprPtr operator>(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
-    expressions.push_back(std::move(lhs));
-    expressions.push_back(std::move(rhs));
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::ComparisonChainExpr>(
-        std::move(expressions),
-        std::vector{ CuraFormulaeEngine::ast::GreaterThan }
-    );
+CuraFormulaeEngine::ast::ExprPtr
+operator>(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs) {
+  std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
+  expressions.push_back(std::move(lhs));
+  expressions.push_back(std::move(rhs));
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::ComparisonChainExpr>(
+      std::move(expressions),
+      std::vector{CuraFormulaeEngine::ast::GreaterThan});
 }
 
-CuraFormulaeEngine::ast::ExprPtr operator<=(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
-    expressions.push_back(std::move(lhs));
-    expressions.push_back(std::move(rhs));
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::ComparisonChainExpr>(
-        std::move(expressions),
-        std::vector{ CuraFormulaeEngine::ast::LessThenEqual }
-    );
+CuraFormulaeEngine::ast::ExprPtr
+operator<=(CuraFormulaeEngine::ast::ExprPtr lhs,
+           CuraFormulaeEngine::ast::ExprPtr rhs) {
+  std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
+  expressions.push_back(std::move(lhs));
+  expressions.push_back(std::move(rhs));
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::ComparisonChainExpr>(
+      std::move(expressions),
+      std::vector{CuraFormulaeEngine::ast::LessThenEqual});
 }
 
-CuraFormulaeEngine::ast::ExprPtr operator<(CuraFormulaeEngine::ast::ExprPtr lhs, CuraFormulaeEngine::ast::ExprPtr rhs)
-{
-    std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
-    expressions.push_back(std::move(lhs));
-    expressions.push_back(std::move(rhs));
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::ComparisonChainExpr>(
-        std::move(expressions),
-        std::vector{ CuraFormulaeEngine::ast::LessThan }
-    );
+CuraFormulaeEngine::ast::ExprPtr
+operator<(CuraFormulaeEngine::ast::ExprPtr lhs,
+          CuraFormulaeEngine::ast::ExprPtr rhs) {
+  std::vector<CuraFormulaeEngine::ast::ExprPtr> expressions;
+  expressions.push_back(std::move(lhs));
+  expressions.push_back(std::move(rhs));
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::ComparisonChainExpr>(
+      std::move(expressions), std::vector{CuraFormulaeEngine::ast::LessThan});
 }
diff --git a/src/ast/condition_expr.cpp b/src/ast/condition_expr.cpp
index da10614..61bee50 100644
--- a/src/ast/condition_expr.cpp
+++ b/src/ast/condition_expr.cpp
@@ -7,60 +7,56 @@
 #include <string>
 #include <unordered_set>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string ConditionExpr::toString() const noexcept
-{
-    return fmt::format("({} if {} else {})", then_expr.toString(), condition.toString(), else_expr.toString());
+[[nodiscard]] std::string ConditionExpr::toString() const noexcept {
+  return fmt::format("({} if {} else {})", then_expr.toString(),
+                     condition.toString(), else_expr.toString());
 }
 
-[[nodiscard]] eval::Result ConditionExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    const auto condition_result = condition.evaluate(environment);
-    if (! condition_result.has_value())
-    {
-        return zeus::unexpected(condition_result.error());
-    }
-    const auto& condition_value = condition_result.value();
-
-    if (condition_value.isTruthy())
-    {
-        return then_expr.evaluate(environment);
-    }
-    return else_expr.evaluate(environment);
+[[nodiscard]] eval::Result
+ConditionExpr::evaluate(const env::Environment *environment) const noexcept {
+  const auto condition_result = condition.evaluate(environment);
+  if (!condition_result.has_value()) {
+    return zeus::unexpected(condition_result.error());
+  }
+  const auto &condition_value = condition_result.value();
+
+  if (condition_value.isTruthy()) {
+    return then_expr.evaluate(environment);
+  }
+  return else_expr.evaluate(environment);
 }
 
-[[nodiscard]] std::unordered_set<std::string> ConditionExpr::freeVariables() const noexcept
-{
-    auto condition_vars = condition.freeVariables();
-    auto then_vars = then_expr.freeVariables();
-    auto else_vars = else_expr.freeVariables();
-    condition_vars.insert(then_vars.begin(), then_vars.end());
-    condition_vars.insert(else_vars.begin(), else_vars.end());
-    return condition_vars;
+[[nodiscard]] std::unordered_set<std::string>
+ConditionExpr::freeVariables() const noexcept {
+  auto condition_vars = condition.freeVariables();
+  auto then_vars = then_expr.freeVariables();
+  auto else_vars = else_expr.freeVariables();
+  condition_vars.insert(then_vars.begin(), then_vars.end());
+  condition_vars.insert(else_vars.begin(), else_vars.end());
+  return condition_vars;
 }
 
-[[nodiscard]] bool ConditionExpr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto other_condition_expr = dynamic_cast<const ConditionExpr*>(&other))
-    {
-        // clang-format off
+[[nodiscard]] bool ConditionExpr::deepEq(const Expr &other) const noexcept {
+  if (const auto other_condition_expr =
+          dynamic_cast<const ConditionExpr *>(&other)) {
+    // clang-format off
         return then_expr.deepEq(other_condition_expr->then_expr)
                && condition.deepEq(other_condition_expr->condition)
                && else_expr.deepEq(other_condition_expr->else_expr);
-        // clang-format on
-    }
-    return false;
+    // clang-format on
+  }
+  return false;
 }
 
-void ConditionExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+void ConditionExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
 
-    then_expr.visitAll(visitor);
-    condition.visitAll(visitor);
-    else_expr.visitAll(visitor);
+  then_expr.visitAll(visitor);
+  condition.visitAll(visitor);
+  else_expr.visitAll(visitor);
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/expr_ptr.cpp b/src/ast/expr_ptr.cpp
index 2a7e8eb..aae0ce3 100644
--- a/src/ast/expr_ptr.cpp
+++ b/src/ast/expr_ptr.cpp
@@ -4,42 +4,36 @@
 #include <string>
 #include <unordered_set>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-eval::Result ExprPtr::evaluate(const env::Environment* environment) const noexcept
-{
-    return ptr->evaluate(environment);
+eval::Result
+ExprPtr::evaluate(const env::Environment *environment) const noexcept {
+  return ptr->evaluate(environment);
 }
 
-std::unordered_set<std::string> ExprPtr::freeVariables() const noexcept
-{
-    return ptr->freeVariables();
+std::unordered_set<std::string> ExprPtr::freeVariables() const noexcept {
+  return ptr->freeVariables();
 }
 
-std::string ExprPtr::toString() const noexcept
-{
-    return ptr->toString();
-}
+std::string ExprPtr::toString() const noexcept { return ptr->toString(); }
 
-bool ExprPtr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto& other_ptr = dynamic_cast<const ExprPtr*>(&other))
-    {
-        return ptr->deepEq(*other_ptr->ptr);
-    }
-    return false;
+bool ExprPtr::deepEq(const Expr &other) const noexcept {
+  if (const auto &other_ptr = dynamic_cast<const ExprPtr *>(&other)) {
+    return ptr->deepEq(*other_ptr->ptr);
+  }
+  return false;
 }
 
-void ExprPtr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
-    ptr->visitAll(visitor);
+void ExprPtr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
+  ptr->visitAll(visitor);
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr CuraFormulaeEngine::ast::ExprPtr::operator[](ExprPtr other)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<IndexExpr>(std::move(*this), std::move(other));
+CuraFormulaeEngine::ast::ExprPtr
+CuraFormulaeEngine::ast::ExprPtr::operator[](ExprPtr other) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<IndexExpr>(std::move(*this),
+                                                           std::move(other));
 }
diff --git a/src/ast/fn_application_expr.cpp b/src/ast/fn_application_expr.cpp
index 17d553d..c97f45e 100644
--- a/src/ast/fn_application_expr.cpp
+++ b/src/ast/fn_application_expr.cpp
@@ -13,90 +13,80 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string FnApplicationExpr::toString() const noexcept
-{
-    auto args_str
-            = args | ranges::views::transform([](const auto& arg) { return arg.toString(); }) | ranges::views::join(ranges::views::c_str(", ")) | ranges::to<std::string>();
+[[nodiscard]] std::string FnApplicationExpr::toString() const noexcept {
+  auto args_str =
+      args |
+      ranges::views::transform([](const auto &arg) { return arg.toString(); }) |
+      ranges::views::join(ranges::views::c_str(", ")) |
+      ranges::to<std::string>();
 
-    if (const auto& variable = dynamic_cast<const VariableExpr*>(fn.ptr.get()))
-    {
-        return fmt::format("({}({}))", variable->name, args_str);
-    }
-    return fmt::format("(({})({}))", fn.toString(), args_str);
+  if (const auto &variable = dynamic_cast<const VariableExpr *>(fn.ptr.get())) {
+    return fmt::format("({}({}))", variable->name, args_str);
+  }
+  return fmt::format("(({})({}))", fn.toString(), args_str);
 }
 
-[[nodiscard]] eval::Result FnApplicationExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    const auto fn_result = try_get<eval::Value::fn_t>(fn.evaluate(environment));
-    if (! fn_result.has_value())
-    {
-        return zeus::unexpected(fn_result.error());
-    }
-    const auto& fn_value = fn_result.value();
+[[nodiscard]] eval::Result FnApplicationExpr::evaluate(
+    const env::Environment *environment) const noexcept {
+  const auto fn_result = try_get<eval::Value::fn_t>(fn.evaluate(environment));
+  if (!fn_result.has_value()) {
+    return zeus::unexpected(fn_result.error());
+  }
+  const auto &fn_value = fn_result.value();
 
-    std::vector<eval::Value> arg_results;
-    for (const auto& arg : args)
-    {
-        const auto arg_result = arg.evaluate(environment);
-        if (! arg_result.has_value())
-        {
-            return zeus::unexpected(arg_result.error());
-        }
-        arg_results.push_back(arg_result.value());
+  std::vector<eval::Value> arg_results;
+  for (const auto &arg : args) {
+    const auto arg_result = arg.evaluate(environment);
+    if (!arg_result.has_value()) {
+      return zeus::unexpected(arg_result.error());
     }
+    arg_results.push_back(arg_result.value());
+  }
 
-    return fn_value(arg_results);
+  return fn_value(arg_results);
 }
 
-[[nodiscard]] std::unordered_set<std::string> FnApplicationExpr::freeVariables() const noexcept
-{
-    std::unordered_set<std::string> result;
-    const auto fn_vars = fn.freeVariables();
-    result.insert(fn_vars.begin(), fn_vars.end());
-    for (const auto& arg : args)
-    {
-        const auto arg_vars = arg.freeVariables();
-        result.insert(arg_vars.begin(), arg_vars.end());
-    }
-    return result;
+[[nodiscard]] std::unordered_set<std::string>
+FnApplicationExpr::freeVariables() const noexcept {
+  std::unordered_set<std::string> result;
+  const auto fn_vars = fn.freeVariables();
+  result.insert(fn_vars.begin(), fn_vars.end());
+  for (const auto &arg : args) {
+    const auto arg_vars = arg.freeVariables();
+    result.insert(arg_vars.begin(), arg_vars.end());
+  }
+  return result;
 }
 
-[[nodiscard]] bool FnApplicationExpr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto& other_fn_application = dynamic_cast<const FnApplicationExpr*>(&other))
-    {
-        if (! fn.deepEq(other_fn_application->fn))
-        {
-            return false;
-        }
-        if (args.size() != other_fn_application->args.size())
-        {
-            return false;
-        }
-        for (size_t i = 0; i < args.size(); ++i)
-        {
-            if (! args[i].deepEq(other_fn_application->args[i]))
-            {
-                return false;
-            }
-        }
-        return true;
+[[nodiscard]] bool FnApplicationExpr::deepEq(const Expr &other) const noexcept {
+  if (const auto &other_fn_application =
+          dynamic_cast<const FnApplicationExpr *>(&other)) {
+    if (!fn.deepEq(other_fn_application->fn)) {
+      return false;
     }
-    return false;
+    if (args.size() != other_fn_application->args.size()) {
+      return false;
+    }
+    for (size_t i = 0; i < args.size(); ++i) {
+      if (!args[i].deepEq(other_fn_application->args[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
 }
 
-void FnApplicationExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+void FnApplicationExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
 
-    fn.visitAll(visitor);
-    for (const auto& arg : args)
-    {
-        arg.visitAll(visitor);
-    }
+  fn.visitAll(visitor);
+  for (const auto &arg : args) {
+    arg.visitAll(visitor);
+  }
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/index_expr.cpp b/src/ast/index_expr.cpp
index 99f8669..0673498 100644
--- a/src/ast/index_expr.cpp
+++ b/src/ast/index_expr.cpp
@@ -10,55 +10,50 @@
 #include <unordered_set>
 #include <variant>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string IndexExpr::toString() const noexcept
-{
-    return fmt::format("{}[{}]", array.toString(), index.toString());
+[[nodiscard]] std::string IndexExpr::toString() const noexcept {
+  return fmt::format("{}[{}]", array.toString(), index.toString());
 }
 
-[[nodiscard]] eval::Result IndexExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    const auto array_result = array.evaluate(environment);
-    if (! array_result.has_value())
-    {
-        return zeus::unexpected(array_result.error());
-    }
-    const auto& array_value = array_result.value();
-
-    const auto index_result = index.evaluate(environment);
-    if (! index_result.has_value())
-    {
-        return zeus::unexpected(index_result.error());
-    }
-    const auto& index_value = index_result.value();
-
-    return array_value[index_value];
+[[nodiscard]] eval::Result
+IndexExpr::evaluate(const env::Environment *environment) const noexcept {
+  const auto array_result = array.evaluate(environment);
+  if (!array_result.has_value()) {
+    return zeus::unexpected(array_result.error());
+  }
+  const auto &array_value = array_result.value();
+
+  const auto index_result = index.evaluate(environment);
+  if (!index_result.has_value()) {
+    return zeus::unexpected(index_result.error());
+  }
+  const auto &index_value = index_result.value();
+
+  return array_value[index_value];
 }
 
-[[nodiscard]] std::unordered_set<std::string> IndexExpr::freeVariables() const noexcept
-{
-    auto array_vars = array.freeVariables();
-    auto index_vars = index.freeVariables();
-    array_vars.insert(index_vars.begin(), index_vars.end());
-    return array_vars;
+[[nodiscard]] std::unordered_set<std::string>
+IndexExpr::freeVariables() const noexcept {
+  auto array_vars = array.freeVariables();
+  auto index_vars = index.freeVariables();
+  array_vars.insert(index_vars.begin(), index_vars.end());
+  return array_vars;
 }
 
-[[nodiscard]] bool IndexExpr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto other_index_expr = dynamic_cast<const IndexExpr*>(&other))
-    {
-        return array.deepEq(other_index_expr->array) && index.deepEq(other_index_expr->index);
-    }
-    return false;
+[[nodiscard]] bool IndexExpr::deepEq(const Expr &other) const noexcept {
+  if (const auto other_index_expr = dynamic_cast<const IndexExpr *>(&other)) {
+    return array.deepEq(other_index_expr->array) &&
+           index.deepEq(other_index_expr->index);
+  }
+  return false;
 }
 
-void IndexExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
-    array.visitAll(visitor);
-    index.visitAll(visitor);
+void IndexExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
+  array.visitAll(visitor);
+  index.visitAll(visitor);
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/list_comprehension_expr.cpp b/src/ast/list_comprehension_expr.cpp
index 14e509a..7fb564a 100644
--- a/src/ast/list_comprehension_expr.cpp
+++ b/src/ast/list_comprehension_expr.cpp
@@ -15,193 +15,171 @@
 #include <vector>
 #include <zeus/expected.hpp>
 
-namespace CuraFormulaeEngine::ast
-{
-
-[[nodiscard]] std::string ListComprehensionExpr::toString() const noexcept
-{
-    const auto loops_str = loops
-                           | ranges::views::transform(
-            [](const auto& loop)
-            {
-                if (loop.conditions.empty())
-                {
-                    return fmt::format("for {} in {}", loop.iterator_key.toString(), loop.iterable.toString());
-                }
-                const auto conditions_str = loop.conditions
-                                            | ranges::views::transform([](const auto& condition) { return fmt::format("if {}", condition.toString()); })
-                                            | ranges::views::join(ranges::views::c_str(" ")) | ranges::to<std::string>();
-                return fmt::format("for {} in {} {}", loop.iterator_key.toString(), loop.iterable.toString(), conditions_str);
-            })
-                           | ranges::views::join(ranges::views::c_str(" ")) | ranges::to<std::string>();
-
-    return fmt::format("({} {})", iterator.toString(), loops_str);
+namespace CuraFormulaeEngine::ast {
+
+[[nodiscard]] std::string ListComprehensionExpr::toString() const noexcept {
+  const auto loops_str =
+      loops | ranges::views::transform([](const auto &loop) {
+        if (loop.conditions.empty()) {
+          return fmt::format("for {} in {}", loop.iterator_key.toString(),
+                             loop.iterable.toString());
+        }
+        const auto conditions_str =
+            loop.conditions |
+            ranges::views::transform([](const auto &condition) {
+              return fmt::format("if {}", condition.toString());
+            }) |
+            ranges::views::join(ranges::views::c_str(" ")) |
+            ranges::to<std::string>();
+        return fmt::format("for {} in {} {}", loop.iterator_key.toString(),
+                           loop.iterable.toString(), conditions_str);
+      }) |
+      ranges::views::join(ranges::views::c_str(" ")) |
+      ranges::to<std::string>();
+
+  return fmt::format("({} {})", iterator.toString(), loops_str);
 }
 
-std::optional<eval::Error> ListComprehensionExpr::handle_loop(const size_t loop_index, env::LocalEnvironment& local_environment, std::vector<eval::Value>& results) const
-{
-    if (loop_index >= loops.size())
-    {
-        assert(loops.size() == 0 && "loops in list comprehension cannot be empty");
-        throw std::runtime_error("loops in list comprehension cannot be empty");
+std::optional<eval::Error>
+ListComprehensionExpr::handle_loop(const size_t loop_index,
+                                   env::LocalEnvironment &local_environment,
+                                   std::vector<eval::Value> &results) const {
+  if (loop_index >= loops.size()) {
+    assert(loops.size() == 0 && "loops in list comprehension cannot be empty");
+    throw std::runtime_error("loops in list comprehension cannot be empty");
+  }
+
+  const auto &loop = loops[loop_index];
+  const auto iterable_result = try_get<std::vector<eval::Value>>(
+      loop.iterable.evaluate(&local_environment));
+  if (!iterable_result.has_value()) {
+    return iterable_result.error();
+  }
+  const auto iterable_value = iterable_result.value();
+
+  for (const auto &element : iterable_value) {
+    for (const auto &key : loop.iterator_key.freeVariables()) {
+      local_environment.set(key, element);
     }
 
-    const auto& loop = loops[loop_index];
-    const auto iterable_result = try_get<std::vector<eval::Value>>(loop.iterable.evaluate(&local_environment));
-    if (! iterable_result.has_value())
-    {
-        return iterable_result.error();
+    auto exit_loop = false;
+    for (const auto &condition : loop.conditions) {
+      const auto condition_result = condition.evaluate(&local_environment);
+      if (!condition_result.has_value()) {
+        return condition_result.error();
+      }
+      const auto &condition_value = condition_result.value();
+
+      if (!condition_value.isTruthy()) {
+        exit_loop = true;
+        break;
+      }
     }
-    const auto iterable_value = iterable_result.value();
-
-    for (const auto& element : iterable_value)
-    {
-        for (const auto& key : loop.iterator_key.freeVariables())
-        {
-            local_environment.set(key, element);
-        }
-
-        auto exit_loop = false;
-        for (const auto& condition : loop.conditions)
-        {
-            const auto condition_result = condition.evaluate(&local_environment);
-            if (! condition_result.has_value())
-            {
-                return condition_result.error();
-            }
-            const auto& condition_value = condition_result.value();
-
-            if (! condition_value.isTruthy())
-            {
-                exit_loop = true;
-                break;
-            }
-        }
 
-        if (exit_loop)
-        {
-            continue;
-        }
+    if (exit_loop) {
+      continue;
+    }
 
-        if (loop_index + 1 == loops.size())
-        {
-            const auto iterator_result = iterator.evaluate(&local_environment);
-            if (! iterator_result.has_value())
-            {
-                return iterator_result.error();
-            }
-            results.push_back(iterator_result.value());
-        }
-        else
-        {
-            const auto loop_err = handle_loop(loop_index + 1, local_environment, results);
-            if (loop_err.has_value())
-            {
-                return loop_err.value();
-            }
-        }
+    if (loop_index + 1 == loops.size()) {
+      const auto iterator_result = iterator.evaluate(&local_environment);
+      if (!iterator_result.has_value()) {
+        return iterator_result.error();
+      }
+      results.push_back(iterator_result.value());
+    } else {
+      const auto loop_err =
+          handle_loop(loop_index + 1, local_environment, results);
+      if (loop_err.has_value()) {
+        return loop_err.value();
+      }
     }
+  }
 
-    return std::nullopt;
+  return std::nullopt;
 }
 
-[[nodiscard]] eval::Result ListComprehensionExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    env::LocalEnvironment local_environment { environment };
-    std::vector<eval::Value> results;
-    const auto loop_err = handle_loop(0, local_environment, results);
-    if (loop_err.has_value())
-    {
-        return zeus::unexpected(loop_err.value());
-    }
-    return eval::Value{ results };
+[[nodiscard]] eval::Result ListComprehensionExpr::evaluate(
+    const env::Environment *environment) const noexcept {
+  env::LocalEnvironment local_environment{environment};
+  std::vector<eval::Value> results;
+  const auto loop_err = handle_loop(0, local_environment, results);
+  if (loop_err.has_value()) {
+    return zeus::unexpected(loop_err.value());
+  }
+  return eval::Value{results};
 }
 
-[[nodiscard]] std::unordered_set<std::string> ListComprehensionExpr::freeVariables() const noexcept
-{
-    std::unordered_set<std::string> free_variables = {};
-    std::unordered_set<std::string> local_variables = {};
-    for (const auto& loop : loops)
-    {
-        for (const auto& key : loop.iterable.freeVariables())
-        {
-            if (local_variables.contains(key))
-            {
-                continue;
-            }
-            free_variables.insert(key);
-        }
-        for (const auto& condition : loop.conditions)
-        {
-            for (const auto& key : condition.freeVariables())
-            {
-                if (local_variables.contains(key))
-                {
-                    continue;
-                }
-                free_variables.insert(key);
-            }
-        }
-        for (const auto& key : loop.iterator_key.freeVariables())
-        {
-            local_variables.insert(key);
+[[nodiscard]] std::unordered_set<std::string>
+ListComprehensionExpr::freeVariables() const noexcept {
+  std::unordered_set<std::string> free_variables = {};
+  std::unordered_set<std::string> local_variables = {};
+  for (const auto &loop : loops) {
+    for (const auto &key : loop.iterable.freeVariables()) {
+      if (local_variables.contains(key)) {
+        continue;
+      }
+      free_variables.insert(key);
+    }
+    for (const auto &condition : loop.conditions) {
+      for (const auto &key : condition.freeVariables()) {
+        if (local_variables.contains(key)) {
+          continue;
         }
+        free_variables.insert(key);
+      }
     }
-    return free_variables;
+    for (const auto &key : loop.iterator_key.freeVariables()) {
+      local_variables.insert(key);
+    }
+  }
+  return free_variables;
 }
 
-[[nodiscard]] bool ListComprehensionExpr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto other_list_comprehension = dynamic_cast<const ListComprehensionExpr*>(&other))
-    {
-        if (loops.size() != other_list_comprehension->loops.size())
-        {
-            return false;
-        }
+[[nodiscard]] bool
+ListComprehensionExpr::deepEq(const Expr &other) const noexcept {
+  if (const auto other_list_comprehension =
+          dynamic_cast<const ListComprehensionExpr *>(&other)) {
+    if (loops.size() != other_list_comprehension->loops.size()) {
+      return false;
+    }
 
-        for (const auto [loop, other_loop] : ranges::views::zip(loops, other_list_comprehension->loops))
-        {
-            if (! loop.iterator_key.deepEq(other_loop.iterator_key))
-            {
-                return false;
-            }
-            if (! loop.iterable.deepEq(other_loop.iterable))
-            {
-                return false;
-            }
-            if (loop.conditions.size() != other_loop.conditions.size())
-            {
-                return false;
-            }
-            for (const auto [condition, other_condition] : ranges::views::zip(loop.conditions, other_loop.conditions))
-            {
-                if (! condition.deepEq(other_condition))
-                {
-                    return false;
-                }
-            }
+    for (const auto [loop, other_loop] :
+         ranges::views::zip(loops, other_list_comprehension->loops)) {
+      if (!loop.iterator_key.deepEq(other_loop.iterator_key)) {
+        return false;
+      }
+      if (!loop.iterable.deepEq(other_loop.iterable)) {
+        return false;
+      }
+      if (loop.conditions.size() != other_loop.conditions.size()) {
+        return false;
+      }
+      for (const auto [condition, other_condition] :
+           ranges::views::zip(loop.conditions, other_loop.conditions)) {
+        if (!condition.deepEq(other_condition)) {
+          return false;
         }
-
-        return iterator.deepEq(other_list_comprehension->iterator);
+      }
     }
-    return false;
+
+    return iterator.deepEq(other_list_comprehension->iterator);
+  }
+  return false;
 }
 
-void ListComprehensionExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+void ListComprehensionExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
 
-    iterator.visitAll(visitor);
+  iterator.visitAll(visitor);
 
-    for (const auto& loop : loops)
-    {
-        loop.iterator_key.visitAll(visitor);
-        loop.iterable.visitAll(visitor);
-        for (const auto& condition : loop.conditions)
-        {
-            condition.visitAll(visitor);
-        }
+  for (const auto &loop : loops) {
+    loop.iterator_key.visitAll(visitor);
+    loop.iterable.visitAll(visitor);
+    for (const auto &condition : loop.conditions) {
+      condition.visitAll(visitor);
     }
+  }
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/list_expr.cpp b/src/ast/list_expr.cpp
index 8cb4280..4bfaa26 100644
--- a/src/ast/list_expr.cpp
+++ b/src/ast/list_expr.cpp
@@ -14,73 +14,66 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
+[[nodiscard]] std::string ListExpr::toString() const noexcept {
+  auto elements_str = elements |
+                      ranges::views::transform([](const auto &element) {
+                        return element.toString();
+                      }) |
+                      ranges::views::join(ranges::views::c_str(", ")) |
+                      ranges::to<std::string>();
 
-[[nodiscard]] std::string ListExpr::toString() const noexcept
-{
-    auto elements_str = elements | ranges::views::transform([](const auto& element) { return element.toString(); }) | ranges::views::join(ranges::views::c_str(", "))
-                        | ranges::to<std::string>();
-
-    return fmt::format("[{}]", elements_str);
+  return fmt::format("[{}]", elements_str);
 }
 
-[[nodiscard]] eval::Result ListExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    std::vector<eval::Value> results;
-    for (const auto& element : elements)
-    {
-        const auto result = element.evaluate(environment);
-        if (! result.has_value())
-        {
-            return zeus::unexpected(result.error());
-        }
-        results.push_back(result.value());
+[[nodiscard]] eval::Result
+ListExpr::evaluate(const env::Environment *environment) const noexcept {
+  std::vector<eval::Value> results;
+  for (const auto &element : elements) {
+    const auto result = element.evaluate(environment);
+    if (!result.has_value()) {
+      return zeus::unexpected(result.error());
     }
-    return std::move(results);
+    results.push_back(result.value());
+  }
+  return std::move(results);
 }
 
-[[nodiscard]] std::unordered_set<std::string> ListExpr::freeVariables() const noexcept
-{
-    std::unordered_set<std::string> result;
-    for (const auto& element : elements)
-    {
-        const auto element_vars = element.freeVariables();
-        result.insert(element_vars.begin(), element_vars.end());
-    }
-    return result;
+[[nodiscard]] std::unordered_set<std::string>
+ListExpr::freeVariables() const noexcept {
+  std::unordered_set<std::string> result;
+  for (const auto &element : elements) {
+    const auto element_vars = element.freeVariables();
+    result.insert(element_vars.begin(), element_vars.end());
+  }
+  return result;
 }
 
-[[nodiscard]] bool ListExpr::deepEq(const Expr& other) const noexcept
-{
-    if (auto other_list_expr = dynamic_cast<const ListExpr*>(&other))
-    {
-        if (elements.size() != other_list_expr->elements.size())
-        {
-            return false;
-        }
+[[nodiscard]] bool ListExpr::deepEq(const Expr &other) const noexcept {
+  if (auto other_list_expr = dynamic_cast<const ListExpr *>(&other)) {
+    if (elements.size() != other_list_expr->elements.size()) {
+      return false;
+    }
 
-        for (const auto [element, other_element] : ranges::views::zip(elements, other_list_expr->elements))
-        {
-            if (! element.deepEq(other_element))
-            {
-                return false;
-            }
-        }
-        return true;
+    for (const auto [element, other_element] :
+         ranges::views::zip(elements, other_list_expr->elements)) {
+      if (!element.deepEq(other_element)) {
+        return false;
+      }
     }
-    return false;
+    return true;
+  }
+  return false;
 }
 
-void ListExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+void ListExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
 
-    for (const auto& element : elements)
-    {
-        element.visitAll(visitor);
-    }
+  for (const auto &element : elements) {
+    element.visitAll(visitor);
+  }
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/primary_expr/string_expr.cpp b/src/ast/primary_expr/string_expr.cpp
index 60e12fc..9fc1ae3 100644
--- a/src/ast/primary_expr/string_expr.cpp
+++ b/src/ast/primary_expr/string_expr.cpp
@@ -4,12 +4,10 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-std::string StringExpr::toString() const noexcept
-{
-    return fmt::format("\"{}\"", value);
+std::string StringExpr::toString() const noexcept {
+  return fmt::format("\"{}\"", value);
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/slice_expr.cpp b/src/ast/slice_expr.cpp
index dc1df12..0c80d2f 100644
--- a/src/ast/slice_expr.cpp
+++ b/src/ast/slice_expr.cpp
@@ -1,7 +1,7 @@
+#include "cura-formulae-engine/ast/slice_expr.h"
 #include "cura-formulae-engine/ast/ast.h"
 #include "cura-formulae-engine/ast/expr_ptr.h"
 #include "cura-formulae-engine/eval.h"
-#include "cura-formulae-engine/ast/slice_expr.h"
 
 #include <zeus/expected.hpp>
 
@@ -11,157 +11,159 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::ast
-{
-
-[[nodiscard]] std::string SliceExpr::toString() const noexcept
-{
-    const auto start_index_str = start_index.has_value() ? start_index.value().toString() : "";
-    const auto end_index_str = end_index.has_value() ? end_index.value().toString() : "";
-    const auto step_size_str = step_size.has_value() ? step_size.value().toString() : "";
-    return fmt::format("{}[{}:{}:{}]", array.toString(), start_index_str, end_index_str, step_size_str);
+namespace CuraFormulaeEngine::ast {
+
+[[nodiscard]] std::string SliceExpr::toString() const noexcept {
+  const auto start_index_str =
+      start_index.has_value() ? start_index.value().toString() : "";
+  const auto end_index_str =
+      end_index.has_value() ? end_index.value().toString() : "";
+  const auto step_size_str =
+      step_size.has_value() ? step_size.value().toString() : "";
+  return fmt::format("{}[{}:{}:{}]", array.toString(), start_index_str,
+                     end_index_str, step_size_str);
 }
 
-[[nodiscard]] eval::Result SliceExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    std::int64_t step_size_value = int64_t(1);
-    if (step_size.has_value())
-    {
-        const auto end_index_result = try_get<std::int64_t>(step_size.value().evaluate(environment));
-        if (! end_index_result.has_value())
-        {
-            return zeus::unexpected(end_index_result.error());
-        }
-        step_size_value = end_index_result.value();
-
-        if (step_size_value == int64_t(0))
-        {
-            return zeus::unexpected(eval::Error::ValueError);
-        }
+[[nodiscard]] eval::Result
+SliceExpr::evaluate(const env::Environment *environment) const noexcept {
+  std::int64_t step_size_value = int64_t(1);
+  if (step_size.has_value()) {
+    const auto end_index_result =
+        try_get<std::int64_t>(step_size.value().evaluate(environment));
+    if (!end_index_result.has_value()) {
+      return zeus::unexpected(end_index_result.error());
     }
+    step_size_value = end_index_result.value();
 
-    const auto array_result = try_get<std::vector<eval::Value>>(array.evaluate(environment));
-    if (! array_result.has_value())
-    {
-        return zeus::unexpected(array_result.error());
+    if (step_size_value == int64_t(0)) {
+      return zeus::unexpected(eval::Error::ValueError);
     }
-    const auto& array_value = array_result.value();
-
-    std::int64_t start_index_absolute_value = step_size_value > 0 ? 0 : int64_t(array_value.size()) - 1;
-    if (start_index.has_value())
-    {
-        const auto start_index_result = try_get<std::int64_t>(start_index.value().evaluate(environment));
-        if (! start_index_result.has_value())
-        {
-            return zeus::unexpected(start_index_result.error());
-        }
-        const auto start_index_value = start_index_result.value();
-
-        if (start_index_value < int64_t(0))
-        {
-            start_index_absolute_value = int64_t(array_value.size()) - -start_index_value - int64_t(1);
-            start_index_absolute_value = std::max(start_index_absolute_value, int64_t(0));
-        }
-        else
-        {
-            start_index_absolute_value = start_index_value;
-            start_index_absolute_value = std::min(start_index_absolute_value, static_cast<std::int64_t>(array_value.size()) - int64_t(1));
-        }
-        start_index_absolute_value = std::min(start_index_absolute_value, static_cast<std::int64_t>(array_value.size()) - int64_t(1));
+  }
+
+  const auto array_result =
+      try_get<std::vector<eval::Value>>(array.evaluate(environment));
+  if (!array_result.has_value()) {
+    return zeus::unexpected(array_result.error());
+  }
+  const auto &array_value = array_result.value();
+
+  std::int64_t start_index_absolute_value =
+      step_size_value > 0 ? 0 : int64_t(array_value.size()) - 1;
+  if (start_index.has_value()) {
+    const auto start_index_result =
+        try_get<std::int64_t>(start_index.value().evaluate(environment));
+    if (!start_index_result.has_value()) {
+      return zeus::unexpected(start_index_result.error());
     }
-
-    std::int64_t end_index_absolute_value = step_size_value > int64_t(0) ? static_cast<std::int64_t>(array_value.size()) - int64_t(1) : int64_t(0);
-    if (end_index.has_value())
-    {
-        const auto end_index_result = try_get<std::int64_t>(end_index.value().evaluate(environment));
-        if (! end_index_result.has_value())
-        {
-            return zeus::unexpected(end_index_result.error());
-        }
-        const auto end_index_value = end_index_result.value();
-
-        if (end_index_value < int64_t(0))
-        {
-            end_index_absolute_value = int64_t(array_value.size()) - -end_index_value - int64_t(1);
-            end_index_absolute_value = std::max(end_index_absolute_value, int64_t(0));
-        }
-        else
-        {
-            end_index_absolute_value = end_index_value;
-            end_index_absolute_value = std::min(end_index_absolute_value, static_cast<std::int64_t>(array_value.size()) - int64_t(1));
-        }
+    const auto start_index_value = start_index_result.value();
+
+    if (start_index_value < int64_t(0)) {
+      start_index_absolute_value =
+          int64_t(array_value.size()) - -start_index_value - int64_t(1);
+      start_index_absolute_value =
+          std::max(start_index_absolute_value, int64_t(0));
+    } else {
+      start_index_absolute_value = start_index_value;
+      start_index_absolute_value =
+          std::min(start_index_absolute_value,
+                   static_cast<std::int64_t>(array_value.size()) - int64_t(1));
     }
-
-    std::vector<eval::Value> result;
-
-    if (step_size_value > 0)
-    {
-        for (std::int64_t i = start_index_absolute_value; i <= end_index_absolute_value; i += step_size_value)
-        {
-            result.push_back(array_value[size_t(i)]);
-        }
+    start_index_absolute_value =
+        std::min(start_index_absolute_value,
+                 static_cast<std::int64_t>(array_value.size()) - int64_t(1));
+  }
+
+  std::int64_t end_index_absolute_value =
+      step_size_value > int64_t(0)
+          ? static_cast<std::int64_t>(array_value.size()) - int64_t(1)
+          : int64_t(0);
+  if (end_index.has_value()) {
+    const auto end_index_result =
+        try_get<std::int64_t>(end_index.value().evaluate(environment));
+    if (!end_index_result.has_value()) {
+      return zeus::unexpected(end_index_result.error());
     }
-    else
-    {
-        for (std::int64_t i = start_index_absolute_value; i >= end_index_absolute_value; i += step_size_value)
-        {
-            result.push_back(array_value[size_t(i)]);
-        }
+    const auto end_index_value = end_index_result.value();
+
+    if (end_index_value < int64_t(0)) {
+      end_index_absolute_value =
+          int64_t(array_value.size()) - -end_index_value - int64_t(1);
+      end_index_absolute_value = std::max(end_index_absolute_value, int64_t(0));
+    } else {
+      end_index_absolute_value = end_index_value;
+      end_index_absolute_value =
+          std::min(end_index_absolute_value,
+                   static_cast<std::int64_t>(array_value.size()) - int64_t(1));
     }
+  }
 
-    return result;
-}
+  std::vector<eval::Value> result;
 
-[[nodiscard]] std::unordered_set<std::string> SliceExpr::freeVariables() const noexcept
-{
-    auto free_vars = array.freeVariables();
-    if (start_index.has_value())
-    {
-        const auto start_index_vars = start_index.value().freeVariables();
-        free_vars.insert(start_index_vars.begin(), start_index_vars.end());
+  if (step_size_value > 0) {
+    for (std::int64_t i = start_index_absolute_value;
+         i <= end_index_absolute_value; i += step_size_value) {
+      result.push_back(array_value[size_t(i)]);
     }
-    if (end_index.has_value())
-    {
-        const auto end_index_vars = end_index.value().freeVariables();
-        free_vars.insert(end_index_vars.begin(), end_index_vars.end());
+  } else {
+    for (std::int64_t i = start_index_absolute_value;
+         i >= end_index_absolute_value; i += step_size_value) {
+      result.push_back(array_value[size_t(i)]);
     }
-    if (step_size.has_value())
-    {
-        const auto step_size_vars = step_size.value().freeVariables();
-        free_vars.insert(step_size_vars.begin(), step_size_vars.end());
-    }
-    return free_vars;
+  }
+
+  return result;
 }
 
-[[nodiscard]] bool SliceExpr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto other_slice_expr = dynamic_cast<const SliceExpr*>(&other))
-    {
-        return array.deepEq(other_slice_expr->array) && start_index.has_value() == other_slice_expr->start_index.has_value()
-               && (! start_index.has_value() || start_index.value().deepEq(other_slice_expr->start_index.value()))
-               && end_index.has_value() == other_slice_expr->end_index.has_value() && (! end_index.has_value() || end_index.value().deepEq(other_slice_expr->end_index.value()))
-               && step_size.has_value() == other_slice_expr->step_size.has_value() && (! step_size.has_value() || step_size.value().deepEq(other_slice_expr->step_size.value()));
-    }
-    return false;
+[[nodiscard]] std::unordered_set<std::string>
+SliceExpr::freeVariables() const noexcept {
+  auto free_vars = array.freeVariables();
+  if (start_index.has_value()) {
+    const auto start_index_vars = start_index.value().freeVariables();
+    free_vars.insert(start_index_vars.begin(), start_index_vars.end());
+  }
+  if (end_index.has_value()) {
+    const auto end_index_vars = end_index.value().freeVariables();
+    free_vars.insert(end_index_vars.begin(), end_index_vars.end());
+  }
+  if (step_size.has_value()) {
+    const auto step_size_vars = step_size.value().freeVariables();
+    free_vars.insert(step_size_vars.begin(), step_size_vars.end());
+  }
+  return free_vars;
 }
 
-void SliceExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+[[nodiscard]] bool SliceExpr::deepEq(const Expr &other) const noexcept {
+  if (const auto other_slice_expr = dynamic_cast<const SliceExpr *>(&other)) {
+    return array.deepEq(other_slice_expr->array) &&
+           start_index.has_value() ==
+               other_slice_expr->start_index.has_value() &&
+           (!start_index.has_value() ||
+            start_index.value().deepEq(
+                other_slice_expr->start_index.value())) &&
+           end_index.has_value() == other_slice_expr->end_index.has_value() &&
+           (!end_index.has_value() ||
+            end_index.value().deepEq(other_slice_expr->end_index.value())) &&
+           step_size.has_value() == other_slice_expr->step_size.has_value() &&
+           (!step_size.has_value() ||
+            step_size.value().deepEq(other_slice_expr->step_size.value()));
+  }
+  return false;
+}
 
-    array.visitAll(visitor);
-    if (start_index.has_value())
-    {
-        start_index.value().visitAll(visitor);
-    }
-    if (end_index.has_value())
-    {
-        end_index.value().visitAll(visitor);
-    }
-    if (step_size.has_value())
-    {
-        step_size.value().visitAll(visitor);
-    }
+void SliceExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
+
+  array.visitAll(visitor);
+  if (start_index.has_value()) {
+    start_index.value().visitAll(visitor);
+  }
+  if (end_index.has_value()) {
+    end_index.value().visitAll(visitor);
+  }
+  if (step_size.has_value()) {
+    step_size.value().visitAll(visitor);
+  }
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/tuple_expr.cpp b/src/ast/tuple_expr.cpp
index 3008b3c..608d7fc 100644
--- a/src/ast/tuple_expr.cpp
+++ b/src/ast/tuple_expr.cpp
@@ -14,72 +14,65 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
+[[nodiscard]] std::string TupleExpr::toString() const noexcept {
+  auto elements_str = elements |
+                      ranges::views::transform([](const auto &element) {
+                        return element.toString();
+                      }) |
+                      ranges::views::join(ranges::views::c_str(", ")) |
+                      ranges::to<std::string>();
 
-[[nodiscard]] std::string TupleExpr::toString() const noexcept
-{
-    auto elements_str = elements | ranges::views::transform([](const auto& element) { return element.toString(); }) | ranges::views::join(ranges::views::c_str(", "))
-                        | ranges::to<std::string>();
-
-    return fmt::format("({})", elements_str);
+  return fmt::format("({})", elements_str);
 }
 
-[[nodiscard]] eval::Result TupleExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    std::vector<eval::Value> results;
-    for (const auto& element : elements)
-    {
-        auto result = element.evaluate(environment);
-        if (! result.has_value())
-        {
-            return zeus::unexpected(result.error());
-        }
-        results.push_back(result.value());
+[[nodiscard]] eval::Result
+TupleExpr::evaluate(const env::Environment *environment) const noexcept {
+  std::vector<eval::Value> results;
+  for (const auto &element : elements) {
+    auto result = element.evaluate(environment);
+    if (!result.has_value()) {
+      return zeus::unexpected(result.error());
     }
-    return std::move(results);
+    results.push_back(result.value());
+  }
+  return std::move(results);
 }
 
-[[nodiscard]] std::unordered_set<std::string> TupleExpr::freeVariables() const noexcept
-{
-    std::unordered_set<std::string> result;
-    for (const auto& element : elements)
-    {
-        auto element_vars = element.freeVariables();
-        result.insert(element_vars.begin(), element_vars.end());
-    }
-    return result;
+[[nodiscard]] std::unordered_set<std::string>
+TupleExpr::freeVariables() const noexcept {
+  std::unordered_set<std::string> result;
+  for (const auto &element : elements) {
+    auto element_vars = element.freeVariables();
+    result.insert(element_vars.begin(), element_vars.end());
+  }
+  return result;
 }
 
-[[nodiscard]] bool TupleExpr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto* other_tuple_expr = dynamic_cast<const TupleExpr*>(&other))
-    {
-        if (elements.size() != other_tuple_expr->elements.size())
-        {
-            return false;
-        }
-        for (const auto [element, other_element] : ranges::views::zip(elements, other_tuple_expr->elements))
-        {
-            if (! element.deepEq(other_element))
-            {
-                return false;
-            }
-        }
-        return true;
+[[nodiscard]] bool TupleExpr::deepEq(const Expr &other) const noexcept {
+  if (const auto *other_tuple_expr = dynamic_cast<const TupleExpr *>(&other)) {
+    if (elements.size() != other_tuple_expr->elements.size()) {
+      return false;
     }
-    return false;
+    for (const auto [element, other_element] :
+         ranges::views::zip(elements, other_tuple_expr->elements)) {
+      if (!element.deepEq(other_element)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
 }
 
-void TupleExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+void TupleExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
 
-    for (const auto& element : elements)
-    {
-        element.visitAll(visitor);
-    }
+  for (const auto &element : elements) {
+    element.visitAll(visitor);
+  }
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/unary_expr/neg_expr.cpp b/src/ast/unary_expr/neg_expr.cpp
index f90cc35..090d55f 100644
--- a/src/ast/unary_expr/neg_expr.cpp
+++ b/src/ast/unary_expr/neg_expr.cpp
@@ -2,22 +2,21 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string NegExpr::getOpIdentifier() const noexcept
-{
-    return "-";
+[[nodiscard]] std::string NegExpr::getOpIdentifier() const noexcept {
+  return "-";
 }
 
-[[nodiscard]] eval::Result NegExpr::evaluate(const eval::Value& eval_value) const noexcept
-{
-    return -eval_value;
+[[nodiscard]] eval::Result
+NegExpr::evaluate(const eval::Value &eval_value) const noexcept {
+  return -eval_value;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator-(CuraFormulaeEngine::ast::ExprPtr operand)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::NegExpr>(std::move(operand));
+CuraFormulaeEngine::ast::ExprPtr
+operator-(CuraFormulaeEngine::ast::ExprPtr operand) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::NegExpr>(std::move(operand));
 }
diff --git a/src/ast/unary_expr/not_expr.cpp b/src/ast/unary_expr/not_expr.cpp
index 6f18cc3..8461fcb 100644
--- a/src/ast/unary_expr/not_expr.cpp
+++ b/src/ast/unary_expr/not_expr.cpp
@@ -2,22 +2,21 @@
 
 #include <string>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string NotExpr::getOpIdentifier() const noexcept
-{
-    return "not";
+[[nodiscard]] std::string NotExpr::getOpIdentifier() const noexcept {
+  return "not";
 }
 
-[[nodiscard]] eval::Result NotExpr::evaluate(const eval::Value& eval_value) const noexcept
-{
-    return ! eval_value;
+[[nodiscard]] eval::Result
+NotExpr::evaluate(const eval::Value &eval_value) const noexcept {
+  return !eval_value;
 }
 
 } // namespace CuraFormulaeEngine::ast
 
-CuraFormulaeEngine::ast::ExprPtr operator!(CuraFormulaeEngine::ast::ExprPtr operand)
-{
-    return CuraFormulaeEngine::ast::make_expr_ptr<CuraFormulaeEngine::ast::NotExpr>(std::move(operand));
+CuraFormulaeEngine::ast::ExprPtr
+operator!(CuraFormulaeEngine::ast::ExprPtr operand) {
+  return CuraFormulaeEngine::ast::make_expr_ptr<
+      CuraFormulaeEngine::ast::NotExpr>(std::move(operand));
 }
diff --git a/src/ast/unary_expr/unary_expr.cpp b/src/ast/unary_expr/unary_expr.cpp
index 2819ae5..312c3e9 100644
--- a/src/ast/unary_expr/unary_expr.cpp
+++ b/src/ast/unary_expr/unary_expr.cpp
@@ -6,44 +6,39 @@
 #include <string>
 #include <unordered_set>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-[[nodiscard]] std::string UnaryExpr::toString() const noexcept
-{
-    return fmt::format("({} {})", getOpIdentifier(), operand.toString());
+[[nodiscard]] std::string UnaryExpr::toString() const noexcept {
+  return fmt::format("({} {})", getOpIdentifier(), operand.toString());
 }
 
-[[nodiscard]] eval::Result UnaryExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    const auto operand_result = operand.evaluate(environment);
-    if (! operand_result.has_value())
-    {
-        return zeus::unexpected(operand_result.error());
-    }
-    const auto operand_value = operand_result.value();
-    return evaluate(operand_value);
+[[nodiscard]] eval::Result
+UnaryExpr::evaluate(const env::Environment *environment) const noexcept {
+  const auto operand_result = operand.evaluate(environment);
+  if (!operand_result.has_value()) {
+    return zeus::unexpected(operand_result.error());
+  }
+  const auto operand_value = operand_result.value();
+  return evaluate(operand_value);
 }
 
-[[nodiscard]] std::unordered_set<std::string> UnaryExpr::freeVariables() const noexcept
-{
-    return operand.freeVariables();
+[[nodiscard]] std::unordered_set<std::string>
+UnaryExpr::freeVariables() const noexcept {
+  return operand.freeVariables();
 }
 
-[[nodiscard]] bool UnaryExpr::deepEq(const Expr& other) const noexcept
-{
-    if (typeid(*this) != typeid(other))
-    {
-        return false;
-    }
-    const auto& other_UnaryExpr = static_cast<const UnaryExpr&>(other);
-    return operand.deepEq(other_UnaryExpr.operand);
+[[nodiscard]] bool UnaryExpr::deepEq(const Expr &other) const noexcept {
+  if (typeid(*this) != typeid(other)) {
+    return false;
+  }
+  const auto &other_UnaryExpr = static_cast<const UnaryExpr &>(other);
+  return operand.deepEq(other_UnaryExpr.operand);
 }
 
-void UnaryExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
-    operand.visitAll(visitor);
+void UnaryExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
+  operand.visitAll(visitor);
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/ast/variable_expr.cpp b/src/ast/variable_expr.cpp
index 3ac4479..853e31a 100644
--- a/src/ast/variable_expr.cpp
+++ b/src/ast/variable_expr.cpp
@@ -7,40 +7,32 @@
 #include <string>
 #include <unordered_set>
 
-namespace CuraFormulaeEngine::ast
-{
+namespace CuraFormulaeEngine::ast {
 
-std::string VariableExpr::toString() const noexcept
-{
-    return name;
-}
+std::string VariableExpr::toString() const noexcept { return name; }
 
-eval::Result VariableExpr::evaluate(const env::Environment* environment) const noexcept
-{
-    if (const auto value = environment->get(name); value.has_value())
-    {
-        return value.value();
-    }
-    return zeus::unexpected(eval::Error::UndefinedVariable);
+eval::Result
+VariableExpr::evaluate(const env::Environment *environment) const noexcept {
+  if (const auto value = environment->get(name); value.has_value()) {
+    return value.value();
+  }
+  return zeus::unexpected(eval::Error::UndefinedVariable);
 }
 
-std::unordered_set<std::string> VariableExpr::freeVariables() const noexcept
-{
-    return { name };
+std::unordered_set<std::string> VariableExpr::freeVariables() const noexcept {
+  return {name};
 }
 
-bool VariableExpr::deepEq(const Expr& other) const noexcept
-{
-    if (const auto* other_variable = dynamic_cast<const VariableExpr*>(&other))
-    {
-        return name == other_variable->name;
-    }
-    return false;
+bool VariableExpr::deepEq(const Expr &other) const noexcept {
+  if (const auto *other_variable = dynamic_cast<const VariableExpr *>(&other)) {
+    return name == other_variable->name;
+  }
+  return false;
 }
 
-void VariableExpr::visitAll(std::function<void(const Expr&)> visitor) const noexcept
-{
-    visitor(*this);
+void VariableExpr::visitAll(
+    std::function<void(const Expr &)> visitor) const noexcept {
+  visitor(*this);
 }
 
 } // namespace CuraFormulaeEngine::ast
diff --git a/src/env/abs.cpp b/src/env/abs.cpp
index 00499ae..e190cfd 100644
--- a/src/env/abs.cpp
+++ b/src/env/abs.cpp
@@ -8,29 +8,25 @@
 
 namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t abs = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-
-    const auto &value = args[0];
-    if (std::holds_alternative<bool>(value.value))
-    {
-        return std::get<bool>(value.value) ? eval::Value(int64_t(1)) : eval::Value(int64_t(0));
-    }
-    if (std::holds_alternative<double>(value.value))
-    {
-        return std::abs(std::get<double>(value.value));
-    }
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return std::abs(std::get<std::int64_t>(value.value));
-    }
-
-
-    return zeus::unexpected(eval::Error::TypeMismatch);
+const eval::Value::fn_t abs =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  const auto &value = args[0];
+  if (std::holds_alternative<bool>(value.value)) {
+    return std::get<bool>(value.value) ? eval::Value(int64_t(1))
+                                       : eval::Value(int64_t(0));
+  }
+  if (std::holds_alternative<double>(value.value)) {
+    return std::abs(std::get<double>(value.value));
+  }
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return std::abs(std::get<std::int64_t>(value.value));
+  }
+
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/all.cpp b/src/env/all.cpp
index 61c1e3d..4a0c91e 100644
--- a/src/env/all.cpp
+++ b/src/env/all.cpp
@@ -6,21 +6,19 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t all = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-    if (! std::holds_alternative<std::vector<eval::Value>>(args[0].value))
-    {
-        return zeus::unexpected(eval::Error::TypeMismatch);
-    }
-    const auto& elements = std::get<std::vector<eval::Value>>(args[0].value);
-    return ranges::all_of(elements, [](const auto& element) { return element.isTruthy(); });
+const eval::Value::fn_t all =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+  if (!std::holds_alternative<std::vector<eval::Value>>(args[0].value)) {
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
+  const auto &elements = std::get<std::vector<eval::Value>>(args[0].value);
+  return ranges::all_of(elements,
+                        [](const auto &element) { return element.isTruthy(); });
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/any.cpp b/src/env/any.cpp
index 44c06d4..e820b08 100644
--- a/src/env/any.cpp
+++ b/src/env/any.cpp
@@ -6,21 +6,19 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t any = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-    if (! std::holds_alternative<std::vector<eval::Value>>(args[0].value))
-    {
-        return zeus::unexpected(eval::Error::TypeMismatch);
-    }
-    const auto& elements = std::get<std::vector<eval::Value>>(args[0].value);
-    return ranges::any_of(elements, [](const auto& element) { return element.isTruthy(); });
+const eval::Value::fn_t any =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+  if (!std::holds_alternative<std::vector<eval::Value>>(args[0].value)) {
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
+  const auto &elements = std::get<std::vector<eval::Value>>(args[0].value);
+  return ranges::any_of(elements,
+                        [](const auto &element) { return element.isTruthy(); });
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/env.cpp b/src/env/env.cpp
index fdc4075..a6fe037 100644
--- a/src/env/env.cpp
+++ b/src/env/env.cpp
@@ -29,45 +29,43 @@
 #include <limits>
 #include <numbers>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
 /**
  * @brief The standard environment.
  */
-CURA_FORMULAE_ENGINE_API const EnvironmentMap std_env = []()
-{
-    EnvironmentMap env;
+CURA_FORMULAE_ENGINE_API const EnvironmentMap std_env = []() {
+  EnvironmentMap env;
 
-    env.set("abs", eval::Value(abs));
-    env.set("all", eval::Value(all));
-    env.set("any", eval::Value(any));
-    env.set("float", eval::Value(float_fn));
-    env.set("int", eval::Value(int_fn));
-    env.set("len", eval::Value(len));
-    env.set("map", eval::Value(map));
-    env.set("math.atan", eval::Value(math_atan));
-    env.set("math.ceil", eval::Value(math_ceil));
-    env.set("math.cos", eval::Value(math_cos));
-    env.set("math.degrees", eval::Value(math_degrees));
-    env.set("math.e", eval::Value(std::numbers::e));
-    env.set("math.floor", eval::Value(math_floor));
-    env.set("math.inf", eval::Value(std::numeric_limits<double>::infinity()));
-    env.set("math.log", eval::Value(math_log));
-    env.set("math.nan", eval::Value(std::nan("1")));
-    env.set("math.pi", eval::Value(std::numbers::pi));
-    env.set("math.sin", eval::Value(math_sin));
-    env.set("math.tan", eval::Value(math_tan));
-    env.set("math.tau", eval::Value(std::numbers::pi * 2.0));
-    env.set("math.radians", eval::Value(math_radians));
-    env.set("math.sqrt", eval::Value(math_sqrt));
-    env.set("max", eval::Value(max));
-    env.set("min", eval::Value(min));
-    env.set("round", eval::Value(round));
-    env.set("sum", eval::Value(sum));
-    env.set("str", eval::Value(str));
+  env.set("abs", eval::Value(abs));
+  env.set("all", eval::Value(all));
+  env.set("any", eval::Value(any));
+  env.set("float", eval::Value(float_fn));
+  env.set("int", eval::Value(int_fn));
+  env.set("len", eval::Value(len));
+  env.set("map", eval::Value(map));
+  env.set("math.atan", eval::Value(math_atan));
+  env.set("math.ceil", eval::Value(math_ceil));
+  env.set("math.cos", eval::Value(math_cos));
+  env.set("math.degrees", eval::Value(math_degrees));
+  env.set("math.e", eval::Value(std::numbers::e));
+  env.set("math.floor", eval::Value(math_floor));
+  env.set("math.inf", eval::Value(std::numeric_limits<double>::infinity()));
+  env.set("math.log", eval::Value(math_log));
+  env.set("math.nan", eval::Value(std::nan("1")));
+  env.set("math.pi", eval::Value(std::numbers::pi));
+  env.set("math.sin", eval::Value(math_sin));
+  env.set("math.tan", eval::Value(math_tan));
+  env.set("math.tau", eval::Value(std::numbers::pi * 2.0));
+  env.set("math.radians", eval::Value(math_radians));
+  env.set("math.sqrt", eval::Value(math_sqrt));
+  env.set("max", eval::Value(max));
+  env.set("min", eval::Value(min));
+  env.set("round", eval::Value(round));
+  env.set("sum", eval::Value(sum));
+  env.set("str", eval::Value(str));
 
-    return env;
+  return env;
 }();
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/float_fn.cpp b/src/env/float_fn.cpp
index 5a6f0ea..90af474 100644
--- a/src/env/float_fn.cpp
+++ b/src/env/float_fn.cpp
@@ -6,34 +6,28 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t float_fn = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
+const eval::Value::fn_t float_fn =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
 
-    const auto& value = args[0];
-    if (std::holds_alternative<double>(value.value))
-    {
-        return std::get<double>(value.value);
-    }
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return { std::get<std::int64_t>(value.value) };
-    }
-    if (std::holds_alternative<std::string>(value.value))
-    {
-        return std::stod(std::get<std::string>(value.value));
-    }
-    if (std::holds_alternative<bool>(value.value))
-    {
-        return std::get<bool>(value.value) ? 1.0 : 0.0;
-    }
-    return zeus::unexpected(eval::Error::TypeMismatch);
+  const auto &value = args[0];
+  if (std::holds_alternative<double>(value.value)) {
+    return std::get<double>(value.value);
+  }
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return {std::get<std::int64_t>(value.value)};
+  }
+  if (std::holds_alternative<std::string>(value.value)) {
+    return std::stod(std::get<std::string>(value.value));
+  }
+  if (std::holds_alternative<bool>(value.value)) {
+    return std::get<bool>(value.value) ? 1.0 : 0.0;
+  }
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/int_fn.cpp b/src/env/int_fn.cpp
index 59c0023..3c09846 100644
--- a/src/env/int_fn.cpp
+++ b/src/env/int_fn.cpp
@@ -7,49 +7,41 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t int_fn = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() == 2)
-    {
-        if (std::holds_alternative<std::string>(args[0].value) && std::holds_alternative<std::int64_t>(args[1].value))
-        {
-            const auto& str = std::get<std::string>(args[0].value);
-            const auto& base = std::get<std::int64_t>(args[1].value);
-            if (base < 2 || base > 36)
-            {
-                return zeus::unexpected(eval::Error::ValueError);
-            }
-            return std::int64_t(std::stoll(str, nullptr, int(base)));
-        }
-        return zeus::unexpected(eval::Error::TypeMismatch);
+const eval::Value::fn_t int_fn =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() == 2) {
+    if (std::holds_alternative<std::string>(args[0].value) &&
+        std::holds_alternative<std::int64_t>(args[1].value)) {
+      const auto &str = std::get<std::string>(args[0].value);
+      const auto &base = std::get<std::int64_t>(args[1].value);
+      if (base < 2 || base > 36) {
+        return zeus::unexpected(eval::Error::ValueError);
+      }
+      return std::int64_t(std::stoll(str, nullptr, int(base)));
     }
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
 
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
 
-    const auto& x = args[0];
-    if (std::holds_alternative<std::int64_t>(x.value))
-    {
-        return std::get<std::int64_t>(x.value);
-    }
-    if (std::holds_alternative<double>(x.value))
-    {
-        return static_cast<std::int64_t>(std::round(std::get<double>(x.value)));
-    }
-    if (std::holds_alternative<bool>(x.value))
-    {
-        return std::get<bool>(x.value) ? int64_t(1) : int64_t(0);
-    }
-    if (std::holds_alternative<std::string>(x.value))
-    {
-        return static_cast<std::int64_t>(std::stod(std::get<std::string>(x.value)));
-    }
-    return zeus::unexpected(eval::Error::TypeMismatch);
+  const auto &x = args[0];
+  if (std::holds_alternative<std::int64_t>(x.value)) {
+    return std::get<std::int64_t>(x.value);
+  }
+  if (std::holds_alternative<double>(x.value)) {
+    return static_cast<std::int64_t>(std::round(std::get<double>(x.value)));
+  }
+  if (std::holds_alternative<bool>(x.value)) {
+    return std::get<bool>(x.value) ? int64_t(1) : int64_t(0);
+  }
+  if (std::holds_alternative<std::string>(x.value)) {
+    return static_cast<std::int64_t>(std::stod(std::get<std::string>(x.value)));
+  }
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/len.cpp b/src/env/len.cpp
index 7160fd9..b0a9c8f 100644
--- a/src/env/len.cpp
+++ b/src/env/len.cpp
@@ -5,21 +5,18 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t len = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-    if (! std::holds_alternative<std::vector<eval::Value>>(args[0].value))
-    {
-        return zeus::unexpected(eval::Error::TypeMismatch);
-    }
-    const auto& elements = std::get<std::vector<eval::Value>>(args[0].value);
-    return eval::Value{ static_cast<std::int64_t>(elements.size()) };
+const eval::Value::fn_t len =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+  if (!std::holds_alternative<std::vector<eval::Value>>(args[0].value)) {
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
+  const auto &elements = std::get<std::vector<eval::Value>>(args[0].value);
+  return eval::Value{static_cast<std::int64_t>(elements.size())};
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/map.cpp b/src/env/map.cpp
index 2ec7403..0361d21 100644
--- a/src/env/map.cpp
+++ b/src/env/map.cpp
@@ -5,39 +5,33 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t map = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 2)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t map =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 2) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  if (!std::holds_alternative<eval::Value::fn_t>(args[0].value)) {
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
+  if (!std::holds_alternative<std::vector<eval::Value>>(args[1].value)) {
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
+
+  const auto fn = std::get<eval::Value::fn_t>(args[0].value);
+  const auto list = std::get<std::vector<eval::Value>>(args[1].value);
+
+  std::vector<eval::Value> result;
+  for (const auto &element : list) {
+    const auto mapped = fn({element});
+    if (!mapped.has_value()) {
+      return zeus::unexpected(eval::Error::TypeMismatch);
     }
-
-    if (! std::holds_alternative<eval::Value::fn_t>(args[0].value))
-    {
-        return zeus::unexpected(eval::Error::TypeMismatch);
-    }
-    if (! std::holds_alternative<std::vector<eval::Value>>(args[1].value))
-    {
-        return zeus::unexpected(eval::Error::TypeMismatch);
-    }
-
-    const auto fn = std::get<eval::Value::fn_t>(args[0].value);
-    const auto list = std::get<std::vector<eval::Value>>(args[1].value);
-
-    std::vector<eval::Value> result;
-    for (const auto& element : list)
-    {
-        const auto mapped = fn({ element });
-        if (! mapped.has_value())
-        {
-            return zeus::unexpected(eval::Error::TypeMismatch);
-        }
-        result.push_back(mapped.value());
-    }
-    return result;
+    result.push_back(mapped.value());
+  }
+  return result;
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_atan.cpp b/src/env/math_atan.cpp
index 567481a..0f1283f 100644
--- a/src/env/math_atan.cpp
+++ b/src/env/math_atan.cpp
@@ -5,26 +5,22 @@
 #include <cmath>
 #include <variant>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t math_atan = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
+const eval::Value::fn_t math_atan =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
 
-    const auto& value = args[0];
-    if (std::holds_alternative<double>(value.value))
-    {
-        return std::atan(std::get<double>(value.value));
-    }
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return std::atan(std::get<std::int64_t>(value.value));
-    }
-    return zeus::unexpected(eval::Error::TypeMismatch);
+  const auto &value = args[0];
+  if (std::holds_alternative<double>(value.value)) {
+    return std::atan(std::get<double>(value.value));
+  }
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return std::atan(std::get<std::int64_t>(value.value));
+  }
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_ceil.cpp b/src/env/math_ceil.cpp
index a021e50..8d35991 100644
--- a/src/env/math_ceil.cpp
+++ b/src/env/math_ceil.cpp
@@ -5,31 +5,26 @@
 #include <cmath>
 #include <variant>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t math_ceil = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
+const eval::Value::fn_t math_ceil =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
 
-    const auto& value = args[0];
+  const auto &value = args[0];
 
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return eval::Value(std::ceil(std::get<std::int64_t>(value.value)));
-    }
-    if (std::holds_alternative<double>(value.value))
-    {
-        return eval::Value(std::ceil(std::get<double>(value.value)));
-    }
-    if (std::holds_alternative<bool>(value.value))
-    {
-        return eval::Value(std::ceil(std::get<bool>(value.value)));
-    }
-    return zeus::unexpected(eval::Error::TypeMismatch);
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return eval::Value(std::ceil(std::get<std::int64_t>(value.value)));
+  }
+  if (std::holds_alternative<double>(value.value)) {
+    return eval::Value(std::ceil(std::get<double>(value.value)));
+  }
+  if (std::holds_alternative<bool>(value.value)) {
+    return eval::Value(std::ceil(std::get<bool>(value.value)));
+  }
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_cos.cpp b/src/env/math_cos.cpp
index d360d70..aea4f7f 100644
--- a/src/env/math_cos.cpp
+++ b/src/env/math_cos.cpp
@@ -5,26 +5,22 @@
 #include <cmath>
 #include <variant>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t math_cos = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
+const eval::Value::fn_t math_cos =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
 
-    const auto& value = args[0];
-    if (std::holds_alternative<double>(value.value))
-    {
-        return std::cos(std::get<double>(value.value));
-    }
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return std::cos(std::get<std::int64_t>(value.value));
-    }
-    return zeus::unexpected(eval::Error::TypeMismatch);
+  const auto &value = args[0];
+  if (std::holds_alternative<double>(value.value)) {
+    return std::cos(std::get<double>(value.value));
+  }
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return std::cos(std::get<std::int64_t>(value.value));
+  }
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_degrees.cpp b/src/env/math_degrees.cpp
index 6191b50..dbe6d6f 100644
--- a/src/env/math_degrees.cpp
+++ b/src/env/math_degrees.cpp
@@ -4,16 +4,14 @@
 
 #include <numbers>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t math_degrees = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-    return args[0] * eval::Value(180.0 / std::numbers::pi);
+const eval::Value::fn_t math_degrees =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+  return args[0] * eval::Value(180.0 / std::numbers::pi);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_floor.cpp b/src/env/math_floor.cpp
index 665cafe..c0beee6 100644
--- a/src/env/math_floor.cpp
+++ b/src/env/math_floor.cpp
@@ -5,32 +5,27 @@
 #include <cmath>
 #include <variant>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t math_floor = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-
-    const auto& value = args[0];
-
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return eval::Value(std::floor(std::get<std::int64_t>(value.value)));
-    }
-    if (std::holds_alternative<double>(value.value))
-    {
-        return eval::Value(std::floor(std::get<double>(value.value)));
-    }
-    if (std::holds_alternative<bool>(value.value))
-    {
-        return eval::Value(std::floor(std::get<bool>(value.value)));
-    }
-
-    return zeus::unexpected(eval::Error::TypeMismatch);
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t math_floor =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  const auto &value = args[0];
+
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return eval::Value(std::floor(std::get<std::int64_t>(value.value)));
+  }
+  if (std::holds_alternative<double>(value.value)) {
+    return eval::Value(std::floor(std::get<double>(value.value)));
+  }
+  if (std::holds_alternative<bool>(value.value)) {
+    return eval::Value(std::floor(std::get<bool>(value.value)));
+  }
+
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_log.cpp b/src/env/math_log.cpp
index b92eda7..0f0b0ba 100644
--- a/src/env/math_log.cpp
+++ b/src/env/math_log.cpp
@@ -7,57 +7,44 @@
 #include <numbers>
 #include <variant>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t math_log = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.empty() || args.size() > 2)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
+namespace CuraFormulaeEngine::env {
 
-    auto initialize = [](const eval::Value& value) -> double
-    {
-        if (std::holds_alternative<double>(value.value))
-        {
-            return std::get<double>(value.value);
-        }
-        if (std::holds_alternative<std::int64_t>(value.value))
-        {
-            return static_cast<double>(std::get<std::int64_t>(value.value));
-        }
-        if (std::holds_alternative<bool>(value.value))
-        {
-            return std::get<bool>(value.value) ? 1.0 : 0.0;
-        }
-        return std::numeric_limits<double>::quiet_NaN();
-    };
-
-    const double x = initialize(args[0]);
-    if (std::isnan(x))
-    {
-        return zeus::unexpected(eval::Error::TypeMismatch);
-    }
+const eval::Value::fn_t math_log =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.empty() || args.size() > 2) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
 
-    double base = std::numbers::e;
-    if (args.size() == 2)
-    {
-        if (std::holds_alternative<double>(args[1].value))
-        {
-            base = std::get<double>(args[1].value);
-        }
-        else if (std::holds_alternative<std::int64_t>(args[1].value))
-        {
-            base = static_cast<double>(std::get<std::int64_t>(args[1].value));
-        }
-        else if (std::holds_alternative<bool>(args[1].value))
-        {
-            base = std::get<bool>(args[1].value) ? 1.0 : 0.0;
-        }
+  auto initialize = [](const eval::Value &value) -> double {
+    if (std::holds_alternative<double>(value.value)) {
+      return std::get<double>(value.value);
+    }
+    if (std::holds_alternative<std::int64_t>(value.value)) {
+      return static_cast<double>(std::get<std::int64_t>(value.value));
+    }
+    if (std::holds_alternative<bool>(value.value)) {
+      return std::get<bool>(value.value) ? 1.0 : 0.0;
+    }
+    return std::numeric_limits<double>::quiet_NaN();
+  };
+
+  const double x = initialize(args[0]);
+  if (std::isnan(x)) {
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
+
+  double base = std::numbers::e;
+  if (args.size() == 2) {
+    if (std::holds_alternative<double>(args[1].value)) {
+      base = std::get<double>(args[1].value);
+    } else if (std::holds_alternative<std::int64_t>(args[1].value)) {
+      base = static_cast<double>(std::get<std::int64_t>(args[1].value));
+    } else if (std::holds_alternative<bool>(args[1].value)) {
+      base = std::get<bool>(args[1].value) ? 1.0 : 0.0;
     }
+  }
 
-    return eval::Value(std::log(x) / std::log(base));
+  return eval::Value(std::log(x) / std::log(base));
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_radians.cpp b/src/env/math_radians.cpp
index e63a73a..88a7be6 100644
--- a/src/env/math_radians.cpp
+++ b/src/env/math_radians.cpp
@@ -4,16 +4,14 @@
 
 #include <numbers>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t math_radians = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-    return args[0] * eval::Value(std::numbers::pi / 180.0);
+const eval::Value::fn_t math_radians =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+  return args[0] * eval::Value(std::numbers::pi / 180.0);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_sin.cpp b/src/env/math_sin.cpp
index cc585f2..4a60d3f 100644
--- a/src/env/math_sin.cpp
+++ b/src/env/math_sin.cpp
@@ -6,32 +6,27 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t math_sin = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-
-    const auto& value = args[0];
-
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return eval::Value(std::sin(std::get<std::int64_t>(value.value)));
-    }
-    if (std::holds_alternative<double>(value.value))
-    {
-        return eval::Value(std::sin(std::get<double>(value.value)));
-    }
-    if (std::holds_alternative<bool>(value.value))
-    {
-        return eval::Value(std::sin(std::get<bool>(value.value)));
-    }
-
-    return zeus::unexpected(eval::Error::TypeMismatch);
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t math_sin =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  const auto &value = args[0];
+
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return eval::Value(std::sin(std::get<std::int64_t>(value.value)));
+  }
+  if (std::holds_alternative<double>(value.value)) {
+    return eval::Value(std::sin(std::get<double>(value.value)));
+  }
+  if (std::holds_alternative<bool>(value.value)) {
+    return eval::Value(std::sin(std::get<bool>(value.value)));
+  }
+
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_sqrt.cpp b/src/env/math_sqrt.cpp
index 13918da..1795266 100644
--- a/src/env/math_sqrt.cpp
+++ b/src/env/math_sqrt.cpp
@@ -6,32 +6,27 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t math_sqrt = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-
-    const auto& value = args[0];
-
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return eval::Value(std::sqrt(std::get<std::int64_t>(value.value)));
-    }
-    if (std::holds_alternative<double>(value.value))
-    {
-        return eval::Value(std::sqrt(std::get<double>(value.value)));
-    }
-    if (std::holds_alternative<bool>(value.value))
-    {
-        return eval::Value(std::sqrt(std::get<bool>(value.value)));
-    }
-
-    return zeus::unexpected(eval::Error::TypeMismatch);
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t math_sqrt =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  const auto &value = args[0];
+
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return eval::Value(std::sqrt(std::get<std::int64_t>(value.value)));
+  }
+  if (std::holds_alternative<double>(value.value)) {
+    return eval::Value(std::sqrt(std::get<double>(value.value)));
+  }
+  if (std::holds_alternative<bool>(value.value)) {
+    return eval::Value(std::sqrt(std::get<bool>(value.value)));
+  }
+
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/math_tan.cpp b/src/env/math_tan.cpp
index 819679c..799c736 100644
--- a/src/env/math_tan.cpp
+++ b/src/env/math_tan.cpp
@@ -6,32 +6,27 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t math_tan = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-
-    const auto& value = args[0];
-
-    if (std::holds_alternative<std::int64_t>(value.value))
-    {
-        return eval::Value(std::tan(std::get<std::int64_t>(value.value)));
-    }
-    if (std::holds_alternative<double>(value.value))
-    {
-        return eval::Value(std::tan(std::get<double>(value.value)));
-    }
-    if (std::holds_alternative<bool>(value.value))
-    {
-        return eval::Value(std::tan(std::get<bool>(value.value)));
-    }
-
-    return zeus::unexpected(eval::Error::TypeMismatch);
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t math_tan =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  const auto &value = args[0];
+
+  if (std::holds_alternative<std::int64_t>(value.value)) {
+    return eval::Value(std::tan(std::get<std::int64_t>(value.value)));
+  }
+  if (std::holds_alternative<double>(value.value)) {
+    return eval::Value(std::tan(std::get<double>(value.value)));
+  }
+  if (std::holds_alternative<bool>(value.value)) {
+    return eval::Value(std::tan(std::get<bool>(value.value)));
+  }
+
+  return zeus::unexpected(eval::Error::TypeMismatch);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/max.cpp b/src/env/max.cpp
index 2ca6f47..621d344 100644
--- a/src/env/max.cpp
+++ b/src/env/max.cpp
@@ -6,40 +6,35 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t max = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.empty())
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t max =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.empty()) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  const auto find_max =
+      [](const std::vector<eval::Value> &vec) -> eval::Result {
+    auto max = vec[0];
+    for (const auto &arg : vec | ranges::views::drop(1)) {
+      const auto cmp = arg > max;
+      if (!cmp.has_value()) {
+        return zeus::unexpected(eval::Error::TypeMismatch);
+      }
+
+      if (cmp.value()) {
+        max = arg;
+      }
     }
-
-    const auto find_max = [](const std::vector<eval::Value>& vec) -> eval::Result
-    {
-        auto max = vec[0];
-        for (const auto& arg : vec | ranges::views::drop(1))
-        {
-            const auto cmp = arg > max;
-            if (! cmp.has_value())
-            {
-                return zeus::unexpected(eval::Error::TypeMismatch);
-            }
-
-            if (cmp.value())
-            {
-                max = arg;
-            }
-        }
-        return max;
-    };
-
-    if (args.size() == 1 && std::holds_alternative<std::vector<eval::Value>>(args[0].value))
-    {
-        return find_max(std::get<std::vector<eval::Value>>(args[0].value));
-    }
-    return find_max(args);
+    return max;
+  };
+
+  if (args.size() == 1 &&
+      std::holds_alternative<std::vector<eval::Value>>(args[0].value)) {
+    return find_max(std::get<std::vector<eval::Value>>(args[0].value));
+  }
+  return find_max(args);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/min.cpp b/src/env/min.cpp
index 085dc85..f220aea 100644
--- a/src/env/min.cpp
+++ b/src/env/min.cpp
@@ -6,40 +6,35 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t min = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.empty())
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t min =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.empty()) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  const auto find_min =
+      [](const std::vector<eval::Value> &vec) -> eval::Result {
+    auto min = vec[0];
+    for (const auto &arg : vec | ranges::views::drop(1)) {
+      const auto cmp = arg < min;
+      if (!cmp.has_value()) {
+        return zeus::unexpected(eval::Error::TypeMismatch);
+      }
+
+      if (cmp.value()) {
+        min = arg;
+      }
     }
-
-    const auto find_min = [](const std::vector<eval::Value>& vec) -> eval::Result
-    {
-        auto min = vec[0];
-        for (const auto& arg : vec | ranges::views::drop(1))
-        {
-            const auto cmp = arg < min;
-            if (! cmp.has_value())
-            {
-                return zeus::unexpected(eval::Error::TypeMismatch);
-            }
-
-            if (cmp.value())
-            {
-                min = arg;
-            }
-        }
-        return min;
-    };
-
-    if (args.size() == 1 && std::holds_alternative<std::vector<eval::Value>>(args[0].value))
-    {
-        return find_min(std::get<std::vector<eval::Value>>(args[0].value));
-    }
-    return find_min(args);
+    return min;
+  };
+
+  if (args.size() == 1 &&
+      std::holds_alternative<std::vector<eval::Value>>(args[0].value)) {
+    return find_min(std::get<std::vector<eval::Value>>(args[0].value));
+  }
+  return find_min(args);
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/round.cpp b/src/env/round.cpp
index 5cc06de..dd0c423 100644
--- a/src/env/round.cpp
+++ b/src/env/round.cpp
@@ -7,53 +7,44 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t round = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() > 2)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t round =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() > 2) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  auto base = 0LL;
+  if (args.size() == 2) {
+    const auto &base_arg = args[1];
+    if (!std::holds_alternative<std::int64_t>(base_arg.value)) {
+      return zeus::unexpected(eval::Error::TypeMismatch);
     }
+    base = std::get<std::int64_t>(base_arg.value);
+  }
 
-    auto base = 0LL;
-    if (args.size() == 2)
-    {
-        const auto& base_arg = args[1];
-        if (! std::holds_alternative<std::int64_t>(base_arg.value))
-        {
-            return zeus::unexpected(eval::Error::TypeMismatch);
-        }
-        base = std::get<std::int64_t>(base_arg.value);
+  const auto &x = args[0];
+  const auto initialize = [](const auto &value) -> double {
+    if (std::holds_alternative<std::int64_t>(value.value)) {
+      return static_cast<double>(std::get<std::int64_t>(value.value));
     }
-
-    const auto& x = args[0];
-    const auto initialize = [](const auto& value) -> double
-    {
-        if (std::holds_alternative<std::int64_t>(value.value))
-        {
-            return static_cast<double>(std::get<std::int64_t>(value.value));
-        }
-        if (std::holds_alternative<double>(value.value))
-        {
-            return std::get<double>(value.value);
-        }
-        return std::numeric_limits<double>::quiet_NaN();
-    };
-    double value = initialize(x);
-    if (std::isnan(value))
-    {
-        return zeus::unexpected(eval::Error::TypeMismatch);
-    }
-
-    const auto base_exponent = std::pow(10, base);
-    value = std::round(value * base_exponent) / base_exponent;
-    if (base <= 0)
-    {
-        return static_cast<std::int64_t>(value);
+    if (std::holds_alternative<double>(value.value)) {
+      return std::get<double>(value.value);
     }
-    return value;
+    return std::numeric_limits<double>::quiet_NaN();
+  };
+  double value = initialize(x);
+  if (std::isnan(value)) {
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
+
+  const auto base_exponent = std::pow(10, base);
+  value = std::round(value * base_exponent) / base_exponent;
+  if (base <= 0) {
+    return static_cast<std::int64_t>(value);
+  }
+  return value;
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/str.cpp b/src/env/str.cpp
index a060ced..dfbe2e8 100644
--- a/src/env/str.cpp
+++ b/src/env/str.cpp
@@ -6,36 +6,31 @@
 #include <vector>
 #include <zeus/expected.hpp>
 
-namespace CuraFormulaeEngine::env
-{
-
-const eval::Value::fn_t str = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
-
-    if (std::holds_alternative<std::string>(args[0].value))
-    {
-        return std::get<std::string>(args[0].value);
-    }
-
-    if (std::holds_alternative<std::int64_t>(args[0].value))
-    {
-        return std::to_string(std::get<std::int64_t>(args[0].value));
-    }
-
-    if (std::holds_alternative<double>(args[0].value))
-    {
-        return std::to_string(std::get<double>(args[0].value));
-    }
-
-    if (std::holds_alternative<bool>(args[0].value))
-    {
-        return std::get<bool>(args[0].value) ? std::string("True") : std::string("False");
-    }
-    throw std::runtime_error("Unimplemented");
+namespace CuraFormulaeEngine::env {
+
+const eval::Value::fn_t str =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
+
+  if (std::holds_alternative<std::string>(args[0].value)) {
+    return std::get<std::string>(args[0].value);
+  }
+
+  if (std::holds_alternative<std::int64_t>(args[0].value)) {
+    return std::to_string(std::get<std::int64_t>(args[0].value));
+  }
+
+  if (std::holds_alternative<double>(args[0].value)) {
+    return std::to_string(std::get<double>(args[0].value));
+  }
+
+  if (std::holds_alternative<bool>(args[0].value)) {
+    return std::get<bool>(args[0].value) ? std::string("True")
+                                         : std::string("False");
+  }
+  throw std::runtime_error("Unimplemented");
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/env/sum.cpp b/src/env/sum.cpp
index 8b9f097..1dd0947 100644
--- a/src/env/sum.cpp
+++ b/src/env/sum.cpp
@@ -5,33 +5,28 @@
 #include <variant>
 #include <vector>
 
-namespace CuraFormulaeEngine::env
-{
+namespace CuraFormulaeEngine::env {
 
-const eval::Value::fn_t sum = [](const std::vector<eval::Value> &args) -> eval::Result
-{
-    if (args.size() != 1)
-    {
-        return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
-    }
+const eval::Value::fn_t sum =
+    [](const std::vector<eval::Value> &args) -> eval::Result {
+  if (args.size() != 1) {
+    return zeus::unexpected(eval::Error::InvalidNumberOfArguments);
+  }
 
-    if (! std::holds_alternative<std::vector<eval::Value>>(args[0].value))
-    {
-        return zeus::unexpected(eval::Error::TypeMismatch);
-    }
+  if (!std::holds_alternative<std::vector<eval::Value>>(args[0].value)) {
+    return zeus::unexpected(eval::Error::TypeMismatch);
+  }
 
-    auto result = eval::Value{ int64_t(0) };
-    const auto list = std::get<std::vector<eval::Value>>(args[0].value);
-    for (const auto& arg : list)
-    {
-        const auto sum = result + arg;
-        if (! sum.has_value())
-        {
-            return zeus::unexpected(sum.error());
-        }
-        result = sum.value();
+  auto result = eval::Value{int64_t(0)};
+  const auto list = std::get<std::vector<eval::Value>>(args[0].value);
+  for (const auto &arg : list) {
+    const auto sum = result + arg;
+    if (!sum.has_value()) {
+      return zeus::unexpected(sum.error());
     }
-    return result;
+    result = sum.value();
+  }
+  return result;
 };
 
 } // namespace CuraFormulaeEngine::env
diff --git a/src/eval.cpp b/src/eval.cpp
index 11e314d..e2c9fa4 100644
--- a/src/eval.cpp
+++ b/src/eval.cpp
@@ -22,564 +22,617 @@
 
 namespace CuraFormulaeEngine::eval {
 
-    [[nodiscard]] std::string Value::toString() const noexcept
-    {
-        if (std::holds_alternative<bool>(value))
-        {
-            return std::get<bool>(value) ? "true" : "false";
-        }
-        if (std::holds_alternative<double>(value))
-        {
-            auto str = std::to_string(std::get<double>(value));
-            str.erase(str.find_last_not_of('0') + 1, std::string::npos);
-            str.erase(str.find_last_not_of('.') + 1, std::string::npos);
-            return str;
-        }
-        if (std::holds_alternative<std::int64_t>(value))
-        {
-            return std::to_string(std::get<std::int64_t>(value));
-        }
-        if (std::holds_alternative<std::string>(value))
-        {
-            return fmt::format("{}", std::get<std::string>(value));
-        }
-        if (std::holds_alternative<std::vector<Value>>(value))
-        {
-            auto list = std::get<std::vector<Value>>(value);
-            return fmt::format(
-                    "[{}]",
-                    list | ranges::views::transform([](const auto &element) { return element.toString(); }) |
-                    ranges::views::join(ranges::views::c_str(", "))
-                    | ranges::to<std::string>());
-        }
-        if (std::holds_alternative<std::nullptr_t>(value))
-        {
-            return "None";
-        }
-        if (std::holds_alternative<fn_t>(value))
-        {
-            return "<function>";
-        }
-        return "<unknown>";
-    }
+[[nodiscard]] std::string Value::toString() const noexcept {
+  if (std::holds_alternative<bool>(value)) {
+    return std::get<bool>(value) ? "true" : "false";
+  }
+  if (std::holds_alternative<double>(value)) {
+    auto str = std::to_string(std::get<double>(value));
+    str.erase(str.find_last_not_of('0') + 1, std::string::npos);
+    str.erase(str.find_last_not_of('.') + 1, std::string::npos);
+    return str;
+  }
+  if (std::holds_alternative<std::int64_t>(value)) {
+    return std::to_string(std::get<std::int64_t>(value));
+  }
+  if (std::holds_alternative<std::string>(value)) {
+    return fmt::format("{}", std::get<std::string>(value));
+  }
+  if (std::holds_alternative<std::vector<Value>>(value)) {
+    auto list = std::get<std::vector<Value>>(value);
+    return fmt::format("[{}]",
+                       list | ranges::views::transform([](const auto &element) {
+                         return element.toString();
+                       }) | ranges::views::join(ranges::views::c_str(", ")) |
+                           ranges::to<std::string>());
+  }
+  if (std::holds_alternative<std::nullptr_t>(value)) {
+    return "None";
+  }
+  if (std::holds_alternative<fn_t>(value)) {
+    return "<function>";
+  }
+  return "<unknown>";
+}
 
-    [[nodiscard]] bool Value::deepEq(const Value &other) const noexcept
-    {
-        if (std::holds_alternative<bool>(value) && std::holds_alternative<bool>(other.value))
-        {
-            return std::get<bool>(value) == std::get<bool>(other.value);
-        }
-        if (std::holds_alternative<double>(value) && std::holds_alternative<double>(other.value))
-        {
-            return std::get<double>(value) == std::get<double>(other.value);
-        }
-        if (std::holds_alternative<std::int64_t>(value) && std::holds_alternative<std::int64_t>(other.value))
-        {
-            return std::get<std::int64_t>(value) == std::get<std::int64_t>(other.value);
-        }
-        if (std::holds_alternative<std::string>(value) && std::holds_alternative<std::string>(other.value))
-        {
-            return std::get<std::string>(value) == std::get<std::string>(other.value);
-        }
-        if (std::holds_alternative<std::nullptr_t>(value) && std::holds_alternative<std::nullptr_t>(other.value))
-        {
-            return true;
-        }
-        if (std::holds_alternative<std::vector<Value>>(value) && std::holds_alternative<std::vector<Value>>(other.value))
-        {
-            const auto &lhs = std::get<std::vector<Value>>(value);
-            const auto &rhs = std::get<std::vector<Value>>(other.value);
-            if (lhs.size() != rhs.size())
-            {
-                return false;
-            }
-            return ranges::all_of(
-                    ranges::views::zip(lhs, rhs),
-                    [](const auto &pair)
-                    {
-                        const auto [element_lhs, element_rhs] = pair;
-                        return element_lhs.deepEq(element_rhs);
-                    });
-        }
-        if (std::holds_alternative<fn_t>(value) && std::holds_alternative<fn_t>(other.value))
-        {
-            return typeid(std::holds_alternative<fn_t>(value)) == typeid(std::holds_alternative<fn_t>(other.value));
-        }
-        return false;
-    }
+[[nodiscard]] bool Value::deepEq(const Value &other) const noexcept {
+  if (std::holds_alternative<bool>(value) &&
+      std::holds_alternative<bool>(other.value)) {
+    return std::get<bool>(value) == std::get<bool>(other.value);
+  }
+  if (std::holds_alternative<double>(value) &&
+      std::holds_alternative<double>(other.value)) {
+    return std::get<double>(value) == std::get<double>(other.value);
+  }
+  if (std::holds_alternative<std::int64_t>(value) &&
+      std::holds_alternative<std::int64_t>(other.value)) {
+    return std::get<std::int64_t>(value) == std::get<std::int64_t>(other.value);
+  }
+  if (std::holds_alternative<std::string>(value) &&
+      std::holds_alternative<std::string>(other.value)) {
+    return std::get<std::string>(value) == std::get<std::string>(other.value);
+  }
+  if (std::holds_alternative<std::nullptr_t>(value) &&
+      std::holds_alternative<std::nullptr_t>(other.value)) {
+    return true;
+  }
+  if (std::holds_alternative<std::vector<Value>>(value) &&
+      std::holds_alternative<std::vector<Value>>(other.value)) {
+    const auto &lhs = std::get<std::vector<Value>>(value);
+    const auto &rhs = std::get<std::vector<Value>>(other.value);
+    if (lhs.size() != rhs.size()) {
+      return false;
+    }
+    return ranges::all_of(ranges::views::zip(lhs, rhs), [](const auto &pair) {
+      const auto [element_lhs, element_rhs] = pair;
+      return element_lhs.deepEq(element_rhs);
+    });
+  }
+  if (std::holds_alternative<fn_t>(value) &&
+      std::holds_alternative<fn_t>(other.value)) {
+    return typeid(std::holds_alternative<fn_t>(value)) ==
+           typeid(std::holds_alternative<fn_t>(other.value));
+  }
+  return false;
+}
 
-    [[nodiscard]] bool Value::isTruthy() const noexcept
-    {
-        if (std::holds_alternative<bool>(value))
-        {
-            return std::get<bool>(value);
-        }
-        if (std::holds_alternative<double>(value))
-        {
-            return std::get<double>(value) != 0.0;
-        }
-        if (std::holds_alternative<std::int64_t>(value))
-        {
-            return std::get<std::int64_t>(value) != 0L;
-        }
-        if (std::holds_alternative<std::string>(value))
-        {
-            return ! std::get<std::string>(value).empty();
-        }
-        if (std::holds_alternative<std::vector<Value>>(value))
-        {
-            return ! std::get<std::vector<Value>>(value).empty();
-        }
-        return false;
-    };
-
-    [[nodiscard]] zeus::expected<double, Error> Value::numeric() const noexcept
-    {
-        if (std::holds_alternative<double>(value))
-        {
-            return std::get<double>(value);
-        }
-        if (std::holds_alternative<std::int64_t>(value))
-        {
-            return static_cast<double>(std::get<std::int64_t>(value));
-        }
-
-        if (std::holds_alternative<bool>(value))
-        {
-            return std::get<bool>(value) ? 1.0 : 0.0;
-        }
-        return zeus::unexpected(Error::TypeMismatch);
-    }
+[[nodiscard]] bool Value::isTruthy() const noexcept {
+  if (std::holds_alternative<bool>(value)) {
+    return std::get<bool>(value);
+  }
+  if (std::holds_alternative<double>(value)) {
+    return std::get<double>(value) != 0.0;
+  }
+  if (std::holds_alternative<std::int64_t>(value)) {
+    return std::get<std::int64_t>(value) != 0L;
+  }
+  if (std::holds_alternative<std::string>(value)) {
+    return !std::get<std::string>(value).empty();
+  }
+  if (std::holds_alternative<std::vector<Value>>(value)) {
+    return !std::get<std::vector<Value>>(value).empty();
+  }
+  return false;
+};
+
+[[nodiscard]] zeus::expected<double, Error> Value::numeric() const noexcept {
+  if (std::holds_alternative<double>(value)) {
+    return std::get<double>(value);
+  }
+  if (std::holds_alternative<std::int64_t>(value)) {
+    return static_cast<double>(std::get<std::int64_t>(value));
+  }
+
+  if (std::holds_alternative<bool>(value)) {
+    return std::get<bool>(value) ? 1.0 : 0.0;
+  }
+  return zeus::unexpected(Error::TypeMismatch);
+}
 
 #ifdef EMSCRIPTEN
-    [[nodiscard]] emscripten::val Value::toEmscripten() const
-    {
-        if (std::holds_alternative<bool>(value))
-        {
-            return emscripten::val(std::get<bool>(value));
-        }
-        if (std::holds_alternative<double>(value))
-        {
-            return emscripten::val(std::get<double>(value));
-        }
-        if (std::holds_alternative<std::int64_t>(value))
-        {
-            return emscripten::val(static_cast<double>(std::get<std::int64_t>(value)));
-        }
-        if (std::holds_alternative<std::string>(value))
-        {
-            return emscripten::val(std::get<std::string>(value));
-        }
-        if (std::holds_alternative<std::nullptr_t>(value))
-        {
-            return emscripten::val::null();
-        }
-        if (std::holds_alternative<std::vector<Value>>(value))
-        {
-            emscripten::val array = emscripten::val::array();
-            const auto& vector = std::get<std::vector<Value>>(value);
-            for (size_t i = 0; i < vector.size(); ++i)
-            {
-                array.set(i, vector[i].toEmscripten());
-            }
-            return array;
-        }
-        if (std::holds_alternative<fn_t>(value))
-        {
-            throw std::runtime_error("Cannot convert function to emscripten");
-        }
-
-        throw std::runtime_error("Unknown type in `Value::toEmscripten`");
-    }
+[[nodiscard]] emscripten::val Value::toEmscripten() const {
+  if (std::holds_alternative<bool>(value)) {
+    return emscripten::val(std::get<bool>(value));
+  }
+  if (std::holds_alternative<double>(value)) {
+    return emscripten::val(std::get<double>(value));
+  }
+  if (std::holds_alternative<std::int64_t>(value)) {
+    return emscripten::val(static_cast<double>(std::get<std::int64_t>(value)));
+  }
+  if (std::holds_alternative<std::string>(value)) {
+    return emscripten::val(std::get<std::string>(value));
+  }
+  if (std::holds_alternative<std::nullptr_t>(value)) {
+    return emscripten::val::null();
+  }
+  if (std::holds_alternative<std::vector<Value>>(value)) {
+    emscripten::val array = emscripten::val::array();
+    const auto &vector = std::get<std::vector<Value>>(value);
+    for (size_t i = 0; i < vector.size(); ++i) {
+      array.set(i, vector[i].toEmscripten());
+    }
+    return array;
+  }
+  if (std::holds_alternative<fn_t>(value)) {
+    throw std::runtime_error("Cannot convert function to emscripten");
+  }
+
+  throw std::runtime_error("Unknown type in `Value::toEmscripten`");
+}
 #endif
 
-    Result pow(const Value& lhs, const Value& rhs)
-    {
-        if (std::holds_alternative<double>(lhs.value) && std::holds_alternative<double>(rhs.value))
-        {
-            return std::pow(std::get<double>(lhs.value), std::get<double>(rhs.value));
-        }
-        if (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-        {
-            return static_cast<std::int64_t>(std::pow(std::get<std::int64_t>(lhs.value), std::get<std::int64_t>(rhs.value)));
-        }
-        if ((std::holds_alternative<std::int64_t>(lhs.value) || std::holds_alternative<double>(lhs.value))
-            && (std::holds_alternative<std::int64_t>(rhs.value) || std::holds_alternative<double>(rhs.value)))
-        {
-            const auto lhs_value = std::holds_alternative<double>(lhs.value) ? std::get<double>(lhs.value) : static_cast<double>(std::get<std::int64_t>(lhs.value));
-            const auto rhs_value = std::holds_alternative<double>(rhs.value) ? std::get<double>(rhs.value) : static_cast<double>(std::get<std::int64_t>(rhs.value));
-            return std::pow(lhs_value, rhs_value);
-        }
-        return zeus::unexpected(Error::TypeMismatch);
-    }
+Result pow(const Value &lhs, const Value &rhs) {
+  if (std::holds_alternative<double>(lhs.value) &&
+      std::holds_alternative<double>(rhs.value)) {
+    return std::pow(std::get<double>(lhs.value), std::get<double>(rhs.value));
+  }
+  if (std::holds_alternative<std::int64_t>(lhs.value) &&
+      std::holds_alternative<std::int64_t>(rhs.value)) {
+    return static_cast<std::int64_t>(std::pow(
+        std::get<std::int64_t>(lhs.value), std::get<std::int64_t>(rhs.value)));
+  }
+  if ((std::holds_alternative<std::int64_t>(lhs.value) ||
+       std::holds_alternative<double>(lhs.value)) &&
+      (std::holds_alternative<std::int64_t>(rhs.value) ||
+       std::holds_alternative<double>(rhs.value))) {
+    const auto lhs_value =
+        std::holds_alternative<double>(lhs.value)
+            ? std::get<double>(lhs.value)
+            : static_cast<double>(std::get<std::int64_t>(lhs.value));
+    const auto rhs_value =
+        std::holds_alternative<double>(rhs.value)
+            ? std::get<double>(rhs.value)
+            : static_cast<double>(std::get<std::int64_t>(rhs.value));
+    return std::pow(lhs_value, rhs_value);
+  }
+  return zeus::unexpected(Error::TypeMismatch);
+}
 
 } // namespace CuraFormulaeEngine::eval
 
-bool operator==(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    if (std::holds_alternative<bool>(lhs.value) && std::holds_alternative<bool>(rhs.value))
-    {
-        return std::get<bool>(lhs.value) == std::get<bool>(rhs.value);
-    }
-    if (std::holds_alternative<double>(lhs.value) && std::holds_alternative<double>(rhs.value))
-    {
-        return std::get<double>(lhs.value) == std::get<double>(rhs.value);
-    }
-    if (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-    {
-        return std::get<std::int64_t>(lhs.value) == std::get<std::int64_t>(rhs.value);
-    }
-    if (std::holds_alternative<double>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-    {
-        return std::get<double>(lhs.value) == static_cast<double>(std::get<std::int64_t>(rhs.value));
-    }
-    if (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<double>(rhs.value))
-    {
-        return static_cast<double>(std::get<std::int64_t>(lhs.value)) == std::get<double>(rhs.value);
-    }
-    if (std::holds_alternative<bool>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-    {
-        return (std::get<bool>(lhs.value) ? 1 : 0) == std::get<std::int64_t>(rhs.value);
-    }
-    if (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<bool>(rhs.value))
-    {
-        return std::get<std::int64_t>(lhs.value) == (std::get<bool>(rhs.value) ? 1 : 0);
-    }
-    if (std::holds_alternative<bool>(lhs.value) && std::holds_alternative<double>(rhs.value))
-    {
-        return (std::get<bool>(lhs.value) ? 1.0 : 0.0) == std::get<double>(rhs.value);
-    }
-    if (std::holds_alternative<double>(lhs.value) && std::holds_alternative<bool>(rhs.value))
-    {
-        return std::get<double>(lhs.value) == (std::get<bool>(rhs.value) ? 1.0 : 0.0);
-    }
-    if (std::holds_alternative<std::string>(lhs.value) && std::holds_alternative<std::string>(rhs.value))
-    {
-        return std::get<std::string>(lhs.value) == std::get<std::string>(rhs.value);
-    }
-    if (std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value) && std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value))
-    {
-        auto vector_lhs = std::get<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value);
-        auto vector_rhs = std::get<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value);
-
-        if (vector_lhs.size() != vector_rhs.size())
-        {
-            return false;
-        }
-
-        return ranges::all_of(
-                ranges::views::zip(vector_lhs, vector_rhs),
-                [](const auto& pair)
-                {
-                    const auto [element_lhs, element_rhs] = pair;
-                    return element_lhs == element_rhs;
-                });
-    }
+bool operator==(const CuraFormulaeEngine::eval::Value &lhs,
+                const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  if (std::holds_alternative<bool>(lhs.value) &&
+      std::holds_alternative<bool>(rhs.value)) {
+    return std::get<bool>(lhs.value) == std::get<bool>(rhs.value);
+  }
+  if (std::holds_alternative<double>(lhs.value) &&
+      std::holds_alternative<double>(rhs.value)) {
+    return std::get<double>(lhs.value) == std::get<double>(rhs.value);
+  }
+  if (std::holds_alternative<std::int64_t>(lhs.value) &&
+      std::holds_alternative<std::int64_t>(rhs.value)) {
+    return std::get<std::int64_t>(lhs.value) ==
+           std::get<std::int64_t>(rhs.value);
+  }
+  if (std::holds_alternative<double>(lhs.value) &&
+      std::holds_alternative<std::int64_t>(rhs.value)) {
+    return std::get<double>(lhs.value) ==
+           static_cast<double>(std::get<std::int64_t>(rhs.value));
+  }
+  if (std::holds_alternative<std::int64_t>(lhs.value) &&
+      std::holds_alternative<double>(rhs.value)) {
+    return static_cast<double>(std::get<std::int64_t>(lhs.value)) ==
+           std::get<double>(rhs.value);
+  }
+  if (std::holds_alternative<bool>(lhs.value) &&
+      std::holds_alternative<std::int64_t>(rhs.value)) {
+    return (std::get<bool>(lhs.value) ? 1 : 0) ==
+           std::get<std::int64_t>(rhs.value);
+  }
+  if (std::holds_alternative<std::int64_t>(lhs.value) &&
+      std::holds_alternative<bool>(rhs.value)) {
+    return std::get<std::int64_t>(lhs.value) ==
+           (std::get<bool>(rhs.value) ? 1 : 0);
+  }
+  if (std::holds_alternative<bool>(lhs.value) &&
+      std::holds_alternative<double>(rhs.value)) {
+    return (std::get<bool>(lhs.value) ? 1.0 : 0.0) ==
+           std::get<double>(rhs.value);
+  }
+  if (std::holds_alternative<double>(lhs.value) &&
+      std::holds_alternative<bool>(rhs.value)) {
+    return std::get<double>(lhs.value) ==
+           (std::get<bool>(rhs.value) ? 1.0 : 0.0);
+  }
+  if (std::holds_alternative<std::string>(lhs.value) &&
+      std::holds_alternative<std::string>(rhs.value)) {
+    return std::get<std::string>(lhs.value) == std::get<std::string>(rhs.value);
+  }
+  if (std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(
+          lhs.value) &&
+      std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(
+          rhs.value)) {
+    auto vector_lhs =
+        std::get<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value);
+    auto vector_rhs =
+        std::get<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value);
+
+    if (vector_lhs.size() != vector_rhs.size()) {
+      return false;
+    }
+
+    return ranges::all_of(ranges::views::zip(vector_lhs, vector_rhs),
+                          [](const auto &pair) {
+                            const auto [element_lhs, element_rhs] = pair;
+                            return element_lhs == element_rhs;
+                          });
+  }
+
+  return false;
+}
 
-    return false;
+bool operator!=(const CuraFormulaeEngine::eval::Value &lhs,
+                const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  return !(lhs == rhs);
 }
 
-bool operator!=(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    return ! (lhs == rhs);
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator<(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  const auto lhs_numeric = lhs.numeric();
+  const auto rhs_numeric = rhs.numeric();
+  if (lhs_numeric.has_value() && rhs_numeric.has_value()) {
+    return lhs_numeric.value() < rhs_numeric.value();
+  }
+  if (std::holds_alternative<std::string>(lhs.value) &&
+      std::holds_alternative<std::string>(rhs.value)) {
+    return std::get<std::string>(lhs.value) < std::get<std::string>(rhs.value);
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator<(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    const auto lhs_numeric = lhs.numeric();
-    const auto rhs_numeric = rhs.numeric();
-    if (lhs_numeric.has_value() && rhs_numeric.has_value())
-    {
-        return lhs_numeric.value() < rhs_numeric.value();
-    }
-    if (std::holds_alternative<std::string>(lhs.value) && std::holds_alternative<std::string>(rhs.value))
-    {
-        return std::get<std::string>(lhs.value) < std::get<std::string>(rhs.value);
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator<=(const CuraFormulaeEngine::eval::Value &lhs,
+           const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  const auto lhs_numeric = lhs.numeric();
+  const auto rhs_numeric = rhs.numeric();
+  if (lhs_numeric.has_value() && rhs_numeric.has_value()) {
+    return lhs_numeric.value() <= rhs_numeric.value();
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator<=(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    const auto lhs_numeric = lhs.numeric();
-    const auto rhs_numeric = rhs.numeric();
-    if (lhs_numeric.has_value() && rhs_numeric.has_value())
-    {
-        return lhs_numeric.value() <= rhs_numeric.value();
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator>=(const CuraFormulaeEngine::eval::Value &lhs,
+           const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  const auto lhs_numeric = lhs.numeric();
+  const auto rhs_numeric = rhs.numeric();
+  if (lhs_numeric.has_value() && rhs_numeric.has_value()) {
+    return lhs_numeric.value() >= rhs_numeric.value();
+  }
+  if (std::holds_alternative<std::string>(lhs.value) &&
+      std::holds_alternative<std::string>(rhs.value)) {
+    return std::get<std::string>(lhs.value) >= std::get<std::string>(rhs.value);
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator>=(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    const auto lhs_numeric = lhs.numeric();
-    const auto rhs_numeric = rhs.numeric();
-    if (lhs_numeric.has_value() && rhs_numeric.has_value())
-    {
-        return lhs_numeric.value() >= rhs_numeric.value();
-    }
-    if (std::holds_alternative<std::string>(lhs.value) && std::holds_alternative<std::string>(rhs.value))
-    {
-        return std::get<std::string>(lhs.value) >= std::get<std::string>(rhs.value);
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator>(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  const auto lhs_numeric = lhs.numeric();
+  const auto rhs_numeric = rhs.numeric();
+  if (lhs_numeric.has_value() && rhs_numeric.has_value()) {
+    return lhs_numeric.value() > rhs_numeric.value();
+  }
+  if (std::holds_alternative<std::string>(lhs.value) &&
+      std::holds_alternative<std::string>(rhs.value)) {
+    return std::get<std::string>(lhs.value) > std::get<std::string>(rhs.value);
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator>(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    const auto lhs_numeric = lhs.numeric();
-    const auto rhs_numeric = rhs.numeric();
-    if (lhs_numeric.has_value() && rhs_numeric.has_value())
-    {
-        return lhs_numeric.value() > rhs_numeric.value();
-    }
-    if (std::holds_alternative<std::string>(lhs.value) && std::holds_alternative<std::string>(rhs.value))
-    {
-        return std::get<std::string>(lhs.value) > std::get<std::string>(rhs.value);
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator&&(const CuraFormulaeEngine::eval::Value &lhs,
+           const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  if (std::holds_alternative<bool>(lhs.value) &&
+      std::holds_alternative<bool>(rhs.value)) {
+    return std::get<bool>(lhs.value) && std::get<bool>(rhs.value);
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator&&(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    if (std::holds_alternative<bool>(lhs.value) && std::holds_alternative<bool>(rhs.value))
-    {
-        return std::get<bool>(lhs.value) && std::get<bool>(rhs.value);
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+zeus::expected<bool, CuraFormulaeEngine::eval::Error>
+operator||(const CuraFormulaeEngine::eval::Value &lhs,
+           const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  if (std::holds_alternative<bool>(lhs.value) &&
+      std::holds_alternative<bool>(rhs.value)) {
+    return std::get<bool>(lhs.value) || std::get<bool>(rhs.value);
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-zeus::expected<bool, CuraFormulaeEngine::eval::Error> operator||(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    if (std::holds_alternative<bool>(lhs.value) && std::holds_alternative<bool>(rhs.value))
-    {
-        return std::get<bool>(lhs.value) || std::get<bool>(rhs.value);
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+CuraFormulaeEngine::eval::Result
+operator+(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  if (std::holds_alternative<std::string>(lhs.value) &&
+      std::holds_alternative<std::string>(rhs.value)) {
+    return std::get<std::string>(lhs.value) + std::get<std::string>(rhs.value);
+  }
+  if ((std::holds_alternative<bool>(lhs.value) ||
+       std::holds_alternative<std::int64_t>(lhs.value)) &&
+      (std::holds_alternative<bool>(rhs.value) ||
+       std::holds_alternative<std::int64_t>(rhs.value))) {
+    const auto lhs_value =
+        std::holds_alternative<std::int64_t>(lhs.value)
+            ? std::get<std::int64_t>(lhs.value)
+            : static_cast<std::int64_t>(std::get<bool>(lhs.value));
+    const auto rhs_value =
+        std::holds_alternative<std::int64_t>(rhs.value)
+            ? std::get<std::int64_t>(rhs.value)
+            : static_cast<std::int64_t>(std::get<bool>(rhs.value));
+    return lhs_value + rhs_value;
+  }
+  if ((std::holds_alternative<bool>(lhs.value) ||
+       std::holds_alternative<double>(lhs.value)) &&
+      (std::holds_alternative<bool>(rhs.value) ||
+       std::holds_alternative<double>(rhs.value))) {
+    const auto lhs_value = std::holds_alternative<double>(lhs.value)
+                               ? std::get<double>(lhs.value)
+                               : static_cast<double>(std::get<bool>(lhs.value));
+    const auto rhs_value = std::holds_alternative<double>(rhs.value)
+                               ? std::get<double>(rhs.value)
+                               : static_cast<double>(std::get<bool>(rhs.value));
+    return lhs_value + rhs_value;
+  }
+  if ((std::holds_alternative<double>(lhs.value) ||
+       std::holds_alternative<std::int64_t>(lhs.value)) &&
+      (std::holds_alternative<double>(rhs.value) ||
+       std::holds_alternative<std::int64_t>(rhs.value))) {
+    const auto lhs_value =
+        std::holds_alternative<double>(lhs.value)
+            ? std::get<double>(lhs.value)
+            : static_cast<double>(std::get<std::int64_t>(lhs.value));
+    const auto rhs_value =
+        std::holds_alternative<double>(rhs.value)
+            ? std::get<double>(rhs.value)
+            : static_cast<double>(std::get<std::int64_t>(rhs.value));
+    return lhs_value + rhs_value;
+  }
+  if (std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(
+          lhs.value) &&
+      std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(
+          rhs.value)) {
+    auto list_lhs =
+        std::get<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value);
+    auto list_rhs =
+        std::get<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value);
+    list_lhs.insert(list_lhs.end(), list_rhs.begin(), list_rhs.end());
+    return list_lhs;
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-CuraFormulaeEngine::eval::Result operator+(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    if (std::holds_alternative<std::string>(lhs.value) && std::holds_alternative<std::string>(rhs.value))
-    {
-        return std::get<std::string>(lhs.value) + std::get<std::string>(rhs.value);
-    }
-    if ((std::holds_alternative<bool>(lhs.value) || std::holds_alternative<std::int64_t>(lhs.value))
-        && (std::holds_alternative<bool>(rhs.value) || std::holds_alternative<std::int64_t>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<std::int64_t>(lhs.value) ? std::get<std::int64_t>(lhs.value) : static_cast<std::int64_t>(std::get<bool>(lhs.value));
-        const auto rhs_value = std::holds_alternative<std::int64_t>(rhs.value) ? std::get<std::int64_t>(rhs.value) : static_cast<std::int64_t>(std::get<bool>(rhs.value));
-        return lhs_value + rhs_value;
-    }
-    if ((std::holds_alternative<bool>(lhs.value) || std::holds_alternative<double>(lhs.value))
-        && (std::holds_alternative<bool>(rhs.value) || std::holds_alternative<double>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<double>(lhs.value) ? std::get<double>(lhs.value) : static_cast<double>(std::get<bool>(lhs.value));
-        const auto rhs_value = std::holds_alternative<double>(rhs.value) ? std::get<double>(rhs.value) : static_cast<double>(std::get<bool>(rhs.value));
-        return lhs_value + rhs_value;
-    }
-    if ((std::holds_alternative<double>(lhs.value) || std::holds_alternative<std::int64_t>(lhs.value))
-        && (std::holds_alternative<double>(rhs.value) || std::holds_alternative<std::int64_t>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<double>(lhs.value) ? std::get<double>(lhs.value) : static_cast<double>(std::get<std::int64_t>(lhs.value));
-        const auto rhs_value = std::holds_alternative<double>(rhs.value) ? std::get<double>(rhs.value) : static_cast<double>(std::get<std::int64_t>(rhs.value));
-        return lhs_value + rhs_value;
-    }
-    if (std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value) && std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value))
-    {
-        auto list_lhs = std::get<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value);
-        auto list_rhs = std::get<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value);
-        list_lhs.insert(list_lhs.end(), list_rhs.begin(), list_rhs.end());
-        return list_lhs;
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+CuraFormulaeEngine::eval::Result
+operator-(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  if ((std::holds_alternative<bool>(lhs.value) ||
+       std::holds_alternative<std::int64_t>(lhs.value)) &&
+      (std::holds_alternative<bool>(rhs.value) ||
+       std::holds_alternative<std::int64_t>(rhs.value))) {
+    const auto lhs_value =
+        std::holds_alternative<std::int64_t>(lhs.value)
+            ? std::get<std::int64_t>(lhs.value)
+            : static_cast<std::int64_t>(std::get<bool>(lhs.value));
+    const auto rhs_value =
+        std::holds_alternative<std::int64_t>(rhs.value)
+            ? std::get<std::int64_t>(rhs.value)
+            : static_cast<std::int64_t>(std::get<bool>(rhs.value));
+    return lhs_value - rhs_value;
+  }
+  if ((std::holds_alternative<bool>(lhs.value) ||
+       std::holds_alternative<double>(lhs.value)) &&
+      (std::holds_alternative<bool>(rhs.value) ||
+       std::holds_alternative<double>(rhs.value))) {
+    const auto lhs_value = std::holds_alternative<double>(lhs.value)
+                               ? std::get<double>(lhs.value)
+                               : static_cast<double>(std::get<bool>(lhs.value));
+    const auto rhs_value = std::holds_alternative<double>(rhs.value)
+                               ? std::get<double>(rhs.value)
+                               : static_cast<double>(std::get<bool>(rhs.value));
+    return lhs_value - rhs_value;
+  }
+  if ((std::holds_alternative<double>(lhs.value) ||
+       std::holds_alternative<std::int64_t>(lhs.value)) &&
+      (std::holds_alternative<double>(rhs.value) ||
+       std::holds_alternative<std::int64_t>(rhs.value))) {
+    const auto lhs_value =
+        std::holds_alternative<double>(lhs.value)
+            ? std::get<double>(lhs.value)
+            : static_cast<double>(std::get<std::int64_t>(lhs.value));
+    const auto rhs_value =
+        std::holds_alternative<double>(rhs.value)
+            ? std::get<double>(rhs.value)
+            : static_cast<double>(std::get<std::int64_t>(rhs.value));
+    return lhs_value - rhs_value;
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-CuraFormulaeEngine::eval::Result operator-(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    if ((std::holds_alternative<bool>(lhs.value) || std::holds_alternative<std::int64_t>(lhs.value))
-        && (std::holds_alternative<bool>(rhs.value) || std::holds_alternative<std::int64_t>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<std::int64_t>(lhs.value) ? std::get<std::int64_t>(lhs.value) : static_cast<std::int64_t>(std::get<bool>(lhs.value));
-        const auto rhs_value = std::holds_alternative<std::int64_t>(rhs.value) ? std::get<std::int64_t>(rhs.value) : static_cast<std::int64_t>(std::get<bool>(rhs.value));
-        return lhs_value - rhs_value;
-    }
-    if ((std::holds_alternative<bool>(lhs.value) || std::holds_alternative<double>(lhs.value))
-        && (std::holds_alternative<bool>(rhs.value) || std::holds_alternative<double>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<double>(lhs.value) ? std::get<double>(lhs.value) : static_cast<double>(std::get<bool>(lhs.value));
-        const auto rhs_value = std::holds_alternative<double>(rhs.value) ? std::get<double>(rhs.value) : static_cast<double >(std::get<bool>(rhs.value));
-        return lhs_value - rhs_value;
-    }
-    if ((std::holds_alternative<double>(lhs.value) || std::holds_alternative<std::int64_t>(lhs.value))
-        && (std::holds_alternative<double>(rhs.value) || std::holds_alternative<std::int64_t>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<double>(lhs.value) ? std::get<double>(lhs.value) : static_cast<double>(std::get<std::int64_t>(lhs.value));
-        const auto rhs_value = std::holds_alternative<double>(rhs.value) ? std::get<double>(rhs.value) : static_cast<double>(std::get<std::int64_t>(rhs.value));
-        return lhs_value - rhs_value;
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+CuraFormulaeEngine::eval::Result
+operator*(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  if (std::holds_alternative<std::int64_t>(lhs.value) &&
+      std::holds_alternative<std::int64_t>(rhs.value)) {
+    return std::get<std::int64_t>(lhs.value) *
+           std::get<std::int64_t>(rhs.value);
+  }
+  if ((std::holds_alternative<std::int64_t>(lhs.value) ||
+       std::holds_alternative<double>(lhs.value)) &&
+      (std::holds_alternative<std::int64_t>(rhs.value) ||
+       std::holds_alternative<double>(rhs.value))) {
+    const auto lhs_value =
+        std::holds_alternative<double>(lhs.value)
+            ? std::get<double>(lhs.value)
+            : static_cast<double>(std::get<std::int64_t>(lhs.value));
+    const auto rhs_value =
+        std::holds_alternative<double>(rhs.value)
+            ? std::get<double>(rhs.value)
+            : static_cast<double>(std::get<std::int64_t>(rhs.value));
+    return lhs_value * rhs_value;
+  }
+  if ((std::holds_alternative<bool>(lhs.value) ||
+       std::holds_alternative<double>(lhs.value)) &&
+      (std::holds_alternative<bool>(rhs.value) ||
+       std::holds_alternative<double>(rhs.value))) {
+    const auto lhs_value = std::holds_alternative<double>(lhs.value)
+                               ? std::get<double>(lhs.value)
+                               : static_cast<double>(std::get<bool>(lhs.value));
+    const auto rhs_value = std::holds_alternative<double>(rhs.value)
+                               ? std::get<double>(rhs.value)
+                               : static_cast<double>(std::get<bool>(rhs.value));
+    return lhs_value * rhs_value;
+  }
+  if ((std::holds_alternative<std::string>(lhs.value) &&
+       std::holds_alternative<std::int64_t>(rhs.value)) ||
+      (std::holds_alternative<std::int64_t>(lhs.value) &&
+       std::holds_alternative<std::string>(rhs.value))) {
+    const auto &string = std::holds_alternative<std::string>(lhs.value)
+                             ? std::get<std::string>(lhs.value)
+                             : std::get<std::string>(rhs.value);
+    const auto &times = std::holds_alternative<std::int64_t>(lhs.value)
+                            ? std::get<std::int64_t>(lhs.value)
+                            : std::get<std::int64_t>(rhs.value);
+    std::string result;
+    for (std::int64_t i = 0; i < times; ++i) {
+      result += string;
+    }
+    return result;
+  }
+  if ((std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(
+           lhs.value) &&
+       std::holds_alternative<std::int64_t>(rhs.value)) ||
+      (std::holds_alternative<std::int64_t>(lhs.value) &&
+       std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(
+           rhs.value))) {
+    const auto &string =
+        std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(
+            lhs.value)
+            ? std::get<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value)
+            : std::get<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value);
+    const auto &times = std::holds_alternative<std::int64_t>(lhs.value)
+                            ? std::get<std::int64_t>(lhs.value)
+                            : std::get<std::int64_t>(rhs.value);
+    std::vector<CuraFormulaeEngine::eval::Value> result;
+    for (std::int64_t i = 0; i < times; ++i) {
+      result.insert(result.end(), string.begin(), string.end());
+    }
+    return result;
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-CuraFormulaeEngine::eval::Result operator*(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    if (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-    {
-        return std::get<std::int64_t>(lhs.value) * std::get<std::int64_t>(rhs.value);
-    }
-    if ((std::holds_alternative<std::int64_t>(lhs.value) || std::holds_alternative<double>(lhs.value))
-        && (std::holds_alternative<std::int64_t>(rhs.value) || std::holds_alternative<double>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<double>(lhs.value) ? std::get<double>(lhs.value) : static_cast<double>(std::get<std::int64_t>(lhs.value));
-        const auto rhs_value = std::holds_alternative<double>(rhs.value) ? std::get<double>(rhs.value) : static_cast<double>(std::get<std::int64_t>(rhs.value));
-        return lhs_value * rhs_value;
-    }
-    if ((std::holds_alternative<bool>(lhs.value) || std::holds_alternative<double>(lhs.value))
-        && (std::holds_alternative<bool>(rhs.value) || std::holds_alternative<double>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<double>(lhs.value) ? std::get<double>(lhs.value) : static_cast<double>(std::get<bool>(lhs.value));
-        const auto rhs_value = std::holds_alternative<double>(rhs.value) ? std::get<double>(rhs.value) : static_cast<double >(std::get<bool>(rhs.value));
-        return lhs_value * rhs_value;
-    }
-    if ((std::holds_alternative<std::string>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-        || (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<std::string>(rhs.value)))
-    {
-        const auto& string = std::holds_alternative<std::string>(lhs.value) ? std::get<std::string>(lhs.value) : std::get<std::string>(rhs.value);
-        const auto& times = std::holds_alternative<std::int64_t>(lhs.value) ? std::get<std::int64_t>(lhs.value) : std::get<std::int64_t>(rhs.value);
-        std::string result;
-        for (std::int64_t i = 0; i < times; ++i)
-        {
-            result += string;
-        }
-        return result;
-    }
-    if ((std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-        || (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value)))
-    {
-        const auto& string = std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value) ? std::get<std::vector<CuraFormulaeEngine::eval::Value>>(lhs.value)
-                                                                                                  : std::get<std::vector<CuraFormulaeEngine::eval::Value>>(rhs.value);
-        const auto& times = std::holds_alternative<std::int64_t>(lhs.value) ? std::get<std::int64_t>(lhs.value) : std::get<std::int64_t>(rhs.value);
-        std::vector<CuraFormulaeEngine::eval::Value> result;
-        for (std::int64_t i = 0; i < times; ++i)
-        {
-            result.insert(result.end(), string.begin(), string.end());
-        }
-        return result;
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+CuraFormulaeEngine::eval::Result
+operator/(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  if (std::holds_alternative<std::int64_t>(lhs.value) &&
+      std::holds_alternative<std::int64_t>(rhs.value)) {
+    if (std::get<std::int64_t>(rhs.value) == 0L) {
+      return zeus::unexpected(CuraFormulaeEngine::eval::Error::DivisionByZero);
+    }
+    return static_cast<double>(std::get<std::int64_t>(lhs.value)) /
+           static_cast<double>(std::get<std::int64_t>(rhs.value));
+  }
+  if ((std::holds_alternative<std::int64_t>(lhs.value) ||
+       std::holds_alternative<double>(lhs.value)) &&
+      (std::holds_alternative<std::int64_t>(rhs.value) ||
+       std::holds_alternative<double>(rhs.value))) {
+    const auto lhs_value =
+        std::holds_alternative<double>(lhs.value)
+            ? std::get<double>(lhs.value)
+            : static_cast<double>(std::get<std::int64_t>(lhs.value));
+    const auto rhs_value =
+        std::holds_alternative<double>(rhs.value)
+            ? std::get<double>(rhs.value)
+            : static_cast<double>(std::get<std::int64_t>(rhs.value));
+
+    if (rhs_value == 0.0) {
+      return zeus::unexpected(CuraFormulaeEngine::eval::Error::DivisionByZero);
+    }
+    return lhs_value / rhs_value;
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-CuraFormulaeEngine::eval::Result operator/(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    if (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-    {
-        if (std::get<std::int64_t>(rhs.value) == 0L)
-        {
-            return zeus::unexpected(CuraFormulaeEngine::eval::Error::DivisionByZero);
-        }
-        return static_cast<double>(std::get<std::int64_t>(lhs.value)) / static_cast<double>(std::get<std::int64_t>(rhs.value));
-    }
-    if ((std::holds_alternative<std::int64_t>(lhs.value) || std::holds_alternative<double>(lhs.value))
-        && (std::holds_alternative<std::int64_t>(rhs.value) || std::holds_alternative<double>(rhs.value)))
-    {
-        const auto lhs_value = std::holds_alternative<double>(lhs.value) ? std::get<double>(lhs.value) : static_cast<double>(std::get<std::int64_t>(lhs.value));
-        const auto rhs_value = std::holds_alternative<double>(rhs.value) ? std::get<double>(rhs.value) : static_cast<double>(std::get<std::int64_t>(rhs.value));
-
-        if (rhs_value == 0.0)
-        {
-            return zeus::unexpected(CuraFormulaeEngine::eval::Error::DivisionByZero);
-        }
-        return lhs_value / rhs_value;
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+CuraFormulaeEngine::eval::Result
+operator%(const CuraFormulaeEngine::eval::Value &lhs,
+          const CuraFormulaeEngine::eval::Value &rhs) noexcept {
+  if (std::holds_alternative<double>(lhs.value) &&
+      std::holds_alternative<double>(rhs.value)) {
+    return std::fmod(std::get<double>(lhs.value), std::get<double>(rhs.value));
+  }
+  if (std::holds_alternative<std::int64_t>(lhs.value) &&
+      std::holds_alternative<std::int64_t>(rhs.value)) {
+    return std::get<std::int64_t>(lhs.value) %
+           std::get<std::int64_t>(rhs.value);
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-CuraFormulaeEngine::eval::Result operator%(const CuraFormulaeEngine::eval::Value& lhs, const CuraFormulaeEngine::eval::Value& rhs) noexcept
-{
-    if (std::holds_alternative<double>(lhs.value) && std::holds_alternative<double>(rhs.value))
-    {
-        return std::fmod(std::get<double>(lhs.value), std::get<double>(rhs.value));
-    }
-    if (std::holds_alternative<std::int64_t>(lhs.value) && std::holds_alternative<std::int64_t>(rhs.value))
-    {
-        return std::get<std::int64_t>(lhs.value) % std::get<std::int64_t>(rhs.value);
-    }
+CuraFormulaeEngine::eval::Result
+CuraFormulaeEngine::eval::Value::operator[](const Value &index) const noexcept {
+  if (!std::holds_alternative<std::vector<Value>>(this->value)) {
     return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
-}
+  }
+  const auto &list = std::get<std::vector<Value>>(this->value);
 
-CuraFormulaeEngine::eval::Result CuraFormulaeEngine::eval::Value::operator[](const Value& index) const noexcept
-{
-    if (! std::holds_alternative<std::vector<Value>>(this->value))
-    {
-        return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
-    }
-    const auto& list = std::get<std::vector<Value>>(this->value);
+  if (!std::holds_alternative<std::int64_t>(index.value)) {
+    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+  }
+  const auto &index_value = std::get<std::int64_t>(index.value);
 
-    if (! std::holds_alternative<std::int64_t>(index.value))
-    {
-        return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+  std::int64_t index_value_absolute;
+  if (index_value < 0) {
+    index_value_absolute =
+        static_cast<std::int64_t>(list.size()) - -index_value;
+    if (index_value_absolute < 0) {
+      return zeus::unexpected(eval::Error::IndexOutOfBounds);
     }
-    const auto& index_value = std::get<std::int64_t>(index.value);
-
-    std::int64_t index_value_absolute;
-    if (index_value < 0)
-    {
-        index_value_absolute = static_cast<std::int64_t>(list.size()) - -index_value;
-        if (index_value_absolute < 0)
-        {
-            return zeus::unexpected(eval::Error::IndexOutOfBounds);
-        }
-    }
-    else
-    {
-        index_value_absolute = index_value;
-        if (index_value_absolute >= static_cast<std::int64_t>(list.size()))
-        {
-            return zeus::unexpected(eval::Error::IndexOutOfBounds);
-        }
+  } else {
+    index_value_absolute = index_value;
+    if (index_value_absolute >= static_cast<std::int64_t>(list.size())) {
+      return zeus::unexpected(eval::Error::IndexOutOfBounds);
     }
+  }
 
-    return list[static_cast<std::size_t>(index_value_absolute)];
+  return list[static_cast<std::size_t>(index_value_absolute)];
 }
 
-CuraFormulaeEngine::eval::Result operator!(const CuraFormulaeEngine::eval::Value& operand) noexcept
-{
-    if (std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(operand.value))
-    {
-        return std::get<std::vector<CuraFormulaeEngine::eval::Value>>(operand.value).empty();
-    }
-    if (std::holds_alternative<std::int64_t>(operand.value))
-    {
-        return std::get<std::int64_t>(operand.value) == 0L;
-    }
-    if (std::holds_alternative<double>(operand.value))
-    {
-        return std::get<double>(operand.value) == 0.0;
-    }
-    if (std::holds_alternative<std::string>(operand.value))
-    {
-        return std::get<std::string>(operand.value) == std::string("");
-    }
-    if (std::holds_alternative<bool>(operand.value))
-    {
-        return ! std::get<bool>(operand.value);
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+CuraFormulaeEngine::eval::Result
+operator!(const CuraFormulaeEngine::eval::Value &operand) noexcept {
+  if (std::holds_alternative<std::vector<CuraFormulaeEngine::eval::Value>>(
+          operand.value)) {
+    return std::get<std::vector<CuraFormulaeEngine::eval::Value>>(operand.value)
+        .empty();
+  }
+  if (std::holds_alternative<std::int64_t>(operand.value)) {
+    return std::get<std::int64_t>(operand.value) == 0L;
+  }
+  if (std::holds_alternative<double>(operand.value)) {
+    return std::get<double>(operand.value) == 0.0;
+  }
+  if (std::holds_alternative<std::string>(operand.value)) {
+    return std::get<std::string>(operand.value) == std::string("");
+  }
+  if (std::holds_alternative<bool>(operand.value)) {
+    return !std::get<bool>(operand.value);
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
 
-CuraFormulaeEngine::eval::Result operator-(const CuraFormulaeEngine::eval::Value& operand) noexcept
-{
-    if (std::holds_alternative<bool>(operand.value))
-    {
-        return std::get<bool>(operand.value) ? static_cast<std::int64_t>(-1) : static_cast<std::int64_t>(0);
-    }
-    if (std::holds_alternative<std::int64_t>(operand.value))
-    {
-        return -std::get<std::int64_t>(operand.value);
-    }
-    if (std::holds_alternative<double>(operand.value))
-    {
-        return -std::get<double>(operand.value);
-    }
-    return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
+CuraFormulaeEngine::eval::Result
+operator-(const CuraFormulaeEngine::eval::Value &operand) noexcept {
+  if (std::holds_alternative<bool>(operand.value)) {
+    return std::get<bool>(operand.value) ? static_cast<std::int64_t>(-1)
+                                         : static_cast<std::int64_t>(0);
+  }
+  if (std::holds_alternative<std::int64_t>(operand.value)) {
+    return -std::get<std::int64_t>(operand.value);
+  }
+  if (std::holds_alternative<double>(operand.value)) {
+    return -std::get<double>(operand.value);
+  }
+  return zeus::unexpected(CuraFormulaeEngine::eval::Error::TypeMismatch);
 }
diff --git a/src/parser/parser.cpp b/src/parser/parser.cpp
index 2110a9e..e0f4e7f 100644
--- a/src/parser/parser.cpp
+++ b/src/parser/parser.cpp
@@ -1,5 +1,5 @@
-#include "cura-formulae-engine/ast/expr_ptr.h"
 #include "cura-formulae-engine/parser/parser.h"
+#include "cura-formulae-engine/ast/expr_ptr.h"
 
 #include <zeus/expected.hpp>
 
@@ -9,17 +9,17 @@
 #include <lexy/input/string_input.hpp>
 #include <string_view>
 
-namespace CuraFormulaeEngine::parser
-{
+namespace CuraFormulaeEngine::parser {
 
-zeus::expected<ast::ExprPtr, error_t> parse(std::string_view input)
-{
-    auto parse_result = lexy::parse<Grammar>(lexy::string_input<lexy::utf8_encoding>(input), lexy::noop);
-    if (parse_result.is_success())
-    {
-        return static_cast<lexy::parse_result<ast::ExprPtr, lexy::_noop>&&>(parse_result).value();
-    }
-    return zeus::unexpected(parse_result.errors());
+zeus::expected<ast::ExprPtr, error_t> parse(std::string_view input) {
+  auto parse_result = lexy::parse<Grammar>(
+      lexy::string_input<lexy::utf8_encoding>(input), lexy::noop);
+  if (parse_result.is_success()) {
+    return static_cast<lexy::parse_result<ast::ExprPtr, lexy::_noop> &&>(
+               parse_result)
+        .value();
+  }
+  return zeus::unexpected(parse_result.errors());
 }
 
 } // namespace CuraFormulaeEngine::parser
diff --git a/tests/parser.cpp b/tests/parser.cpp
index e6a0483..19a8272 100644
--- a/tests/parser.cpp
+++ b/tests/parser.cpp
@@ -12,2270 +12,2331 @@
 using namespace std::string_view_literals;
 using namespace CuraFormulaeEngine::ast;
 
-TEST_CASE("constant single digit", "[parser, constant]")
-{
-    auto input = "1"sv;
-    const auto expected_ast = make_expr_ptr<IntExpr>(1);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("constant multi digit", "[parser, constant]")
-{
-    auto input = "12345"sv;
-    const auto expected_ast = make_expr_ptr<IntExpr>(12345);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(12345));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("float", "[parser, constant]")
-{
-    auto input = "3.14"sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(3.14);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(3.14);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("float no integer", "[parser, constant]")
-{
-    auto input = ".0"sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(0.0);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("float no decimal", "[parser, constant]")
-{
-    auto input = "0."sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(0.0);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("int scientific", "[.][parser, constant]")
-{
-    auto input = "3e10"sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(3e10);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(3e10);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("int scientific plus", "[.][parser, constant]")
-{
-    auto input = "3e+10"sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(3e+10);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(3e+10);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("int scientific minus", "[.][parser, constant]")
-{
-    auto input = "3e-10"sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(3e-10);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(3e-10);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("float scientific", "[.][parser, constant]")
-{
-    auto input = "2.7e10"sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(2.7e10);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(2.7e10);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("float scientific plus", "[.][parser, constant]")
-{
-    auto input = "2.7e+10"sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(2.7e+10);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(2.7e+10);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("float scientific minus", "[.][parser, constant]")
-{
-    auto input = "2.7e-10"sv;
-    const auto expected_ast = make_expr_ptr<FloatExpr>(2.7e-10);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(2.7e-10);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("constant boolean True", "[parser, constant]")
-{
-    auto input = "True"sv;
-    const auto expected_ast = make_expr_ptr<BoolExpr>(true);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("constant boolean", "[parser, constant]")
-{
-    auto input = "False"sv;
-    const auto expected_ast = make_expr_ptr<BoolExpr>(false);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("negate int", "[parser, neg]")
-{
-    auto input = "-1"sv;
-    const auto expected_ast = -make_expr_ptr<IntExpr>(1);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(-1));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("negate float", "[parser, neg]")
-{
-    auto input = "-1.0"sv;
-    const auto expected_ast = -make_expr_ptr<FloatExpr>(1.0);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(-1.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("negate bool false", "[parser, neg]")
-{
-    auto input = "-False"sv;
-    const auto expected_ast = -make_expr_ptr<BoolExpr>(false);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("negate bool true", "[parser, neg]")
-{
-    auto input = "-[]"sv;
-    const auto expected_ast = -make_list_expr();
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE_FALSE(eval.has_value());
-}
-
-TEST_CASE("inverse int 1", "[parser, not]")
-{
-    auto input = "not 1"sv;
-    const auto expected_ast = !make_expr_ptr<IntExpr>(1);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse float 1", "[parser, not]")
-{
-    auto input = "not 1.0"sv;
-    const auto expected_ast = !make_expr_ptr<FloatExpr>(1.0);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse int 0", "[parser, not]")
-{
-    auto input = "not 0"sv;
-    const auto expected_ast = !make_expr_ptr<IntExpr>(0);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse float 0", "[parser, not]")
-{
-    auto input = "not 0.0"sv;
-    const auto expected_ast = !make_expr_ptr<FloatExpr>(0.0);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse bool false", "[parser, not]")
-{
-    auto input = "not False"sv;
-    const auto expected_ast = !make_expr_ptr<BoolExpr>(false);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse bool true", "[parser, not]")
-{
-    auto input = "not True"sv;
-    const auto expected_ast = !make_expr_ptr<BoolExpr>(true);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse empty string", "[parser, not]")
-{
-    auto input = "not \"\""sv;
-    const auto expected_ast = !make_expr_ptr<StringExpr>("");
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse string", "[parser, not]")
-{
-    auto input = "not \"foo\""sv;
-    const auto expected_ast = !make_expr_ptr<StringExpr>("foo");
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse bool empty list", "[parser, not]")
-{
-    auto input = "not []"sv;
-    const auto expected_ast = !make_list_expr();
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("inverse bool list", "[parser, not]")
-{
-    auto input = "not [1]"sv;
-    const auto expected_ast = !make_list_expr(make_expr_ptr<IntExpr>(int64_t(1)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("member empty list", "[parser, member]")
-{
-    auto input = "1 in []"sv;
-
-    std::vector<ExprPtr> numbers;
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
-    numbers.push_back(make_list_expr());
-    const auto expected_ast = make_expr_ptr<ComparisonChainExpr>(std::move(numbers), std::vector{ComparisonOperators::Member});
+TEST_CASE("constant single digit", "[parser, constant]") {
+  auto input = "1"sv;
+  const auto expected_ast = make_expr_ptr<IntExpr>(1);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("constant multi digit", "[parser, constant]") {
+  auto input = "12345"sv;
+  const auto expected_ast = make_expr_ptr<IntExpr>(12345);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(12345));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("float", "[parser, constant]") {
+  auto input = "3.14"sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(3.14);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(3.14);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("float no integer", "[parser, constant]") {
+  auto input = ".0"sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(0.0);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("float no decimal", "[parser, constant]") {
+  auto input = "0."sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(0.0);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("int scientific", "[.][parser, constant]") {
+  auto input = "3e10"sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(3e10);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(3e10);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("int scientific plus", "[.][parser, constant]") {
+  auto input = "3e+10"sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(3e+10);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(3e+10);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("int scientific minus", "[.][parser, constant]") {
+  auto input = "3e-10"sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(3e-10);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(3e-10);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("float scientific", "[.][parser, constant]") {
+  auto input = "2.7e10"sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(2.7e10);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(2.7e10);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("float scientific plus", "[.][parser, constant]") {
+  auto input = "2.7e+10"sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(2.7e+10);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(2.7e+10);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("float scientific minus", "[.][parser, constant]") {
+  auto input = "2.7e-10"sv;
+  const auto expected_ast = make_expr_ptr<FloatExpr>(2.7e-10);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(2.7e-10);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("constant boolean True", "[parser, constant]") {
+  auto input = "True"sv;
+  const auto expected_ast = make_expr_ptr<BoolExpr>(true);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("constant boolean", "[parser, constant]") {
+  auto input = "False"sv;
+  const auto expected_ast = make_expr_ptr<BoolExpr>(false);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("negate int", "[parser, neg]") {
+  auto input = "-1"sv;
+  const auto expected_ast = -make_expr_ptr<IntExpr>(1);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(-1));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("negate float", "[parser, neg]") {
+  auto input = "-1.0"sv;
+  const auto expected_ast = -make_expr_ptr<FloatExpr>(1.0);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(-1.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("negate bool false", "[parser, neg]") {
+  auto input = "-False"sv;
+  const auto expected_ast = -make_expr_ptr<BoolExpr>(false);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("negate bool true", "[parser, neg]") {
+  auto input = "-[]"sv;
+  const auto expected_ast = -make_list_expr();
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE_FALSE(eval.has_value());
+}
+
+TEST_CASE("inverse int 1", "[parser, not]") {
+  auto input = "not 1"sv;
+  const auto expected_ast = !make_expr_ptr<IntExpr>(1);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse float 1", "[parser, not]") {
+  auto input = "not 1.0"sv;
+  const auto expected_ast = !make_expr_ptr<FloatExpr>(1.0);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse int 0", "[parser, not]") {
+  auto input = "not 0"sv;
+  const auto expected_ast = !make_expr_ptr<IntExpr>(0);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse float 0", "[parser, not]") {
+  auto input = "not 0.0"sv;
+  const auto expected_ast = !make_expr_ptr<FloatExpr>(0.0);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse bool false", "[parser, not]") {
+  auto input = "not False"sv;
+  const auto expected_ast = !make_expr_ptr<BoolExpr>(false);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse bool true", "[parser, not]") {
+  auto input = "not True"sv;
+  const auto expected_ast = !make_expr_ptr<BoolExpr>(true);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse empty string", "[parser, not]") {
+  auto input = "not \"\""sv;
+  const auto expected_ast = !make_expr_ptr<StringExpr>("");
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse string", "[parser, not]") {
+  auto input = "not \"foo\""sv;
+  const auto expected_ast = !make_expr_ptr<StringExpr>("foo");
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse bool empty list", "[parser, not]") {
+  auto input = "not []"sv;
+  const auto expected_ast = !make_list_expr();
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("inverse bool list", "[parser, not]") {
+  auto input = "not [1]"sv;
+  const auto expected_ast = !make_list_expr(make_expr_ptr<IntExpr>(int64_t(1)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("member empty list", "[parser, member]") {
+  auto input = "1 in []"sv;
+
+  std::vector<ExprPtr> numbers;
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
+  numbers.push_back(make_list_expr());
+  const auto expected_ast = make_expr_ptr<ComparisonChainExpr>(
+      std::move(numbers), std::vector{ComparisonOperators::Member});
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("member list", "[parser, member]") {
+  auto input = "1 in [1]"sv;
 
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("member list", "[parser, member]")
-{
-    auto input = "1 in [1]"sv;
+  std::vector<ExprPtr> expressions;
+  expressions.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
+  std::vector<ExprPtr> numbers;
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
+  expressions.push_back(make_list_expr(make_expr_ptr<IntExpr>(int64_t(1))));
 
-    std::vector<ExprPtr> expressions;
-    expressions.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
-    std::vector<ExprPtr> numbers;
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
-    expressions.push_back(make_list_expr(make_expr_ptr<IntExpr>(int64_t(1))));
-
-    std::vector<ComparisonOperators> operators = {ComparisonOperators::Member};
-
-    const auto expected_ast = make_expr_ptr<ComparisonChainExpr>(std::move(expressions), std::move(operators));
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
+  std::vector<ComparisonOperators> operators = {ComparisonOperators::Member};
+
+  const auto expected_ast = make_expr_ptr<ComparisonChainExpr>(
+      std::move(expressions), std::move(operators));
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("not member empty list", "[parser, member]") {
+  auto input = "1 not in []"sv;
+
+  std::vector<ExprPtr> numbers;
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
+
+  numbers.push_back(make_list_expr());
+
+  const auto expected_ast = make_expr_ptr<ComparisonChainExpr>(
+      std::move(numbers), std::vector{ComparisonOperators::NotMember});
 
-TEST_CASE("not member empty list", "[parser, member]")
-{
-    auto input = "1 not in []"sv;
-
-    std::vector<ExprPtr> numbers;
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
-
-    numbers.push_back(make_list_expr());
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("not member list", "[parser, member]") {
+  auto input = "1 not in [1]"sv;
 
-    const auto expected_ast = make_expr_ptr<ComparisonChainExpr>(std::move(numbers), std::vector{ComparisonOperators::NotMember});
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("not member list", "[parser, member]")
-{
-    auto input = "1 not in [1]"sv;
-
-    std::vector<ExprPtr> expressions;
-    expressions.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
-
-    std::vector<ExprPtr> numbers;
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
-    expressions.push_back(make_list_expr(make_expr_ptr<IntExpr>(int64_t(1))));
-
-    std::vector<ComparisonOperators> operators = {ComparisonOperators::NotMember};
-
-    const auto expected_ast = make_expr_ptr<ComparisonChainExpr>(std::move(expressions), std::move(operators));
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+  std::vector<ExprPtr> expressions;
+  expressions.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
+
+  std::vector<ExprPtr> numbers;
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
+  expressions.push_back(make_list_expr(make_expr_ptr<IntExpr>(int64_t(1))));
+
+  std::vector<ComparisonOperators> operators = {ComparisonOperators::NotMember};
+
+  const auto expected_ast = make_expr_ptr<ComparisonChainExpr>(
+      std::move(expressions), std::move(operators));
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
 
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression or operator", "[parser, expression]")
-{
-    auto input = "True or False"sv;
-    const auto expected_ast = make_expr_ptr<BoolExpr>(true) || make_expr_ptr<BoolExpr>(false);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression or operator", "[parser, expression]") {
+  auto input = "True or False"sv;
+  const auto expected_ast =
+      make_expr_ptr<BoolExpr>(true) || make_expr_ptr<BoolExpr>(false);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
 
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression addition operator", "[parser, expression]")
-{
-    auto input = "1 + 2"sv;
-    const auto expected_ast = make_expr_ptr<IntExpr>(1) + make_expr_ptr<IntExpr>(2);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(3));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression addition operator with float and bool", "[parser, expression]")
-{
-    auto input = "True + 0.4"sv;
-    const auto expected_ast = make_expr_ptr<BoolExpr>(true) + make_expr_ptr<FloatExpr>(0.4);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(1.4);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-
-TEST_CASE("expression subtraction operator", "[parser, expression]")
-{
-    auto input = "1 - 2"sv;
-    const auto expected_ast = make_expr_ptr<IntExpr>(1) - make_expr_ptr<IntExpr>(2);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(-1));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression pow operator", "[parser, expression]")
-{
-    auto input = "2 ** 3"sv;
-    const auto expected_ast = make_expr_ptr<PowExpr>(make_expr_ptr<IntExpr>(2), make_expr_ptr<IntExpr>(3));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(8));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression decimal pow operator", "[parser, expression]")
-{
-    auto input = "9 ** 0.5"sv;
-    const auto expected_ast = make_expr_ptr<PowExpr>(make_expr_ptr<IntExpr>(9), make_expr_ptr<FloatExpr>(0.5));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(3.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression multiply operator", "[parser, expression]")
-{
-    auto input = "2 * 2"sv;
-    const auto expected_ast = make_expr_ptr<IntExpr>(2) * make_expr_ptr<IntExpr>(2);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(4));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression division operator", "[parser, expression]")
-{
-    auto input = "2 / 2"sv;
-    const auto expected_ast = make_expr_ptr<IntExpr>(2) / make_expr_ptr<IntExpr>(2);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(1.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression multiple operators", "[parser, expression]")
-{
-    auto input = "4 + 4 ** 2 * 2"sv;
-    const auto expected_ast
-        = make_expr_ptr<IntExpr>(4)
-        + make_expr_ptr<PowExpr>(make_expr_ptr<IntExpr>(4), make_expr_ptr<IntExpr>(2))
-        * make_expr_ptr<IntExpr>(2);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(36));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("2 < 3", "[parser, expression]")
-{
-    auto input = "2 < 3"sv;
-
-    auto expected_ast = make_expr_ptr<IntExpr>(int64_t(2)) < make_expr_ptr<IntExpr>(int64_t(3));
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("15 < 300 < 25", "[parser, expression]")
-{
-    auto input = "15 < 300 < 25"sv;
-
-    std::vector<ExprPtr> numbers;
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(15)));
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(300)));
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(25)));
-    auto expected_ast = make_expr_ptr<ComparisonChainExpr>(
-        std::move(numbers),
-        std::vector{ComparisonOperators::LessThan, ComparisonOperators::LessThan}
-    );
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("1 < 2 <= 2", "[parser, expression]")
-{
-    auto input = "1 < 2 <= 2"sv;
-
-    std::vector<ExprPtr> numbers;
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(2)));
-    numbers.push_back(make_expr_ptr<IntExpr>(int64_t(2)));
-    auto expected_ast = make_expr_ptr<ComparisonChainExpr>(
-        std::move(numbers),
-        std::vector{ComparisonOperators::LessThan, ComparisonOperators::LessThenEqual}
-    );
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("simple variable", "[parser, variable]")
-{
-    auto input = "foo"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("foo"));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::string("bar"));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("foo", std::string("bar"));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("empty tuple", "[parser, tuple]")
-{
-    auto input = "()"sv;
-    const auto expected_ast = make_tuple_expr();
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::vector<CuraFormulaeEngine::eval::Value>{});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("single tuple", "[parser, tuple]")
-{
-    auto input = "(1)"sv;
-    const auto expected_ast = make_expr_ptr<IntExpr>(int64_t(1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("tuple trailing comma", "[parser, tuple]")
-{
-    auto input = "(1,  )"sv;
-    const auto expected_ast = make_expr_ptr<IntExpr>(int64_t(1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("double tuple", "[parser, tuple]")
-{
-    auto input = "(1, 2)"sv;
-    const auto expected_ast = make_tuple_expr(make_expr_ptr<IntExpr>(int64_t(1)), make_expr_ptr<IntExpr>(int64_t(2)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2)}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("trailing comma tuple", "[parser, tuple]")
-{
-    auto input = "(1, 2, )"sv;
-    const auto expected_ast = make_tuple_expr(make_expr_ptr<IntExpr>(int64_t(1)), make_expr_ptr<IntExpr>(int64_t(2)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2)}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("variable math.pi", "[parser, variable]")
-{
-    auto input = "math.pi"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.pi");
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::numbers::pi);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("variable math.e", "[parser, variable]")
-{
-    auto input = "math.e"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.e");
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::numbers::e);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn cos", "[parser, fn]")
-{
-    auto input = "math.cos(math.pi)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.cos")(make_expr_ptr<VariableExpr>("math.pi"));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::cos(std::numbers::pi));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn sin", "[parser, fn]")
-{
-    auto input = "math.sin(math.pi)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.sin")(make_expr_ptr<VariableExpr>("math.pi"));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::sin(std::numbers::pi));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn tan", "[parser, fn]")
-{
-    auto input = "math.tan(math.pi)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.tan")(make_expr_ptr<VariableExpr>("math.pi"));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::tan(std::numbers::pi));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn max", "[parser, fn]")
-{
-    auto input = "max(1, 2, 3, 4)"sv;
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(4));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn min", "[parser, fn]")
-{
-    auto input = "min(1, 2, 3, 4)"sv;
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn sum", "[parser, fn]")
-{
-    auto input = "sum([1, 2, 3, 4])"sv;
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(10));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn map", "[parser, fn]")
-{
-    auto input = "map(abs, [1, -2, 3, -4])"sv;
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2), int64_t(3), int64_t(4)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("empty list", "[parser, list]")
-{
-    auto input = "[]"sv;
-    const auto expected_ast = make_list_expr();
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("empty list whitespace", "[parser, list]")
-{
-    auto input = "[ ]"sv;
-    const auto expected_ast = make_list_expr();
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("bool list", "[parser, list]")
-{
-    auto input = "[True, True, False]"sv;
-    const auto expected_ast = make_list_expr(make_expr_ptr<BoolExpr>(true), make_expr_ptr<BoolExpr>(true),
-                                             make_expr_ptr<BoolExpr>(false));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{true, true, false}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("trailing comma bool list", "[parser, list]")
-{
-    auto input = "[True, True, False, ]"sv;
-    std::vector<ExprPtr> list;
-    const auto expected_ast = make_list_expr(make_expr_ptr<BoolExpr>(true), make_expr_ptr<BoolExpr>(true),
-                                             make_expr_ptr<BoolExpr>(false));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{true, true, false}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expr list", "[parser, list]")
-{
-    auto input = "[0 if True else 1, 4 ** 4, 1 > 2]"sv;
-    const auto expected_ast = make_list_expr(
-            make_expr_ptr<ConditionExpr>(make_expr_ptr<IntExpr>(0), make_expr_ptr<BoolExpr>(true),
-                                         make_expr_ptr<IntExpr>(1)),
-            make_expr_ptr<PowExpr>(make_expr_ptr<IntExpr>(4), make_expr_ptr<IntExpr>(4)),
-            make_expr_ptr<IntExpr>(1) > make_expr_ptr<IntExpr>(2));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(256), false}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("simple list comprehension", "[parser, list comprehension]")
-{
-    auto input = "[x for x in dummy_array]"sv;
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>("x"), make_expr_ptr<VariableExpr>("dummy_array"),
-                       std::vector<ExprPtr>{});
-    const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>("x"), std::move(loops));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4), int64_t(5),
-                                              int64_t(6), int64_t(7), int64_t(8), int64_t(9), int64_t(10)}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("expression list comprehension", "[parser, list comprehension]")
-{
-    auto input = "[x * 2 for x in dummy_array]"sv;
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>("x"), make_expr_ptr<VariableExpr>("dummy_array"),
-                       std::vector<ExprPtr>{});
-    const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
-            make_expr_ptr<VariableExpr>("x") * make_expr_ptr<IntExpr>(2), std::move(loops));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(2), int64_t(4), int64_t(6), int64_t(8), int64_t(10),
-                                              int64_t(12), int64_t(14), int64_t(16), int64_t(18), int64_t(20)}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("simple list comprehension even", "[parser, list comprehension]")
-{
-    auto input = "[x for x in dummy_array if x % 2 == 0]"sv;
-    auto conditions = std::vector<ExprPtr>{};
-    conditions.emplace_back(make_expr_ptr<VariableExpr>("x") % make_expr_ptr<IntExpr>(2) == make_expr_ptr<IntExpr>(0));
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>("x"), make_expr_ptr<VariableExpr>("dummy_array"),
-                       std::move(conditions));
-    const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>("x"), std::move(loops));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(2), int64_t(4), int64_t(6), int64_t(8), int64_t(10)}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("simple list comprehension expression and condition", "[parser, list comprehension]")
-{
-    auto input = "[x * 2 for x in dummy_array if x <= 1]"sv;
-    auto conditions = std::vector<ExprPtr>{};
-    conditions.emplace_back(make_expr_ptr<VariableExpr>("x") <= make_expr_ptr<IntExpr>(1));
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>("x"), make_expr_ptr<VariableExpr>("dummy_array"),
-                       std::move(conditions));
-    const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
-            make_expr_ptr<VariableExpr>("x") * make_expr_ptr<IntExpr>(2), std::move(loops));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(2)}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("list comprehension inline list", "[parser, list comprehension]")
-{
-    auto input = "[x for x in [0, 1]]"sv;
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>("x"),
-                       make_list_expr(make_expr_ptr<IntExpr>(int64_t(0)), make_expr_ptr<IntExpr>(int64_t(1))),
-                       std::vector<ExprPtr>{});
-    const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>("x"), std::move(loops));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1)}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("list comprehension if chains", "[parser, list comprehension]")
-{
-    auto input = "[x for x in [1, 2, 3] if x <= 2 if x >= 2]"sv;
-    auto conditions = std::vector<ExprPtr>{};
-    conditions.emplace_back(make_expr_ptr<VariableExpr>("x") <= make_expr_ptr<IntExpr>(2));
-    conditions.emplace_back(make_expr_ptr<VariableExpr>("x") >= make_expr_ptr<IntExpr>(2));
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(
-            make_expr_ptr<VariableExpr>("x"),
-            make_list_expr(make_expr_ptr<IntExpr>(int64_t(1)), make_expr_ptr<IntExpr>(int64_t(2)),
-                           make_expr_ptr<IntExpr>(int64_t(3))),
-            std::move(conditions));
-    const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>("x"), std::move(loops));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(2)}};
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("Nested list comprehension", "[parser, list comprehension]")
-{
-    auto input = "[x for x in (y for y in [[1, 2], [3, 4]])]"sv;
-
-    auto loops_b = std::vector<ListComprehensionExpr::loop>{};
-    loops_b.emplace_back(
-            make_expr_ptr<VariableExpr>("y"),
-            make_list_expr(
-                    make_list_expr(make_expr_ptr<IntExpr>(int64_t(1)), make_expr_ptr<IntExpr>(int64_t(2))),
-                    make_list_expr(make_expr_ptr<IntExpr>(int64_t(3)), make_expr_ptr<IntExpr>(int64_t(4)))),
-            std::vector<ExprPtr>{});
-    auto loops_a = std::vector<ListComprehensionExpr::loop>{};
-    loops_a.emplace_back(make_expr_ptr<VariableExpr>("x"),
-                         make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>("y"), std::move(loops_b)),
-                         std::vector<ExprPtr>{});
-    const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>("x"),
-                                                                   std::move(loops_a));
-
-    const auto expected_eval
-            = CuraFormulaeEngine::eval::Value{
-                    std::vector<CuraFormulaeEngine::eval::Value>{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2)},
-                                                      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(3), int64_t(4)}}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("Flatten list comprehension", "[parser, list comprehension]")
-{
-    auto input = "[item for row in matrix for item in row]"sv;
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2), int64_t(3), int64_t(4)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("matrix",
-                   std::vector<CuraFormulaeEngine::eval::Value>{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2)},
-                                                     std::vector<CuraFormulaeEngine::eval::Value>{int64_t(3), int64_t(4)}});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("Flatten list comprehension condition", "[parser, list comprehension]")
-{
-    auto input = "[item for row in matrix if len(row) >= 3 for item in row]"sv;
-
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2), int64_t(3), int64_t(6), int64_t(7), int64_t(8)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set(
-            "matrix",
-            std::vector<CuraFormulaeEngine::eval::Value>{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2), int64_t(3)},
-                                              std::vector<CuraFormulaeEngine::eval::Value>{int64_t(4), int64_t(5)},
-                                              std::vector<CuraFormulaeEngine::eval::Value>{int64_t(6), int64_t(7), int64_t(8)}});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("Single quoted string", "[parser, string]")
-{
-    auto input = "'HELLO WORLD'"sv;
-    const auto expected_ast = make_expr_ptr<StringExpr>(std::string("HELLO WORLD"));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::string("HELLO WORLD"));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("Single quoted empty string", "[parser, string]")
-{
-    auto input = "''"sv;
-    const auto expected_ast = make_expr_ptr<StringExpr>(std::string(""));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::string(""));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("Double quoted string", "[parser, string]")
-{
-    auto input = "\"FOO BAR\""sv;
-    const auto expected_ast = make_expr_ptr<StringExpr>(std::string("FOO BAR"));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::string("FOO BAR"));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("String with parenthesis", "[parser, string]")
-{
-    auto input = "\"Marlin (Volumetric)\""sv;
-    const auto expected_ast = make_expr_ptr<StringExpr>(std::string("Marlin (Volumetric)"));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::string("Marlin (Volumetric)"));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("Double quoted empty string", "[parser, string]")
-{
-    auto input = "\"\""sv;
-    const auto expected_ast = make_expr_ptr<StringExpr>(std::string(""));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(std::string(""));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn int", "[parser, fn]")
-{
-    auto input = "int(0.1)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("int")(make_expr_ptr<FloatExpr>(0.1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn neg int", "[parser, fn]")
-{
-    auto input = "int(-0.1)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("int")(-make_expr_ptr<FloatExpr>(0.1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn int str input", "[parser, fn]")
-{
-    auto input = "int(\"100\")"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("int")(make_expr_ptr<StringExpr>("100"));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(100));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn int str input base", "[parser, fn]")
-{
-    auto input = "int(\"100\", 2)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("int"))(make_expr_ptr<StringExpr>("100"),
-                                                                              make_expr_ptr<IntExpr>(int64_t(2)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(4));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn floor", "[parser, fn]")
-{
-    auto input = "math.floor(0.1)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.floor")(make_expr_ptr<FloatExpr>(0.1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn ceil", "[parser, fn]")
-{
-    auto input = "math.ceil(0.1)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.ceil")(make_expr_ptr<FloatExpr>(0.1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(1.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn math.log(1)", "[parser, fn]")
-{
-    auto input = "math.log(1)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.log")(make_expr_ptr<IntExpr>(int64_t(1)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn math.log(1.0)", "[parser, fn]")
-{
-    auto input = "math.log(1.0)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.log")(make_expr_ptr<FloatExpr>(1.0));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn math.log(4096, 8)", "[parser, fn]")
-{
-    auto input = "math.log(4096, 8)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.log")(make_expr_ptr<IntExpr>(int64_t(4096)),
-                                                                      make_expr_ptr<IntExpr>(int64_t(8)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(4.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn math.log(True)", "[parser, fn]")
-{
-    auto input = "math.log(True)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("math.log")(make_expr_ptr<BoolExpr>(true));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("condition True", "[parser, condition]")
-{
-    auto input = "1 if True else 0"sv;
-    const auto expected_ast = make_expr_ptr<ConditionExpr>(make_expr_ptr<IntExpr>(1), make_expr_ptr<BoolExpr>(true),
-                                                           make_expr_ptr<IntExpr>(0));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("condition False", "[parser, condition]")
-{
-    auto input = "1 if False else 0"sv;
-    const auto expected_ast = make_expr_ptr<ConditionExpr>(make_expr_ptr<IntExpr>(1), make_expr_ptr<BoolExpr>(false),
-                                                           make_expr_ptr<IntExpr>(0));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("nested condition 1", "[parser, condition]")
-{
-    auto input = "1 if False else 2 if False else 3"sv;
-    const auto expected_ast = make_expr_ptr<ConditionExpr>(
-            make_expr_ptr<IntExpr>(1),
-            make_expr_ptr<BoolExpr>(false),
-            make_expr_ptr<ConditionExpr>(make_expr_ptr<IntExpr>(2), make_expr_ptr<BoolExpr>(false),
-                                         make_expr_ptr<IntExpr>(3)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(3));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("nested condition 2", "[parser, condition]")
-{
-    auto input = "1 if False else 2 if False else 3 if False else 4"sv;
-    const auto expected_ast = make_expr_ptr<ConditionExpr>(
-            make_expr_ptr<IntExpr>(1),
-            make_expr_ptr<BoolExpr>(false),
-            make_expr_ptr<ConditionExpr>(
-                    make_expr_ptr<IntExpr>(2),
-                    make_expr_ptr<BoolExpr>(false),
-                    make_expr_ptr<ConditionExpr>(make_expr_ptr<IntExpr>(3), make_expr_ptr<BoolExpr>(false),
-                                                 make_expr_ptr<IntExpr>(4))));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(4));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("index simple 0", "[parser, index]")
-{
-    auto input = "dummy_array[0]"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("dummy_array"))[make_expr_ptr<IntExpr>(0)];
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("slice index out of bounds positive", "[parser, index]")
-{
-    auto input = "dummy_array[11]"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("dummy_array"))[make_expr_ptr<IntExpr>(11)];
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE_FALSE(eval.has_value());
-    REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::IndexOutOfBounds);
-}
-
-TEST_CASE("slice index out of bounds negative", "[parser, index]")
-{
-    auto input = "dummy_array[-12]"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("dummy_array"))[-make_expr_ptr<IntExpr>(12)];
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE_FALSE(eval.has_value());
-    REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::IndexOutOfBounds);
-}
-
-TEST_CASE("non integer index", "[parser, slice]")
-{
-    auto input = "dummy_array[0.1]"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("dummy_array"))[make_expr_ptr<FloatExpr>(0.1)];
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE_FALSE(eval.has_value());
-    REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::TypeMismatch);
-}
-
-TEST_CASE("simple slice", "[parser, slice]")
-{
-    auto input = "dummy_array[0:10:1]"sv;
-    const auto expected_ast
-            = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                       make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(10),
-                                       make_expr_ptr<IntExpr>(1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4), int64_t(5),
-                                              int64_t(6), int64_t(7), int64_t(8), int64_t(9), int64_t(10)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("simple slice space", "[parser, slice]")
-{
-    auto input = "dummy_array[0 : 10 : 1]"sv;
-    const auto expected_ast
-            = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                       make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(10),
-                                       make_expr_ptr<IntExpr>(1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4), int64_t(5),
-                                              int64_t(6), int64_t(7), int64_t(8), int64_t(9), int64_t(10)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("simple slice syntax sugar", "[parser, slice]")
-{
-    auto input = "dummy_array[0:10]"sv;
-    const auto expected_ast
-            = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                       make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(10), std::nullopt);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4), int64_t(5),
-                                              int64_t(6), int64_t(7), int64_t(8), int64_t(9), int64_t(10)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("simple slice out of bound", "[parser, slice]")
-{
-    auto input = "dummy_array[0:11:1]"sv;
-    const auto expected_ast
-            = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                       make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(11),
-                                       make_expr_ptr<IntExpr>(1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4), int64_t(5),
-                                              int64_t(6), int64_t(7), int64_t(8), int64_t(9), int64_t(10)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("reverse slice", "[parser, slice]")
-{
-    auto input = "dummy_array[10:0:-1]"sv;
-    const auto expected_ast
-            = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                       make_expr_ptr<IntExpr>(10), make_expr_ptr<IntExpr>(0),
-                                       -make_expr_ptr<IntExpr>(1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(10), int64_t(9), int64_t(8), int64_t(7), int64_t(6), int64_t(5),
-                                              int64_t(4), int64_t(3), int64_t(2), int64_t(1), int64_t(0)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("array slice step size 2", "[parser, slice]")
-{
-    auto input = "dummy_array[0:10:2]"sv;
-    const auto expected_ast
-            = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                       make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(10),
-                                       make_expr_ptr<IntExpr>(2));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(2), int64_t(4), int64_t(6), int64_t(8), int64_t(10)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("slice empty value start/end index step size", "[parser, slice]")
-{
-    auto input = "dummy_array[::]"sv;
-    const auto expected_ast = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                                       std::nullopt, std::nullopt, std::nullopt);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4), int64_t(5),
-                                              int64_t(6), int64_t(7), int64_t(8), int64_t(9), int64_t(10)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("slice empty value start/end index negative step size", "[parser, slice]")
-{
-    auto input = "dummy_array[::-1]"sv;
-    const auto expected_ast = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                                       std::nullopt, std::nullopt, -make_expr_ptr<IntExpr>(1));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(10), int64_t(9), int64_t(8), int64_t(7), int64_t(6), int64_t(5),
-                                              int64_t(4), int64_t(3), int64_t(2), int64_t(1), int64_t(0)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("slice empty value start index, step size", "[parser, slice]")
-{
-    auto input = "dummy_array[:-2]"sv;
-    const auto expected_ast = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                                       std::nullopt, -make_expr_ptr<IntExpr>(2), std::nullopt);
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{
-            std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4), int64_t(5),
-                                              int64_t(6), int64_t(7), int64_t(8)}};
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("non integer slice start index", "[parser, slice]")
-{
-    auto input = "dummy_array[0.1::]"sv;
-    const auto expected_ast = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                                       make_expr_ptr<FloatExpr>(0.1), std::nullopt, std::nullopt);
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE_FALSE(eval.has_value());
-    REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::TypeMismatch);
-}
-
-
-TEST_CASE("non integer slice end index", "[parser, slice]")
-{
-    auto input = "dummy_array[:0.1:]"sv;
-    const auto expected_ast = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                                       std::nullopt, make_expr_ptr<FloatExpr>(0.1), std::nullopt);
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE_FALSE(eval.has_value());
-    REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::TypeMismatch);
-}
-
-TEST_CASE("non integer slice step size", "[parser, slice]")
-{
-    auto input = "dummy_array[::0.1]"sv;
-    const auto expected_ast = make_expr_ptr<SliceExpr>(make_expr_ptr<VariableExpr>(std::string("dummy_array")),
-                                                       std::nullopt, std::nullopt, make_expr_ptr<FloatExpr>(0.1));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE_FALSE(eval.has_value());
-    REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::TypeMismatch);
-}
-
-TEST_CASE("index simple 10", "[parser, index]")
-{
-    auto input = "dummy_array[10]"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("dummy_array"))[make_expr_ptr<IntExpr>(10)];
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(10));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("index last", "[parser, index]")
-{
-    auto input = "dummy_array[-1]"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("dummy_array"))[-make_expr_ptr<IntExpr>(1)];
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(10));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("index last first", "[parser, index]")
-{
-    auto input = "dummy_array[-11]"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("dummy_array"))[-make_expr_ptr<IntExpr>(11)];
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("index without index value", "[parser, index]")
-{
-    auto input = "dummy_array[]"sv;
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(!message.has_value());
-}
-
-TEST_CASE("fn any", "[parser, fn]")
-{
-    auto input = "any([True])"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("any")(make_list_expr(make_expr_ptr<BoolExpr>(true)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("index function application", "[parser, index]")
-{
-    auto input = "map(abs, [1, -2, 3, -4])[0]"sv;
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(CuraFormulaeEngine::eval::Value(int64_t(1))));
-}
-
-TEST_CASE("double index", "[parser, index]")
-{
-    auto input = "dummy_array[0][0]"sv;
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array", std::vector<CuraFormulaeEngine::eval::Value>{
-            CuraFormulaeEngine::eval::Value(std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0)})});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-}
-
-TEST_CASE("fn round", "[parser, fn]")
-{
-    auto input = "round(1.5)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("round")(make_expr_ptr<FloatExpr>(1.5));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(2));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn round base=1", "[parser, fn]")
-{
-    auto input = "round(1.5, 1)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("round")(make_expr_ptr<FloatExpr>(1.5),
-                                                                   make_expr_ptr<IntExpr>(int64_t(1)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(1.5);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn round base=-1", "[parser, fn]")
-{
-    auto input = "round(15, -1)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("round")(make_expr_ptr<IntExpr>(int64_t(15)),
-                                                                   -make_expr_ptr<IntExpr>(int64_t(1)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(20));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn round base=5", "[parser, fn]")
-{
-    auto input = "round(0.2*60/100, 5)"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("round")(
-            make_expr_ptr<FloatExpr>(0.2) * make_expr_ptr<IntExpr>(60) / make_expr_ptr<IntExpr>(100),
-            make_expr_ptr<IntExpr>(int64_t(5)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(0.12);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn any trailing comma", "[parser, fn]")
-{
-    auto input = "any([True], )"sv;
-    const auto expected_ast = make_expr_ptr<VariableExpr>("any")(make_list_expr(make_expr_ptr<BoolExpr>(true)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("fn list comprehension", "[parser, fn]")
-{
-    auto input = "all(x <= 10 for x in dummy_array)"sv;
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>("x"), make_expr_ptr<VariableExpr>("dummy_array"),
-                       std::vector<ExprPtr>{});
-    const auto expected_ast
-            = make_expr_ptr<VariableExpr>("all")(
-                    make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>("x") <= make_expr_ptr<IntExpr>(10),
-                                                         std::move(loops)));
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("dummy_array",
-                   std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
-                                                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
-                                                     int64_t(10)});
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("parse endcode", "[parser, real example]")
-{
-    auto input
-            = "\";Version _2.6 of the firmware can abort the print too early if the file ends\\n;too soon. However if the file hasn't ended yet because there are comments at\\n;the end of the file, it won't abort yet. Therefore we have to put at least 512\\n;bytes at the end of the g-code so that the file is not yet finished by the\\n;time that the motion planner gets flushed. With firmware version _3.3 this\\n;should be fixed, so this comment wouldn't be necessary any more. Now we have\\n;to pad this text to make precisely 512 bytes.\"  if machine_gcode_flavor == \"UltiGCode\" else \"M104 S0 ;extruder heater off\\nM140 S0 ;heated bed heater off (if you have it)\\nG91 ;relative positioning\\nG1 E-1 F300  ;retract the filament a bit before lifting the nozzle, to release some of the pressure\\nG1 Z+0.5 E-5 X-20 Y-20 F9000 ;move Z up a bit and retract filament even more\\nG28 X0 Y0 ;move X/Y to min endstops, so the head is out of the way\\nM84 ;steppers off\\nG90 ;absolute positioning\\n;Version _2.6 of the firmware can abort the print too early if the file ends\\n;too soon. However if the file hasn't ended yet because there are comments at\\n;the end of the file, it won't abort yet. Therefore we have to put at least 512\\n;bytes at the end of the g-code so that the file is not yet finished by the\\n;time that the motion planner gets flushed. With firmware version _3.3 this\\n;should be fixed, so this comment wouldn't be necessary any more. Now we have\\n;to pad this text to make precisely 512 bytes.\""sv;
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-}
-
-TEST_CASE("simple var free variable", "[free variables, variable]")
-{
-    auto ast = make_expr_ptr<VariableExpr>(std::string("foo"));
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.size() == 1);
-    REQUIRE(free_variables.contains(std::string("foo")));
-}
-
-TEST_CASE("float has no free variable", "[free variables, float]")
-{
-    auto ast = make_expr_ptr<FloatExpr>(1.0);
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.empty());
-}
-
-TEST_CASE("int has no free variable", "[free variables, int]")
-{
-    auto ast = make_expr_ptr<IntExpr>(1);
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.empty());
-}
-
-TEST_CASE("string has no free variable", "[free variables, string]")
-{
-    auto ast = make_expr_ptr<StringExpr>(std::string("hello world"));
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.empty());
-}
-
-TEST_CASE("bool has no free variable", "[free variables, bool]")
-{
-    auto ast = make_expr_ptr<BoolExpr>(true);
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.empty());
-}
-
-TEST_CASE("free_variables(foo()) = { foo }", "[free variables, fn]")
-{
-    auto ast = make_expr_ptr<FnApplicationExpr>(make_expr_ptr<VariableExpr>(std::string("foo")),
-                                                std::vector<ExprPtr>{});
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.size() == 1);
-    REQUIRE(free_variables.contains(std::string("foo")));
-}
-
-TEST_CASE("free_variables(x^2) = { x }", "[free variables, x^2]")
-{
-    auto ast = make_expr_ptr<PowExpr>(make_expr_ptr<VariableExpr>(std::string("x")), make_expr_ptr<IntExpr>(2));
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.size() == 1);
-    REQUIRE(free_variables.contains(std::string("x")));
-}
-
-TEST_CASE("free_variables([1, x, 2, y, 3]) = { x, y }", "[free variables, list]")
-{
-    auto ast = make_list_expr(
-            make_expr_ptr<IntExpr>(1),
-            make_expr_ptr<VariableExpr>(std::string("x")),
-            make_expr_ptr<IntExpr>(2),
-            make_expr_ptr<VariableExpr>(std::string("y")),
-            make_expr_ptr<IntExpr>(3));
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.size() == 2);
-    REQUIRE(free_variables.contains(std::string("x")));
-    REQUIRE(free_variables.contains(std::string("y")));
-}
-
-TEST_CASE("free_variables([x for x in dummy_array]) = { dummy_array }", "[free variables, list comprehension]")
-{
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>(std::string("x")),
-                       make_expr_ptr<VariableExpr>(std::string("dummy_array")), std::vector<ExprPtr>{});
-    auto ast = make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>(std::string("x")), std::move(loops));
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.size() == 1);
-    REQUIRE(free_variables.contains(std::string("dummy_array")));
-}
-
-TEST_CASE("free_variables([x for x in x]) = { x }", "[free variables, list comprehension]")
-{
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>(std::string("x")), make_expr_ptr<VariableExpr>(std::string("x")),
-                       std::vector<ExprPtr>{});
-    auto ast = make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>(std::string("x")), std::move(loops));
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.size() == 1);
-    REQUIRE(free_variables.contains(std::string("x")));
-}
-
-TEST_CASE("free_variables([item for row in matrix for item in row]) = { matrix }",
-          "[free variables, list comprehension]")
-{
-    auto loops = std::vector<ListComprehensionExpr::loop>{};
-    loops.emplace_back(make_expr_ptr<VariableExpr>(std::string("row")),
-                       make_expr_ptr<VariableExpr>(std::string("matrix")), std::vector<ExprPtr>{});
-    loops.emplace_back(make_expr_ptr<VariableExpr>(std::string("item")),
-                       make_expr_ptr<VariableExpr>(std::string("row")), std::vector<ExprPtr>{});
-    auto ast = make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>(std::string("item")), std::move(loops));
-    auto free_variables = ast.freeVariables();
-    REQUIRE(free_variables.size() == 1);
-    REQUIRE(free_variables.contains(std::string("matrix")));
-}
-
-TEST_CASE("real world expression",
-          "[parser, fdm_printer.def.json example]")
-{
-    auto input = "int(defaultExtruderPosition()) if resolveOrValue('adhesion_type') == 'raft' else -1"sv;
-
-    const auto expected_ast = make_expr_ptr<ConditionExpr>(
-            make_expr_ptr<VariableExpr>(std::string("int"))(
-                    make_expr_ptr<VariableExpr>(std::string("defaultExtruderPosition"))()),
-            make_expr_ptr<VariableExpr>(std::string("resolveOrValue"))(
-                    make_expr_ptr<StringExpr>(std::string("adhesion_type"))) ==
-            make_expr_ptr<StringExpr>(std::string("raft")),
-            -make_expr_ptr<IntExpr>(int64_t(1)));
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-    REQUIRE(ast.deepEq(expected_ast));
-}
-
-TEST_CASE("prime tower parser", "[parser, fdm_printer.def.json example]")
-{
-    auto input
-            = "'none' if (extruders_enabled_count < 2) else ('interleaved' if (all(material_type_var == extruderValues('material_type')[0] for material_type_var in extruderValues('material_type')) and all(material_brand_var == extruderValues('material_brand')[0] for material_brand_var in extruderValues('material_brand'))) else 'normal')"sv;
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-}
-
-TEST_CASE("s8 bottom_thickness setting parser", "[parser, fdm_printer.def.json example]")
-{
-    auto input = "3*layer_height if top_layers==4 and not support_enable else top_bottom_thickness"sv;
-    const auto expected_eval = CuraFormulaeEngine::eval::Value(0.6018);
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("layer_height", 0.2006);
-    custom_env.set("top_layers", int64_t(4));
-    custom_env.set("support_enable", false);
-    custom_env.set("top_bottom_thickness", 0.8);
-
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
-}
-
-TEST_CASE("Falcon infill", "[parser, fdm_printer.def.json example]")
-{
-    auto input = "[-40,50] if infill_pattern in ('grid', 'lines', 'zigzag')  else [ ]"sv;
-    const auto expected_eval = CuraFormulaeEngine::eval::Value{std::vector<CuraFormulaeEngine::eval::Value>{int64_t(-40), int64_t(50)}};
-
-    const auto message = CuraFormulaeEngine::parser::parse(input);
-    REQUIRE(message.has_value());
-    const auto &ast = message.value();
-
-    CuraFormulaeEngine::env::LocalEnvironment custom_env{&CuraFormulaeEngine::env::std_env};
-    custom_env.set("infill_pattern", std::string("grid"));
-
-    const auto eval = ast.evaluate(&custom_env);
-    REQUIRE(eval.has_value());
-    REQUIRE(eval.value().deepEq(expected_eval));
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression addition operator", "[parser, expression]") {
+  auto input = "1 + 2"sv;
+  const auto expected_ast =
+      make_expr_ptr<IntExpr>(1) + make_expr_ptr<IntExpr>(2);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(3));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression addition operator with float and bool",
+          "[parser, expression]") {
+  auto input = "True + 0.4"sv;
+  const auto expected_ast =
+      make_expr_ptr<BoolExpr>(true) + make_expr_ptr<FloatExpr>(0.4);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(1.4);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression subtraction operator", "[parser, expression]") {
+  auto input = "1 - 2"sv;
+  const auto expected_ast =
+      make_expr_ptr<IntExpr>(1) - make_expr_ptr<IntExpr>(2);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(-1));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression pow operator", "[parser, expression]") {
+  auto input = "2 ** 3"sv;
+  const auto expected_ast = make_expr_ptr<PowExpr>(make_expr_ptr<IntExpr>(2),
+                                                   make_expr_ptr<IntExpr>(3));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(8));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression decimal pow operator", "[parser, expression]") {
+  auto input = "9 ** 0.5"sv;
+  const auto expected_ast = make_expr_ptr<PowExpr>(
+      make_expr_ptr<IntExpr>(9), make_expr_ptr<FloatExpr>(0.5));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(3.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression multiply operator", "[parser, expression]") {
+  auto input = "2 * 2"sv;
+  const auto expected_ast =
+      make_expr_ptr<IntExpr>(2) * make_expr_ptr<IntExpr>(2);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(4));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression division operator", "[parser, expression]") {
+  auto input = "2 / 2"sv;
+  const auto expected_ast =
+      make_expr_ptr<IntExpr>(2) / make_expr_ptr<IntExpr>(2);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(1.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression multiple operators", "[parser, expression]") {
+  auto input = "4 + 4 ** 2 * 2"sv;
+  const auto expected_ast = make_expr_ptr<IntExpr>(4) +
+                            make_expr_ptr<PowExpr>(make_expr_ptr<IntExpr>(4),
+                                                   make_expr_ptr<IntExpr>(2)) *
+                                make_expr_ptr<IntExpr>(2);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(36));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("2 < 3", "[parser, expression]") {
+  auto input = "2 < 3"sv;
+
+  auto expected_ast =
+      make_expr_ptr<IntExpr>(int64_t(2)) < make_expr_ptr<IntExpr>(int64_t(3));
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("15 < 300 < 25", "[parser, expression]") {
+  auto input = "15 < 300 < 25"sv;
+
+  std::vector<ExprPtr> numbers;
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(15)));
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(300)));
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(25)));
+  auto expected_ast = make_expr_ptr<ComparisonChainExpr>(
+      std::move(numbers), std::vector{ComparisonOperators::LessThan,
+                                      ComparisonOperators::LessThan});
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(false);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("1 < 2 <= 2", "[parser, expression]") {
+  auto input = "1 < 2 <= 2"sv;
+
+  std::vector<ExprPtr> numbers;
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(1)));
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(2)));
+  numbers.push_back(make_expr_ptr<IntExpr>(int64_t(2)));
+  auto expected_ast = make_expr_ptr<ComparisonChainExpr>(
+      std::move(numbers), std::vector{ComparisonOperators::LessThan,
+                                      ComparisonOperators::LessThenEqual});
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("simple variable", "[parser, variable]") {
+  auto input = "foo"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("foo"));
+  const auto expected_eval =
+      CuraFormulaeEngine::eval::Value(std::string("bar"));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("foo", std::string("bar"));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("empty tuple", "[parser, tuple]") {
+  auto input = "()"sv;
+  const auto expected_ast = make_tuple_expr();
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(
+      std::vector<CuraFormulaeEngine::eval::Value>{});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("single tuple", "[parser, tuple]") {
+  auto input = "(1)"sv;
+  const auto expected_ast = make_expr_ptr<IntExpr>(int64_t(1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("tuple trailing comma", "[parser, tuple]") {
+  auto input = "(1,  )"sv;
+  const auto expected_ast = make_expr_ptr<IntExpr>(int64_t(1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("double tuple", "[parser, tuple]") {
+  auto input = "(1, 2)"sv;
+  const auto expected_ast = make_tuple_expr(make_expr_ptr<IntExpr>(int64_t(1)),
+                                            make_expr_ptr<IntExpr>(int64_t(2)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2)}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("trailing comma tuple", "[parser, tuple]") {
+  auto input = "(1, 2, )"sv;
+  const auto expected_ast = make_tuple_expr(make_expr_ptr<IntExpr>(int64_t(1)),
+                                            make_expr_ptr<IntExpr>(int64_t(2)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2)}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("variable math.pi", "[parser, variable]") {
+  auto input = "math.pi"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("math.pi");
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(std::numbers::pi);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("variable math.e", "[parser, variable]") {
+  auto input = "math.e"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("math.e");
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(std::numbers::e);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn cos", "[parser, fn]") {
+  auto input = "math.cos(math.pi)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("math.cos")(
+      make_expr_ptr<VariableExpr>("math.pi"));
+  const auto expected_eval =
+      CuraFormulaeEngine::eval::Value(std::cos(std::numbers::pi));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn sin", "[parser, fn]") {
+  auto input = "math.sin(math.pi)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("math.sin")(
+      make_expr_ptr<VariableExpr>("math.pi"));
+  const auto expected_eval =
+      CuraFormulaeEngine::eval::Value(std::sin(std::numbers::pi));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn tan", "[parser, fn]") {
+  auto input = "math.tan(math.pi)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("math.tan")(
+      make_expr_ptr<VariableExpr>("math.pi"));
+  const auto expected_eval =
+      CuraFormulaeEngine::eval::Value(std::tan(std::numbers::pi));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn max", "[parser, fn]") {
+  auto input = "max(1, 2, 3, 4)"sv;
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(4));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn min", "[parser, fn]") {
+  auto input = "min(1, 2, 3, 4)"sv;
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn sum", "[parser, fn]") {
+  auto input = "sum([1, 2, 3, 4])"sv;
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(10));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn map", "[parser, fn]") {
+  auto input = "map(abs, [1, -2, 3, -4])"sv;
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2),
+                                                   int64_t(3), int64_t(4)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("empty list", "[parser, list]") {
+  auto input = "[]"sv;
+  const auto expected_ast = make_list_expr();
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("empty list whitespace", "[parser, list]") {
+  auto input = "[ ]"sv;
+  const auto expected_ast = make_list_expr();
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("bool list", "[parser, list]") {
+  auto input = "[True, True, False]"sv;
+  const auto expected_ast = make_list_expr(make_expr_ptr<BoolExpr>(true),
+                                           make_expr_ptr<BoolExpr>(true),
+                                           make_expr_ptr<BoolExpr>(false));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{true, true, false}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("trailing comma bool list", "[parser, list]") {
+  auto input = "[True, True, False, ]"sv;
+  std::vector<ExprPtr> list;
+  const auto expected_ast = make_list_expr(make_expr_ptr<BoolExpr>(true),
+                                           make_expr_ptr<BoolExpr>(true),
+                                           make_expr_ptr<BoolExpr>(false));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{true, true, false}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expr list", "[parser, list]") {
+  auto input = "[0 if True else 1, 4 ** 4, 1 > 2]"sv;
+  const auto expected_ast =
+      make_list_expr(make_expr_ptr<ConditionExpr>(make_expr_ptr<IntExpr>(0),
+                                                  make_expr_ptr<BoolExpr>(true),
+                                                  make_expr_ptr<IntExpr>(1)),
+                     make_expr_ptr<PowExpr>(make_expr_ptr<IntExpr>(4),
+                                            make_expr_ptr<IntExpr>(4)),
+                     make_expr_ptr<IntExpr>(1) > make_expr_ptr<IntExpr>(2));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(256),
+                                                   false}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("simple list comprehension", "[parser, list comprehension]") {
+  auto input = "[x for x in dummy_array]"sv;
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>("x"),
+                     make_expr_ptr<VariableExpr>("dummy_array"),
+                     std::vector<ExprPtr>{});
+  const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>("x"), std::move(loops));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+          int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+          int64_t(10)}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("expression list comprehension", "[parser, list comprehension]") {
+  auto input = "[x * 2 for x in dummy_array]"sv;
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>("x"),
+                     make_expr_ptr<VariableExpr>("dummy_array"),
+                     std::vector<ExprPtr>{});
+  const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>("x") * make_expr_ptr<IntExpr>(2),
+      std::move(loops));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(0), int64_t(2), int64_t(4), int64_t(6), int64_t(8),
+          int64_t(10), int64_t(12), int64_t(14), int64_t(16), int64_t(18),
+          int64_t(20)}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("simple list comprehension even", "[parser, list comprehension]") {
+  auto input = "[x for x in dummy_array if x % 2 == 0]"sv;
+  auto conditions = std::vector<ExprPtr>{};
+  conditions.emplace_back(make_expr_ptr<VariableExpr>("x") %
+                              make_expr_ptr<IntExpr>(2) ==
+                          make_expr_ptr<IntExpr>(0));
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>("x"),
+                     make_expr_ptr<VariableExpr>("dummy_array"),
+                     std::move(conditions));
+  const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>("x"), std::move(loops));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(2),
+                                                   int64_t(4), int64_t(6),
+                                                   int64_t(8), int64_t(10)}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("simple list comprehension expression and condition",
+          "[parser, list comprehension]") {
+  auto input = "[x * 2 for x in dummy_array if x <= 1]"sv;
+  auto conditions = std::vector<ExprPtr>{};
+  conditions.emplace_back(make_expr_ptr<VariableExpr>("x") <=
+                          make_expr_ptr<IntExpr>(1));
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>("x"),
+                     make_expr_ptr<VariableExpr>("dummy_array"),
+                     std::move(conditions));
+  const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>("x") * make_expr_ptr<IntExpr>(2),
+      std::move(loops));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(2)}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("list comprehension inline list", "[parser, list comprehension]") {
+  auto input = "[x for x in [0, 1]]"sv;
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>("x"),
+                     make_list_expr(make_expr_ptr<IntExpr>(int64_t(0)),
+                                    make_expr_ptr<IntExpr>(int64_t(1))),
+                     std::vector<ExprPtr>{});
+  const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>("x"), std::move(loops));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(1)}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("list comprehension if chains", "[parser, list comprehension]") {
+  auto input = "[x for x in [1, 2, 3] if x <= 2 if x >= 2]"sv;
+  auto conditions = std::vector<ExprPtr>{};
+  conditions.emplace_back(make_expr_ptr<VariableExpr>("x") <=
+                          make_expr_ptr<IntExpr>(2));
+  conditions.emplace_back(make_expr_ptr<VariableExpr>("x") >=
+                          make_expr_ptr<IntExpr>(2));
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>("x"),
+                     make_list_expr(make_expr_ptr<IntExpr>(int64_t(1)),
+                                    make_expr_ptr<IntExpr>(int64_t(2)),
+                                    make_expr_ptr<IntExpr>(int64_t(3))),
+                     std::move(conditions));
+  const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>("x"), std::move(loops));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(2)}};
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("Nested list comprehension", "[parser, list comprehension]") {
+  auto input = "[x for x in (y for y in [[1, 2], [3, 4]])]"sv;
+
+  auto loops_b = std::vector<ListComprehensionExpr::loop>{};
+  loops_b.emplace_back(
+      make_expr_ptr<VariableExpr>("y"),
+      make_list_expr(make_list_expr(make_expr_ptr<IntExpr>(int64_t(1)),
+                                    make_expr_ptr<IntExpr>(int64_t(2))),
+                     make_list_expr(make_expr_ptr<IntExpr>(int64_t(3)),
+                                    make_expr_ptr<IntExpr>(int64_t(4)))),
+      std::vector<ExprPtr>{});
+  auto loops_a = std::vector<ListComprehensionExpr::loop>{};
+  loops_a.emplace_back(
+      make_expr_ptr<VariableExpr>("x"),
+      make_expr_ptr<ListComprehensionExpr>(make_expr_ptr<VariableExpr>("y"),
+                                           std::move(loops_b)),
+      std::vector<ExprPtr>{});
+  const auto expected_ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>("x"), std::move(loops_a));
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2)},
+          std::vector<CuraFormulaeEngine::eval::Value>{int64_t(3),
+                                                       int64_t(4)}}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("Flatten list comprehension", "[parser, list comprehension]") {
+  auto input = "[item for row in matrix for item in row]"sv;
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2),
+                                                   int64_t(3), int64_t(4)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set(
+      "matrix",
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2)},
+          std::vector<CuraFormulaeEngine::eval::Value>{int64_t(3),
+                                                       int64_t(4)}});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("Flatten list comprehension condition",
+          "[parser, list comprehension]") {
+  auto input = "[item for row in matrix if len(row) >= 3 for item in row]"sv;
+
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2),
+                                                   int64_t(3), int64_t(6),
+                                                   int64_t(7), int64_t(8)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set(
+      "matrix",
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          std::vector<CuraFormulaeEngine::eval::Value>{int64_t(1), int64_t(2),
+                                                       int64_t(3)},
+          std::vector<CuraFormulaeEngine::eval::Value>{int64_t(4), int64_t(5)},
+          std::vector<CuraFormulaeEngine::eval::Value>{int64_t(6), int64_t(7),
+                                                       int64_t(8)}});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("Single quoted string", "[parser, string]") {
+  auto input = "'HELLO WORLD'"sv;
+  const auto expected_ast =
+      make_expr_ptr<StringExpr>(std::string("HELLO WORLD"));
+  const auto expected_eval =
+      CuraFormulaeEngine::eval::Value(std::string("HELLO WORLD"));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("Single quoted empty string", "[parser, string]") {
+  auto input = "''"sv;
+  const auto expected_ast = make_expr_ptr<StringExpr>(std::string(""));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(std::string(""));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("Double quoted string", "[parser, string]") {
+  auto input = "\"FOO BAR\""sv;
+  const auto expected_ast = make_expr_ptr<StringExpr>(std::string("FOO BAR"));
+  const auto expected_eval =
+      CuraFormulaeEngine::eval::Value(std::string("FOO BAR"));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("String with parenthesis", "[parser, string]") {
+  auto input = "\"Marlin (Volumetric)\""sv;
+  const auto expected_ast =
+      make_expr_ptr<StringExpr>(std::string("Marlin (Volumetric)"));
+  const auto expected_eval =
+      CuraFormulaeEngine::eval::Value(std::string("Marlin (Volumetric)"));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("Double quoted empty string", "[parser, string]") {
+  auto input = "\"\""sv;
+  const auto expected_ast = make_expr_ptr<StringExpr>(std::string(""));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(std::string(""));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn int", "[parser, fn]") {
+  auto input = "int(0.1)"sv;
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("int")(make_expr_ptr<FloatExpr>(0.1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn neg int", "[parser, fn]") {
+  auto input = "int(-0.1)"sv;
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("int")(-make_expr_ptr<FloatExpr>(0.1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn int str input", "[parser, fn]") {
+  auto input = "int(\"100\")"sv;
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("int")(make_expr_ptr<StringExpr>("100"));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(100));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn int str input base", "[parser, fn]") {
+  auto input = "int(\"100\", 2)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(std::string("int"))(
+      make_expr_ptr<StringExpr>("100"), make_expr_ptr<IntExpr>(int64_t(2)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(4));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn floor", "[parser, fn]") {
+  auto input = "math.floor(0.1)"sv;
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("math.floor")(make_expr_ptr<FloatExpr>(0.1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn ceil", "[parser, fn]") {
+  auto input = "math.ceil(0.1)"sv;
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("math.ceil")(make_expr_ptr<FloatExpr>(0.1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(1.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn math.log(1)", "[parser, fn]") {
+  auto input = "math.log(1)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("math.log")(
+      make_expr_ptr<IntExpr>(int64_t(1)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn math.log(1.0)", "[parser, fn]") {
+  auto input = "math.log(1.0)"sv;
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("math.log")(make_expr_ptr<FloatExpr>(1.0));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn math.log(4096, 8)", "[parser, fn]") {
+  auto input = "math.log(4096, 8)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("math.log")(
+      make_expr_ptr<IntExpr>(int64_t(4096)),
+      make_expr_ptr<IntExpr>(int64_t(8)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(4.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn math.log(True)", "[parser, fn]") {
+  auto input = "math.log(True)"sv;
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("math.log")(make_expr_ptr<BoolExpr>(true));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(0.0);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("condition True", "[parser, condition]") {
+  auto input = "1 if True else 0"sv;
+  const auto expected_ast = make_expr_ptr<ConditionExpr>(
+      make_expr_ptr<IntExpr>(1), make_expr_ptr<BoolExpr>(true),
+      make_expr_ptr<IntExpr>(0));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(1));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("condition False", "[parser, condition]") {
+  auto input = "1 if False else 0"sv;
+  const auto expected_ast = make_expr_ptr<ConditionExpr>(
+      make_expr_ptr<IntExpr>(1), make_expr_ptr<BoolExpr>(false),
+      make_expr_ptr<IntExpr>(0));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("nested condition 1", "[parser, condition]") {
+  auto input = "1 if False else 2 if False else 3"sv;
+  const auto expected_ast = make_expr_ptr<ConditionExpr>(
+      make_expr_ptr<IntExpr>(1), make_expr_ptr<BoolExpr>(false),
+      make_expr_ptr<ConditionExpr>(make_expr_ptr<IntExpr>(2),
+                                   make_expr_ptr<BoolExpr>(false),
+                                   make_expr_ptr<IntExpr>(3)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(3));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("nested condition 2", "[parser, condition]") {
+  auto input = "1 if False else 2 if False else 3 if False else 4"sv;
+  const auto expected_ast = make_expr_ptr<ConditionExpr>(
+      make_expr_ptr<IntExpr>(1), make_expr_ptr<BoolExpr>(false),
+      make_expr_ptr<ConditionExpr>(
+          make_expr_ptr<IntExpr>(2), make_expr_ptr<BoolExpr>(false),
+          make_expr_ptr<ConditionExpr>(make_expr_ptr<IntExpr>(3),
+                                       make_expr_ptr<BoolExpr>(false),
+                                       make_expr_ptr<IntExpr>(4))));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(4));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("index simple 0", "[parser, index]") {
+  auto input = "dummy_array[0]"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(
+      std::string("dummy_array"))[make_expr_ptr<IntExpr>(0)];
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("slice index out of bounds positive", "[parser, index]") {
+  auto input = "dummy_array[11]"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(
+      std::string("dummy_array"))[make_expr_ptr<IntExpr>(11)];
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE_FALSE(eval.has_value());
+  REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::IndexOutOfBounds);
+}
+
+TEST_CASE("slice index out of bounds negative", "[parser, index]") {
+  auto input = "dummy_array[-12]"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(
+      std::string("dummy_array"))[-make_expr_ptr<IntExpr>(12)];
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE_FALSE(eval.has_value());
+  REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::IndexOutOfBounds);
+}
+
+TEST_CASE("non integer index", "[parser, slice]") {
+  auto input = "dummy_array[0.1]"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(
+      std::string("dummy_array"))[make_expr_ptr<FloatExpr>(0.1)];
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE_FALSE(eval.has_value());
+  REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::TypeMismatch);
+}
+
+TEST_CASE("simple slice", "[parser, slice]") {
+  auto input = "dummy_array[0:10:1]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")),
+      make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(10),
+      make_expr_ptr<IntExpr>(1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+          int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+          int64_t(10)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("simple slice space", "[parser, slice]") {
+  auto input = "dummy_array[0 : 10 : 1]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")),
+      make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(10),
+      make_expr_ptr<IntExpr>(1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+          int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+          int64_t(10)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("simple slice syntax sugar", "[parser, slice]") {
+  auto input = "dummy_array[0:10]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")),
+      make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(10), std::nullopt);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+          int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+          int64_t(10)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("simple slice out of bound", "[parser, slice]") {
+  auto input = "dummy_array[0:11:1]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")),
+      make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(11),
+      make_expr_ptr<IntExpr>(1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+          int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+          int64_t(10)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("reverse slice", "[parser, slice]") {
+  auto input = "dummy_array[10:0:-1]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")),
+      make_expr_ptr<IntExpr>(10), make_expr_ptr<IntExpr>(0),
+      -make_expr_ptr<IntExpr>(1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(10), int64_t(9), int64_t(8), int64_t(7), int64_t(6),
+          int64_t(5), int64_t(4), int64_t(3), int64_t(2), int64_t(1),
+          int64_t(0)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("array slice step size 2", "[parser, slice]") {
+  auto input = "dummy_array[0:10:2]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")),
+      make_expr_ptr<IntExpr>(0), make_expr_ptr<IntExpr>(10),
+      make_expr_ptr<IntExpr>(2));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0), int64_t(2),
+                                                   int64_t(4), int64_t(6),
+                                                   int64_t(8), int64_t(10)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("slice empty value start/end index step size", "[parser, slice]") {
+  auto input = "dummy_array[::]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")), std::nullopt,
+      std::nullopt, std::nullopt);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+          int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+          int64_t(10)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("slice empty value start/end index negative step size",
+          "[parser, slice]") {
+  auto input = "dummy_array[::-1]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")), std::nullopt,
+      std::nullopt, -make_expr_ptr<IntExpr>(1));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(10), int64_t(9), int64_t(8), int64_t(7), int64_t(6),
+          int64_t(5), int64_t(4), int64_t(3), int64_t(2), int64_t(1),
+          int64_t(0)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("slice empty value start index, step size", "[parser, slice]") {
+  auto input = "dummy_array[:-2]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")), std::nullopt,
+      -make_expr_ptr<IntExpr>(2), std::nullopt);
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+          int64_t(5), int64_t(6), int64_t(7), int64_t(8)}};
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("non integer slice start index", "[parser, slice]") {
+  auto input = "dummy_array[0.1::]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")),
+      make_expr_ptr<FloatExpr>(0.1), std::nullopt, std::nullopt);
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE_FALSE(eval.has_value());
+  REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::TypeMismatch);
+}
+
+TEST_CASE("non integer slice end index", "[parser, slice]") {
+  auto input = "dummy_array[:0.1:]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")), std::nullopt,
+      make_expr_ptr<FloatExpr>(0.1), std::nullopt);
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE_FALSE(eval.has_value());
+  REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::TypeMismatch);
+}
+
+TEST_CASE("non integer slice step size", "[parser, slice]") {
+  auto input = "dummy_array[::0.1]"sv;
+  const auto expected_ast = make_expr_ptr<SliceExpr>(
+      make_expr_ptr<VariableExpr>(std::string("dummy_array")), std::nullopt,
+      std::nullopt, make_expr_ptr<FloatExpr>(0.1));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE_FALSE(eval.has_value());
+  REQUIRE(eval.error() == CuraFormulaeEngine::eval::Error::TypeMismatch);
+}
+
+TEST_CASE("index simple 10", "[parser, index]") {
+  auto input = "dummy_array[10]"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(
+      std::string("dummy_array"))[make_expr_ptr<IntExpr>(10)];
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(10));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("index last", "[parser, index]") {
+  auto input = "dummy_array[-1]"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(
+      std::string("dummy_array"))[-make_expr_ptr<IntExpr>(1)];
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(10));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("index last first", "[parser, index]") {
+  auto input = "dummy_array[-11]"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>(
+      std::string("dummy_array"))[-make_expr_ptr<IntExpr>(11)];
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(0));
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("index without index value", "[parser, index]") {
+  auto input = "dummy_array[]"sv;
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(!message.has_value());
+}
+
+TEST_CASE("fn any", "[parser, fn]") {
+  auto input = "any([True])"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("any")(
+      make_list_expr(make_expr_ptr<BoolExpr>(true)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("index function application", "[parser, index]") {
+  auto input = "map(abs, [1, -2, 3, -4])[0]"sv;
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(CuraFormulaeEngine::eval::Value(int64_t(1))));
+}
+
+TEST_CASE("double index", "[parser, index]") {
+  auto input = "dummy_array[0][0]"sv;
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set(
+      "dummy_array",
+      std::vector<CuraFormulaeEngine::eval::Value>{
+          CuraFormulaeEngine::eval::Value(
+              std::vector<CuraFormulaeEngine::eval::Value>{int64_t(0)})});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+}
+
+TEST_CASE("fn round", "[parser, fn]") {
+  auto input = "round(1.5)"sv;
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("round")(make_expr_ptr<FloatExpr>(1.5));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(2));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn round base=1", "[parser, fn]") {
+  auto input = "round(1.5, 1)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("round")(
+      make_expr_ptr<FloatExpr>(1.5), make_expr_ptr<IntExpr>(int64_t(1)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(1.5);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn round base=-1", "[parser, fn]") {
+  auto input = "round(15, -1)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("round")(
+      make_expr_ptr<IntExpr>(int64_t(15)), -make_expr_ptr<IntExpr>(int64_t(1)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(int64_t(20));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn round base=5", "[parser, fn]") {
+  auto input = "round(0.2*60/100, 5)"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("round")(
+      make_expr_ptr<FloatExpr>(0.2) * make_expr_ptr<IntExpr>(60) /
+          make_expr_ptr<IntExpr>(100),
+      make_expr_ptr<IntExpr>(int64_t(5)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(0.12);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn any trailing comma", "[parser, fn]") {
+  auto input = "any([True], )"sv;
+  const auto expected_ast = make_expr_ptr<VariableExpr>("any")(
+      make_list_expr(make_expr_ptr<BoolExpr>(true)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&CuraFormulaeEngine::env::std_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("fn list comprehension", "[parser, fn]") {
+  auto input = "all(x <= 10 for x in dummy_array)"sv;
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>("x"),
+                     make_expr_ptr<VariableExpr>("dummy_array"),
+                     std::vector<ExprPtr>{});
+  const auto expected_ast =
+      make_expr_ptr<VariableExpr>("all")(make_expr_ptr<ListComprehensionExpr>(
+          make_expr_ptr<VariableExpr>("x") <= make_expr_ptr<IntExpr>(10),
+          std::move(loops)));
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(true);
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("dummy_array",
+                 std::vector<CuraFormulaeEngine::eval::Value>{
+                     int64_t(0), int64_t(1), int64_t(2), int64_t(3), int64_t(4),
+                     int64_t(5), int64_t(6), int64_t(7), int64_t(8), int64_t(9),
+                     int64_t(10)});
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("parse endcode", "[parser, real example]") {
+  auto input =
+      "\";Version _2.6 of the firmware can abort the print too early if the file ends\\n;too soon. However if the file hasn't ended yet because there are comments at\\n;the end of the file, it won't abort yet. Therefore we have to put at least 512\\n;bytes at the end of the g-code so that the file is not yet finished by the\\n;time that the motion planner gets flushed. With firmware version _3.3 this\\n;should be fixed, so this comment wouldn't be necessary any more. Now we have\\n;to pad this text to make precisely 512 bytes.\"  if machine_gcode_flavor == \"UltiGCode\" else \"M104 S0 ;extruder heater off\\nM140 S0 ;heated bed heater off (if you have it)\\nG91 ;relative positioning\\nG1 E-1 F300  ;retract the filament a bit before lifting the nozzle, to release some of the pressure\\nG1 Z+0.5 E-5 X-20 Y-20 F9000 ;move Z up a bit and retract filament even more\\nG28 X0 Y0 ;move X/Y to min endstops, so the head is out of the way\\nM84 ;steppers off\\nG90 ;absolute positioning\\n;Version _2.6 of the firmware can abort the print too early if the file ends\\n;too soon. However if the file hasn't ended yet because there are comments at\\n;the end of the file, it won't abort yet. Therefore we have to put at least 512\\n;bytes at the end of the g-code so that the file is not yet finished by the\\n;time that the motion planner gets flushed. With firmware version _3.3 this\\n;should be fixed, so this comment wouldn't be necessary any more. Now we have\\n;to pad this text to make precisely 512 bytes.\""sv;
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+}
+
+TEST_CASE("simple var free variable", "[free variables, variable]") {
+  auto ast = make_expr_ptr<VariableExpr>(std::string("foo"));
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.size() == 1);
+  REQUIRE(free_variables.contains(std::string("foo")));
+}
+
+TEST_CASE("float has no free variable", "[free variables, float]") {
+  auto ast = make_expr_ptr<FloatExpr>(1.0);
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.empty());
+}
+
+TEST_CASE("int has no free variable", "[free variables, int]") {
+  auto ast = make_expr_ptr<IntExpr>(1);
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.empty());
+}
+
+TEST_CASE("string has no free variable", "[free variables, string]") {
+  auto ast = make_expr_ptr<StringExpr>(std::string("hello world"));
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.empty());
+}
+
+TEST_CASE("bool has no free variable", "[free variables, bool]") {
+  auto ast = make_expr_ptr<BoolExpr>(true);
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.empty());
+}
+
+TEST_CASE("free_variables(foo()) = { foo }", "[free variables, fn]") {
+  auto ast = make_expr_ptr<FnApplicationExpr>(
+      make_expr_ptr<VariableExpr>(std::string("foo")), std::vector<ExprPtr>{});
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.size() == 1);
+  REQUIRE(free_variables.contains(std::string("foo")));
+}
+
+TEST_CASE("free_variables(x^2) = { x }", "[free variables, x^2]") {
+  auto ast = make_expr_ptr<PowExpr>(
+      make_expr_ptr<VariableExpr>(std::string("x")), make_expr_ptr<IntExpr>(2));
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.size() == 1);
+  REQUIRE(free_variables.contains(std::string("x")));
+}
+
+TEST_CASE("free_variables([1, x, 2, y, 3]) = { x, y }",
+          "[free variables, list]") {
+  auto ast = make_list_expr(
+      make_expr_ptr<IntExpr>(1), make_expr_ptr<VariableExpr>(std::string("x")),
+      make_expr_ptr<IntExpr>(2), make_expr_ptr<VariableExpr>(std::string("y")),
+      make_expr_ptr<IntExpr>(3));
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.size() == 2);
+  REQUIRE(free_variables.contains(std::string("x")));
+  REQUIRE(free_variables.contains(std::string("y")));
+}
+
+TEST_CASE("free_variables([x for x in dummy_array]) = { dummy_array }",
+          "[free variables, list comprehension]") {
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>(std::string("x")),
+                     make_expr_ptr<VariableExpr>(std::string("dummy_array")),
+                     std::vector<ExprPtr>{});
+  auto ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>(std::string("x")), std::move(loops));
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.size() == 1);
+  REQUIRE(free_variables.contains(std::string("dummy_array")));
+}
+
+TEST_CASE("free_variables([x for x in x]) = { x }",
+          "[free variables, list comprehension]") {
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>(std::string("x")),
+                     make_expr_ptr<VariableExpr>(std::string("x")),
+                     std::vector<ExprPtr>{});
+  auto ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>(std::string("x")), std::move(loops));
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.size() == 1);
+  REQUIRE(free_variables.contains(std::string("x")));
+}
+
+TEST_CASE(
+    "free_variables([item for row in matrix for item in row]) = { matrix }",
+    "[free variables, list comprehension]") {
+  auto loops = std::vector<ListComprehensionExpr::loop>{};
+  loops.emplace_back(make_expr_ptr<VariableExpr>(std::string("row")),
+                     make_expr_ptr<VariableExpr>(std::string("matrix")),
+                     std::vector<ExprPtr>{});
+  loops.emplace_back(make_expr_ptr<VariableExpr>(std::string("item")),
+                     make_expr_ptr<VariableExpr>(std::string("row")),
+                     std::vector<ExprPtr>{});
+  auto ast = make_expr_ptr<ListComprehensionExpr>(
+      make_expr_ptr<VariableExpr>(std::string("item")), std::move(loops));
+  auto free_variables = ast.freeVariables();
+  REQUIRE(free_variables.size() == 1);
+  REQUIRE(free_variables.contains(std::string("matrix")));
+}
+
+TEST_CASE("real world expression", "[parser, fdm_printer.def.json example]") {
+  auto input =
+      "int(defaultExtruderPosition()) if resolveOrValue('adhesion_type') == 'raft' else -1"sv;
+
+  const auto expected_ast = make_expr_ptr<ConditionExpr>(
+      make_expr_ptr<VariableExpr>(std::string("int"))(
+          make_expr_ptr<VariableExpr>(
+              std::string("defaultExtruderPosition"))()),
+      make_expr_ptr<VariableExpr>(std::string("resolveOrValue"))(
+          make_expr_ptr<StringExpr>(std::string("adhesion_type"))) ==
+          make_expr_ptr<StringExpr>(std::string("raft")),
+      -make_expr_ptr<IntExpr>(int64_t(1)));
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+  REQUIRE(ast.deepEq(expected_ast));
+}
+
+TEST_CASE("prime tower parser", "[parser, fdm_printer.def.json example]") {
+  auto input =
+      "'none' if (extruders_enabled_count < 2) else ('interleaved' if (all(material_type_var == extruderValues('material_type')[0] for material_type_var in extruderValues('material_type')) and all(material_brand_var == extruderValues('material_brand')[0] for material_brand_var in extruderValues('material_brand'))) else 'normal')"sv;
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+}
+
+TEST_CASE("s8 bottom_thickness setting parser",
+          "[parser, fdm_printer.def.json example]") {
+  auto input =
+      "3*layer_height if top_layers==4 and not support_enable else top_bottom_thickness"sv;
+  const auto expected_eval = CuraFormulaeEngine::eval::Value(0.6018);
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("layer_height", 0.2006);
+  custom_env.set("top_layers", int64_t(4));
+  custom_env.set("support_enable", false);
+  custom_env.set("top_bottom_thickness", 0.8);
+
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
+}
+
+TEST_CASE("Falcon infill", "[parser, fdm_printer.def.json example]") {
+  auto input =
+      "[-40,50] if infill_pattern in ('grid', 'lines', 'zigzag')  else [ ]"sv;
+  const auto expected_eval = CuraFormulaeEngine::eval::Value{
+      std::vector<CuraFormulaeEngine::eval::Value>{int64_t(-40), int64_t(50)}};
+
+  const auto message = CuraFormulaeEngine::parser::parse(input);
+  REQUIRE(message.has_value());
+  const auto &ast = message.value();
+
+  CuraFormulaeEngine::env::LocalEnvironment custom_env{
+      &CuraFormulaeEngine::env::std_env};
+  custom_env.set("infill_pattern", std::string("grid"));
+
+  const auto eval = ast.evaluate(&custom_env);
+  REQUIRE(eval.has_value());
+  REQUIRE(eval.value().deepEq(expected_eval));
 }