diff --git a/package.json b/package.json
index 5ae0f3898..3c8028c56 100644
--- a/package.json
+++ b/package.json
@@ -81,7 +81,7 @@
   "devEngines": {
     "packageManager": {
       "name": "yarn",
-      "version": "^4.6.0",
+      "version": "^4.13.0",
       "onFail": "error"
     }
   },
diff --git a/src/__tests__/createContext.test.ts b/src/__tests__/createContext.test.ts
index 0e95ee052..148abbe71 100644
--- a/src/__tests__/createContext.test.ts
+++ b/src/__tests__/createContext.test.ts
@@ -30,4 +30,11 @@ describe('importing builtins', () => {
 
     expect(customDisplay).toHaveBeenCalledOnce();
   });
+
+  describe('check builtins being wrapped correctly', () => {
+    test('math_max and math_min', async () => {
+      await expectFinishedResult('math_max(1, 2, 3);').resolves.toEqual(3);
+      await expectFinishedResult('math_min(1, 2, 3);').resolves.toEqual(1);
+    });
+  });
 });
diff --git a/src/createContext.ts b/src/createContext.ts
index 3e8fb3133..eb583a4c8 100644
--- a/src/createContext.ts
+++ b/src/createContext.ts
@@ -201,7 +201,7 @@ export function defineBuiltin(
   context: Context,
   name: string,
   value: Value,
-  minArgsNeeded?: number,
+  optArgs?: number | true,
 ) {
   function extractName(name: string): string {
     return name.split('(')[0].trim();
@@ -223,12 +223,12 @@ export function defineBuiltin(
     const funName = extractName(name);
     const funParameters = extractParameters(name);
 
-    const wrapped = operators.wrap(
+    const wrapped = operators.wrapUnsafe(
       value,
-      minArgsNeeded,
+      optArgs,
+      funName,
       `function ${name} {\n\t[implementation hidden]\n}`,
       null,
-      funName,
     );
 
     // value.toString = () => repr;
@@ -289,16 +289,16 @@ export function importBuiltins(context: Context, externalBuiltIns: Partial<Custo
     (externalBuiltIns.alert ?? defaultBuiltIns.alert)(v, '', context.externalContext);
     context.nativeStorage.maxExecTime += Date.now() - start;
   };
-  const visualise_list = (...v: Value[]) => {
-    (externalBuiltIns.visualiseList ?? defaultBuiltIns.visualiseList)(v, context.externalContext);
-    return v[0];
+  const visualise_list = (v0: Value, ..._v: Value[]) => {
+    (externalBuiltIns.visualiseList ?? defaultBuiltIns.visualiseList)(v0, context.externalContext);
+    return v0;
   };
 
   if (context.chapter >= 1) {
     defineBuiltin(context, 'get_time()', misc.get_time);
     defineBuiltin(context, 'display(val, prepend = undefined)', display, 1);
     defineBuiltin(context, 'raw_display(str, prepend = undefined)', rawDisplay, 1);
-    defineBuiltin(context, 'stringify(val, indent = 2, maxLineLength = 80)', stringify, 1);
+    defineBuiltin(context, 'stringify(val, indent = 2, maxLineLength = 80)', stringify, 2);
     defineBuiltin(context, 'error(str, prepend = undefined)', misc.error_message, 1);
     defineBuiltin(context, 'prompt(str)', prompt);
     defineBuiltin(context, 'is_number(val)', misc.is_number);
@@ -319,15 +319,24 @@ export function importBuiltins(context: Context, externalBuiltIns: Partial<Custo
     for (const name of mathLibraryNames) {
       const value = Math[name as keyof typeof Math];
       if (typeof value === 'function') {
-        let paramString: string;
-        let minArgsNeeded = undefined;
-        if (name === 'max' || name === 'min') {
-          paramString = '...values';
-          minArgsNeeded = 0;
+        if (name === 'max') {
+          defineBuiltin(
+            context,
+            'math_max(...values)',
+            (...args: number[]) => Math.max(...args),
+            true,
+          );
+        } else if (name === 'min') {
+          defineBuiltin(
+            context,
+            'math_min(...values)',
+            (...args: number[]) => Math.min(...args),
+            true,
+          );
         } else {
-          paramString = parameterNames.slice(0, value.length).join(', ');
+          const paramString = parameterNames.slice(0, value.length).join(', ');
+          defineBuiltin(context, `math_${name}(${paramString})`, value);
         }
-        defineBuiltin(context, `math_${name}(${paramString})`, value, minArgsNeeded);
       } else {
         defineBuiltin(context, `math_${name}`, value);
       }
@@ -341,9 +350,9 @@ export function importBuiltins(context: Context, externalBuiltIns: Partial<Custo
     defineBuiltin(context, 'head(xs)', list.head);
     defineBuiltin(context, 'tail(xs)', list.tail);
     defineBuiltin(context, 'is_null(val)', list.is_null);
-    defineBuiltin(context, 'list(...values)', list.list, 0);
-    defineBuiltin(context, 'draw_data(...xs)', visualise_list, 1);
-    defineBuiltin(context, 'display_list(val, prepend = undefined)', display_list, 0);
+    defineBuiltin(context, 'list(...values)', list.list, true);
+    defineBuiltin(context, 'draw_data(x1, ...xs)', visualise_list, true);
+    defineBuiltin(context, 'display_list(val, prepend = undefined)', display_list, 1);
     defineBuiltin(context, 'is_list(val)', list.is_list);
   }
 
@@ -354,7 +363,7 @@ export function importBuiltins(context: Context, externalBuiltIns: Partial<Custo
     defineBuiltin(context, 'is_array(val)', misc.is_array);
 
     // Stream library
-    defineBuiltin(context, 'stream(...values)', stream.stream, 0);
+    defineBuiltin(context, 'stream(...values)', stream.stream, true);
   }
 
   if (context.chapter >= 4) {
diff --git a/src/cse-machine/__tests__/cse-machine-callcc-js.test.ts b/src/cse-machine/__tests__/cse-machine-callcc-js.test.ts
index d5017872d..76e0a9834 100644
--- a/src/cse-machine/__tests__/cse-machine-callcc-js.test.ts
+++ b/src/cse-machine/__tests__/cse-machine-callcc-js.test.ts
@@ -35,7 +35,7 @@ test('call_cc throws error when given no arguments', () => {
         1 + 2 + call_cc() + 4;
         `,
     optionEC4,
-  ).toEqual('Line 1: Expected 1 arguments, but got 0.');
+  ).toEqual('Line 1: call_cc: Expected 1 arguments, but got 0.');
 });
 
 test('call_cc throws error when given > 1 arguments', () => {
@@ -45,7 +45,7 @@ test('call_cc throws error when given > 1 arguments', () => {
         1 + 2 + call_cc(f,f) + 4;
         `,
     optionEC4,
-  ).toEqual('Line 2: Expected 1 arguments, but got 2.');
+  ).toEqual('Line 2: call_cc: Expected 1 arguments, but got 2.');
 });
 
 test('continuations can be stored as a value', async ({ expect }) => {
diff --git a/src/cse-machine/__tests__/cse-machine-errors.test.ts b/src/cse-machine/__tests__/cse-machine-errors.test.ts
index b20d3b062..d91b25813 100644
--- a/src/cse-machine/__tests__/cse-machine-errors.test.ts
+++ b/src/cse-machine/__tests__/cse-machine-errors.test.ts
@@ -477,7 +477,7 @@ test('Error when calling function with too few arguments', () => {
     f();
   `,
     optionEC,
-  ).toEqual('Line 4: Expected 1 arguments, but got 0.');
+  ).toEqual('Line 4: f: Expected 1 arguments, but got 0.');
 });
 
 test('Error when calling function with too few arguments - verbose', async ({ expect }) => {
@@ -493,8 +493,8 @@ test('Error when calling function with too few arguments - verbose', async ({ ex
   );
 
   expect(errStr).toMatchInlineSnapshot(`
-            "Line 5, Column 2: Expected 1 arguments, but got 0.
-            Try calling function f again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
+            "Line 5, Column 2: f: Expected 1 arguments, but got 0.
+            Try calling f again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
             "
           `);
 });
@@ -508,7 +508,7 @@ test('Error when calling function with too many arguments', () => {
     f(1, 2);
   `,
     optionEC,
-  ).toEqual('Line 4: Expected 1 arguments, but got 2.');
+  ).toEqual('Line 4: f: Expected 1 arguments, but got 2.');
 });
 
 test('Error when calling function with too many arguments - verbose', async ({ expect }) => {
@@ -524,8 +524,8 @@ test('Error when calling function with too many arguments - verbose', async ({ e
   );
 
   expect(errStr).toMatchInlineSnapshot(`
-            "Line 5, Column 2: Expected 1 arguments, but got 2.
-            Try calling function f again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
+            "Line 5, Column 2: f: Expected 1 arguments, but got 2.
+            Try calling f again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
             "
           `);
 });
@@ -537,7 +537,7 @@ test('Error when calling arrow function with too few arguments', () => {
     f();
   `,
     optionEC,
-  ).toEqual('Line 2: Expected 1 arguments, but got 0.');
+  ).toEqual('Line 2: f: Expected 1 arguments, but got 0.');
 });
 
 test('Error when calling arrow function with too few arguments - verbose', async ({ expect }) => {
@@ -550,8 +550,8 @@ test('Error when calling arrow function with too few arguments - verbose', async
     optionEC,
   );
   expect(errStr).toMatchInlineSnapshot(`
-            "Line 3, Column 2: Expected 1 arguments, but got 0.
-            Try calling function f again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
+            "Line 3, Column 2: f: Expected 1 arguments, but got 0.
+            Try calling f again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
             "
           `);
 });
@@ -563,7 +563,7 @@ test('Error when calling arrow function with too many arguments', () => {
     f(1, 2);
   `,
     optionEC,
-  ).toEqual('Line 2: Expected 1 arguments, but got 2.');
+  ).toEqual('Line 2: f: Expected 1 arguments, but got 2.');
 });
 
 test('Error when calling arrow function with too many arguments - verbose', async ({ expect }) => {
@@ -576,8 +576,8 @@ test('Error when calling arrow function with too many arguments - verbose', asyn
     optionEC,
   );
   expect(errStr).toMatchInlineSnapshot(`
-            "Line 3, Column 2: Expected 1 arguments, but got 2.
-            Try calling function f again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
+            "Line 3, Column 2: f: Expected 1 arguments, but got 2.
+            Try calling f again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
             "
           `);
 });
@@ -605,7 +605,7 @@ test('Error when calling function from member expression with too many arguments
   );
   expect(errStr).toMatchInlineSnapshot(`
             "Line 3, Column 2: Expected 1 arguments, but got 2.
-            Try calling function f[0] again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
+            Try calling the function again, but with 1 argument instead. Remember that arguments are separated by a ',' (comma).
             "
           `);
 });
@@ -621,8 +621,8 @@ test('Error when calling arrow function in tail call with too many arguments - v
     optionEC,
   );
   expect(errStr).toMatchInlineSnapshot(`
-            "Line 3, Column 15: Expected 0 arguments, but got 1.
-            Try calling function g again, but with 0 arguments instead. Remember that arguments are separated by a ',' (comma).
+            "Line 3, Column 15: g: Expected 0 arguments, but got 1.
+            Try calling g again without arguments.
             "
           `);
 });
@@ -635,7 +635,7 @@ test('Error when calling arrow function in tail call with too many arguments', (
     f(1);
   `,
     optionEC,
-  ).toEqual('Line 2: Expected 0 arguments, but got 1.');
+  ).toEqual('Line 2: g: Expected 0 arguments, but got 1.');
 });
 
 test('Error when calling builtin function in with too many arguments', () => {
@@ -743,7 +743,7 @@ test('Error with too few arguments passed to rest parameters', () => {
     rest(1);
   `,
     optionEC3,
-  ).toEqual('Line 2: Expected 2 or more arguments, but got 1.');
+  ).toEqual('Line 2: rest: Expected 2 or more arguments, but got 1.');
 });
 
 test('Error when redeclaring constant', () => {
diff --git a/src/cse-machine/__tests__/cse-machine-runtime-context.test.ts b/src/cse-machine/__tests__/cse-machine-runtime-context.test.ts
index 90a943bed..ec74d4d07 100644
--- a/src/cse-machine/__tests__/cse-machine-runtime-context.test.ts
+++ b/src/cse-machine/__tests__/cse-machine-runtime-context.test.ts
@@ -4,7 +4,7 @@ import type { IOptions } from '../..';
 import { Chapter } from '../../langs';
 import { parse } from '../../parser/parser';
 import { runCodeInSource } from '../../runner';
-import type { RecursivePartial } from '../../types';
+import type { RecursivePartial } from '../../utils/typeUtils';
 import { stripIndent } from '../../utils/formatters';
 import { mockContext } from '../../utils/testing/mocks';
 import { Control, Stash, generateCSEMachineStateStream } from '../interpreter';
diff --git a/src/cse-machine/utils.ts b/src/cse-machine/utils.ts
index 0ea3355ba..51fc8f1a5 100644
--- a/src/cse-machine/utils.ts
+++ b/src/cse-machine/utils.ts
@@ -15,6 +15,7 @@ import * as ast from '../utils/ast/astCreator';
 import { isIdentifier, isImportDeclaration, isVariableDeclaration } from '../utils/ast/typeGuards';
 import assert from '../utils/assert';
 import { extractDeclarations } from '../utils/ast/helpers';
+import { validateFunctionArgCount } from '../utils/operators';
 import Closure from './closure';
 import { Continuation, isCallWithCurrentContinuation } from './continuations';
 import Heap from './heap';
@@ -499,26 +500,28 @@ export const checkNumberOfArguments = (
   if (callee instanceof Closure) {
     // User-defined or Pre-defined functions
     const params = callee.node.params;
-    const hasVarArgs = params[params.length - 1]?.type === 'RestElement';
-    if (hasVarArgs ? params.length - 1 > args.length : params.length !== args.length) {
-      return handleRuntimeError(
-        context,
-        new errors.InvalidNumberOfArgumentsError(
-          exp,
-          hasVarArgs ? params.length - 1 : params.length,
-          args.length,
-          undefined,
-          hasVarArgs,
-        ),
+    const hasRest = params[params.length - 1]?.type === 'RestElement';
+    const minArgs = params.filter(
+      each => each.type !== 'AssignmentPattern' && each.type !== 'RestElement',
+    ).length;
+
+    try {
+      validateFunctionArgCount(
+        exp,
+        args.length,
+        minArgs,
+        hasRest || params.length,
+        callee.declaredName,
       );
+    } catch (error) {
+      return handleRuntimeError(context, error);
     }
   } else if (isCallWithCurrentContinuation(callee)) {
     // call/cc should have a single argument
-    if (args.length !== 1) {
-      return handleRuntimeError(
-        context,
-        new errors.InvalidNumberOfArgumentsError(exp, 1, args.length, undefined, false),
-      );
+    try {
+      validateFunctionArgCount(exp, args.length, 1, undefined, 'call_cc');
+    } catch (error) {
+      return handleRuntimeError(context, error);
     }
     return undefined;
   } else if (callee instanceof Continuation) {
@@ -527,22 +530,8 @@ export const checkNumberOfArguments = (
     // TODO: in future, if we can somehow check the number of arguments
     // expected by the continuation, we can add a check here.
     return undefined;
-  } else {
-    // Pre-built functions
-    const hasVarArgs = callee.minArgsNeeded != null;
-    if (hasVarArgs ? callee.minArgsNeeded > args.length : callee.length !== args.length) {
-      return handleRuntimeError(
-        context,
-        new errors.InvalidNumberOfArgumentsError(
-          exp,
-          hasVarArgs ? callee.minArgsNeeded : callee.length,
-          args.length,
-          undefined,
-          hasVarArgs,
-        ),
-      );
-    }
   }
+  // No need to check args for builtins, checking is done by callIfFuncAndRightArgs
   return undefined;
 };
 
diff --git a/src/errors/__tests__/rttcErrors.test.ts b/src/errors/__tests__/rttcErrors.test.ts
index 9c4cec567..8e6fa9ed4 100644
--- a/src/errors/__tests__/rttcErrors.test.ts
+++ b/src/errors/__tests__/rttcErrors.test.ts
@@ -37,17 +37,17 @@ describe(errors.InvalidNumberParameterError, () => {
       { max: 2, min: 0, integer: true },
       'foo',
     );
-    expect(error.explain()).toEqual('foo: Expected integer between 0 and 2, got -1.');
+    expect(error.explain()).toEqual('foo: Expected integer ∈ [0, 2], got -1.');
   });
 
   test('integer with only maximum', () => {
     const error = new errors.InvalidNumberParameterError(3, { max: 2 }, 'foo');
-    expect(error.explain()).toEqual('foo: Expected integer less than 2, got 3.');
+    expect(error.explain()).toEqual('foo: Expected integer ≤ 2, got 3.');
   });
 
   test('integer with only minimum', () => {
     const error = new errors.InvalidNumberParameterError(1, { min: 2 }, 'foo');
-    expect(error.explain()).toEqual('foo: Expected integer greater than 2, got 1.');
+    expect(error.explain()).toEqual('foo: Expected integer ≥ 2, got 1.');
   });
 
   test('integer with neither minimum nor maximum', () => {
@@ -61,17 +61,17 @@ describe(errors.InvalidNumberParameterError, () => {
       { max: 2, min: 0, integer: false },
       'foo',
     );
-    expect(error.explain()).toEqual('foo: Expected number between 0 and 2, got -1.');
+    expect(error.explain()).toEqual('foo: Expected number ∈ [0, 2], got -1.');
   });
 
   test('non-integer with only maximum', () => {
     const error = new errors.InvalidNumberParameterError(3, { max: 2, integer: false }, 'foo');
-    expect(error.explain()).toEqual('foo: Expected number less than 2, got 3.');
+    expect(error.explain()).toEqual('foo: Expected number ≤ 2, got 3.');
   });
 
   test('non-integer with only minimum', () => {
     const error = new errors.InvalidNumberParameterError(1, { min: 2, integer: false }, 'foo');
-    expect(error.explain()).toEqual('foo: Expected number greater than 2, got 1.');
+    expect(error.explain()).toEqual('foo: Expected number ≥ 2, got 1.');
   });
 
   test('non-integer with neither minimum nor maximum', () => {
diff --git a/src/errors/errors.ts b/src/errors/errors.ts
index 5357ee9cf..049488572 100644
--- a/src/errors/errors.ts
+++ b/src/errors/errors.ts
@@ -178,32 +178,66 @@ export class UnassignedVariableError extends RuntimeSourceError<Node> {
  * Error thrown when a function is called with the incorrect number of arguments. Usually thrown by
  * `callIfRightFuncAndArgs`
  */
-export class InvalidNumberOfArgumentsError extends RuntimeSourceError<es.CallExpression> {
-  private readonly calleeStr: string;
+abstract class InvalidNumberOfArgumentsError extends RuntimeSourceError<es.CallExpression> {
+  protected readonly calleeStr: string;
 
   constructor(
     node: es.CallExpression,
-    private readonly expected: number,
-    private readonly got: number,
-    private readonly funcName?: string,
-    private readonly hasVarArgs = false,
+    /**
+     * Number of arguments the function was called with
+     */
+    protected readonly received: number,
+    /**
+     * Number of arguments (either minimum or maximum) the function
+     * was expecting
+     */
+    protected readonly requirement: number,
+    /**
+     * Set this to true if the function can take in varying numbers of arguments (including both
+     * rest arguments and default arguments)
+     */
+    protected readonly isVarArgs: boolean,
+    /**
+     * Name of the function
+     */
+    protected readonly funcName?: string,
   ) {
     super(node);
-    this.calleeStr = generate(node.callee);
+    this.calleeStr = node.callee.type === 'Identifier' ? node.callee.name : 'the function';
+  }
+
+  public override elaborate() {
+    const pluralS = this.requirement === 1 ? '' : 's';
+
+    return `Try calling ${this.calleeStr} again, but with ${this.requirement} argument${pluralS} instead. Remember that arguments are separated by a ',' (comma).`;
   }
+}
 
+/**
+ * Error thrown by {@link callIfFuncAndRightArgs} when a function is called with too few arguments.
+ */
+export class TooFewArgumentsError extends InvalidNumberOfArgumentsError {
   public override explain() {
     const funcStr = this.funcName !== undefined ? `${this.funcName}: ` : '';
-    return `${funcStr}Expected ${this.expected} ${this.hasVarArgs ? 'or more ' : ''}arguments, but got ${
-      this.got
-    }.`;
+    return `${funcStr}Expected ${this.requirement} ${this.isVarArgs ? 'or more ' : ''}arguments, but got ${this.received}.`;
   }
+}
 
-  public override elaborate() {
-    const calleeStr = this.calleeStr;
-    const pluralS = this.expected === 1 ? '' : 's';
+/**
+ * Error thrown by {@link callIfFuncAndRightArgs} when a function is called with too many arguments.
+ */
+export class TooManyArgumentsError extends InvalidNumberOfArgumentsError {
+  public override explain() {
+    const funcStr = this.funcName !== undefined ? `${this.funcName}: ` : '';
+    return `${funcStr}Expected ${this.requirement} ${this.isVarArgs ? 'or fewer ' : ''}arguments, but got ${this.received}.`;
+  }
+
+  public override elaborate(): string {
+    if (this.requirement === 0) {
+      return `Try calling ${this.calleeStr} again without arguments.`;
+    }
 
-    return `Try calling function ${calleeStr} again, but with ${this.expected} argument${pluralS} instead. Remember that arguments are separated by a ',' (comma).`;
+    return super.elaborate();
   }
 }
 
diff --git a/src/errors/rttcErrors.ts b/src/errors/rttcErrors.ts
index 37e754455..6a5f6f2d5 100644
--- a/src/errors/rttcErrors.ts
+++ b/src/errors/rttcErrors.ts
@@ -118,12 +118,9 @@ export class InvalidNumberParameterError extends InvalidParameterTypeError {
       const typeStr = integer ? 'integer' : 'number';
 
       if (max !== undefined) {
-        expectedStr =
-          min === undefined
-            ? `${typeStr} less than ${max}`
-            : `${typeStr} between ${min} and ${max}`;
+        expectedStr = min === undefined ? `${typeStr} ≤ ${max}` : `${typeStr} ∈ [${min}, ${max}]`;
       } else {
-        expectedStr = min === undefined ? typeStr : `${typeStr} greater than ${min}`;
+        expectedStr = min === undefined ? typeStr : `${typeStr} ≥ ${min}`;
       }
     }
 
diff --git a/src/index.ts b/src/index.ts
index e632fa3a2..189a4b110 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -12,11 +12,11 @@ import type {
   Context,
   ExecutionMethod,
   Finished,
-  RecursivePartial,
   Result,
   Error as ResultError,
   SVMProgram,
 } from './types';
+import type { RecursivePartial } from './utils/typeUtils';
 import type { ModuleContext, ImportOptions } from './modules/moduleTypes';
 import { assemble } from './vm/svml-assembler';
 import { compileToIns } from './vm/svml-compiler';
@@ -74,6 +74,11 @@ export function parseError(errors: SourceError[], verbose: boolean = verboseErro
     const filePath = error.location?.source ? `[${error.location.source}] ` : '';
     const line = error.location?.start?.line ?? -1;
     const column = error.location?.start?.column ?? -1;
+
+    if (!error.explain) {
+      console.error('Unhandled error', error);
+    }
+
     const explanation = error.explain();
 
     if (verbose) {
diff --git a/src/langs.ts b/src/langs.ts
index 0ee4620e5..338d53fbc 100644
--- a/src/langs.ts
+++ b/src/langs.ts
@@ -11,6 +11,8 @@ export enum Chapter {
   LIBRARY_PARSER = 100,
 }
 
+export type ChapterStrings = keyof typeof Chapter;
+
 export enum Variant {
   DEFAULT = 'default',
   TYPED = 'typed',
diff --git a/src/modules/loader/__mocks__/loaders.ts b/src/modules/loader/__mocks__/loaders.ts
index d92b1b46f..b0042a4e8 100644
--- a/src/modules/loader/__mocks__/loaders.ts
+++ b/src/modules/loader/__mocks__/loaders.ts
@@ -9,7 +9,13 @@ export const memoizedLoadModuleDocsAsync = vi.fn((module: string) => {
   const barDocs: FunctionDocumentation = {
     kind: 'function',
     retType: 'void',
-    params: [['a', 'number']],
+    params: [
+      {
+        name: 'a',
+        paramType: 'regular',
+        type: 'number',
+      },
+    ],
     description: 'bar',
   };
 
diff --git a/src/modules/loader/__tests__/loader.test.ts b/src/modules/loader/__tests__/loader.test.ts
index e2348f676..09b6895ac 100644
--- a/src/modules/loader/__tests__/loader.test.ts
+++ b/src/modules/loader/__tests__/loader.test.ts
@@ -243,7 +243,7 @@ describe('module loading', () => {
         },
         context,
       ),
-    ).rejects.toThrowError(WrongChapterForModuleError);
+    ).rejects.toThrow(WrongChapterForModuleError);
     expect(moduleMocker).not.toHaveBeenCalledOnce();
   });
 
diff --git a/src/modules/loader/loaders.ts b/src/modules/loader/loaders.ts
index c54bd41d9..46a42ebea 100644
--- a/src/modules/loader/loaders.ts
+++ b/src/modules/loader/loaders.ts
@@ -1,6 +1,6 @@
 import mapValues from 'lodash/mapValues';
 import type { Context } from '../../types';
-import { wrap } from '../../utils/operators';
+import { wrapUnsafe } from '../../utils/operators';
 import { ModuleConnectionError, ModuleInternalError } from '../errors';
 import type {
   ModuleDocumentation,
@@ -145,12 +145,12 @@ export async function loadModuleBundleAsync(
       if (typeof value !== 'function') return value;
 
       const name = value.name;
-      return wrap(
+      return wrapUnsafe(
         value as (...args: any[]) => any,
-        false,
+        undefined,
+        name ?? key, // Ensure that names are provided if forgotten
         `function ${name} {\n\t[Function from ${moduleName}\n\tImplementation hidden]\n}`,
         moduleName,
-        name ?? key, // Ensure that names are provided if forgotten
       );
     });
   } catch (error) {
diff --git a/src/modules/loader/requireProvider.ts b/src/modules/loader/requireProvider.ts
index 283b272fc..8f472c152 100644
--- a/src/modules/loader/requireProvider.ts
+++ b/src/modules/loader/requireProvider.ts
@@ -7,6 +7,7 @@ import type { Context, Node } from '../../types';
 import * as types from '../../types';
 import * as assert from '../../utils/assert';
 import * as stringify from '../../utils/stringify';
+import * as operators from '../../utils/operators';
 import * as errorBase from '../../errors/base';
 import * as rttcErrors from '../../errors/rttcErrors';
 import * as rttc from '../../utils/rttc';
@@ -39,8 +40,9 @@ export function getRequireProvider(context: Context) {
         types,
         utils: {
           assert,
-          stringify,
+          operators,
           rttc,
+          stringify,
         },
       },
       context,
diff --git a/src/modules/moduleTypes.ts b/src/modules/moduleTypes.ts
index 999f2cde6..4e6c384af 100644
--- a/src/modules/moduleTypes.ts
+++ b/src/modules/moduleTypes.ts
@@ -4,6 +4,9 @@ import type { RequireProvider } from './loader/requireProvider';
 import type { ImportAnalysisOptions } from './preprocessor/analyzer';
 import type { LinkerOptions } from './preprocessor/linker';
 
+/**
+ * Represents a {@link es.Node|Node} that refers to an import "source".
+ */
 export type ModuleDeclarationWithSource =
   | es.ImportDeclaration
   | es.ExportNamedDeclaration
@@ -34,19 +37,56 @@ export type LoadedBundle = {
   [name: string]: unknown;
 };
 
+type ParamType = 'regular' | 'optional' | 'rest';
+
+interface BaseParam<T extends ParamType> {
+  paramType: T;
+  name: string;
+  type: string;
+}
+
+/**
+ * Represents a rest parameter
+ */
+export type RestParam = BaseParam<'rest'>;
+
+/**
+ * Represents an optional parameter, i.e `x1?: number`.
+ */
+export type OptionalParam = BaseParam<'optional'>;
+
+/**
+ * Represents a regular parameter
+ */
+export interface RegularParam extends BaseParam<'regular'> {
+  defaultValue?: string;
+}
+
+export type ParamSpecifier = RegularParam | RestParam | OptionalParam;
+
+/**
+ * Represents a doc entry documenting a function
+ */
 export interface FunctionDocumentation {
   kind: 'function';
   retType: string;
   description: string;
-  params: [name: string, type: string][];
+  params: ParamSpecifier[];
 }
 
+/**
+ * Represents a doc entry documenting a variable
+ */
 export interface VariableDocumentation {
   kind: 'variable';
   type: string;
   description: string;
 }
 
+/**
+ * Represents a doc entry for something that isn't
+ * a variable or function.
+ */
 export interface UnknownDocumentation {
   kind: 'unknown';
 }
diff --git a/src/modules/preprocessor/__tests__/directedGraph.test.ts b/src/modules/preprocessor/__tests__/directedGraph.test.ts
index 174803570..977476711 100644
--- a/src/modules/preprocessor/__tests__/directedGraph.test.ts
+++ b/src/modules/preprocessor/__tests__/directedGraph.test.ts
@@ -4,7 +4,7 @@ import { DirectedGraph } from '../directedGraph';
 describe('addEdge', () => {
   it('throws an error if the source and destination nodes are the same', () => {
     const graph = new DirectedGraph();
-    expect(() => graph.addEdge('A', 'A')).toThrowError(
+    expect(() => graph.addEdge('A', 'A')).toThrow(
       'Edges that connect a node to itself are not allowed.',
     );
   });
diff --git a/src/modules/preprocessor/__tests__/preprocessor.test.ts b/src/modules/preprocessor/__tests__/preprocessor.test.ts
index 4268aa2dd..7acaffbce 100644
--- a/src/modules/preprocessor/__tests__/preprocessor.test.ts
+++ b/src/modules/preprocessor/__tests__/preprocessor.test.ts
@@ -9,7 +9,7 @@ import {
   accessExportFunctionName,
   defaultExportLookupName,
 } from '../../../stdlib/localImport.prelude';
-import type { RecursivePartial } from '../../../types';
+import type { RecursivePartial } from '../../../utils/typeUtils';
 import { mockContext } from '../../../utils/testing/mocks';
 import { sanitizeAST } from '../../../utils/testing/sanitizer';
 import { UndefinedImportError } from '../../errors';
diff --git a/src/modules/preprocessor/index.ts b/src/modules/preprocessor/index.ts
index db0d36ae4..442674a63 100644
--- a/src/modules/preprocessor/index.ts
+++ b/src/modules/preprocessor/index.ts
@@ -3,7 +3,8 @@ import type es from 'estree';
 
 import type { IOptions } from '../..';
 import { Variant } from '../../langs';
-import type { Context, RecursivePartial } from '../../types';
+import type { Context } from '../../types';
+import type { RecursivePartial } from '../../utils/typeUtils';
 import loadSourceModules, { loadSourceModuleTypes } from '../loader';
 import type { FileGetter } from '../moduleTypes';
 import analyzeImportsAndExports from './analyzer';
diff --git a/src/modules/preprocessor/linker.ts b/src/modules/preprocessor/linker.ts
index bb03619ea..e447e54ab 100644
--- a/src/modules/preprocessor/linker.ts
+++ b/src/modules/preprocessor/linker.ts
@@ -2,7 +2,8 @@ import type es from 'estree';
 
 import { parse } from '../../parser/parser';
 import { parseAt } from '../../parser/utils';
-import type { Context, RecursivePartial } from '../../types';
+import type { Context } from '../../types';
+import type { RecursivePartial } from '../../utils/typeUtils';
 import { getModuleDeclarationSource } from '../../utils/ast/helpers';
 import { isDirective } from '../../utils/ast/typeGuards';
 import { mapAndFilter } from '../../utils/misc';
diff --git a/src/modules/utils.ts b/src/modules/utils.ts
index daaeacb84..a9f28b034 100644
--- a/src/modules/utils.ts
+++ b/src/modules/utils.ts
@@ -1,6 +1,6 @@
 import * as _ from 'lodash';
 
-import type { RecursivePartial } from '../types';
+import type { RecursivePartial } from '../utils/typeUtils';
 import type { ModuleContext, ImportOptions } from './moduleTypes';
 import { defaultAnalysisOptions } from './preprocessor/analyzer';
 
diff --git a/src/name-extractor/__tests__/docsToHtml.test.ts b/src/name-extractor/__tests__/docsToHtml.test.ts
new file mode 100644
index 000000000..b247ae87e
--- /dev/null
+++ b/src/name-extractor/__tests__/docsToHtml.test.ts
@@ -0,0 +1,165 @@
+import { describe, expect, it } from 'vitest';
+import { docsToHtml } from '..';
+import type { FunctionDocumentation } from '../../modules/moduleTypes';
+import { importSpecifier } from '../../utils/ast/astCreator';
+
+describe(docsToHtml, () => {
+  const dummySpec = importSpecifier('f', 'f');
+
+  it('works for functions with no parameters', () => {
+    const testDocs: FunctionDocumentation = {
+      kind: 'function',
+      retType: 'string',
+      description: 'A description',
+      params: [],
+    };
+
+    expect(docsToHtml(dummySpec, testDocs)).toMatchInlineSnapshot(
+      `"<div><h4>f() → {string}</h4><div class=\\"description\\">A description</div></div>"`,
+    );
+  });
+
+  it('works for functions with 1 parameter', () => {
+    const testDocs: FunctionDocumentation = {
+      kind: 'function',
+      retType: 'string',
+      description: 'A description',
+      params: [
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param0',
+        },
+      ],
+    };
+
+    expect(docsToHtml(dummySpec, testDocs)).toMatchInlineSnapshot(
+      `"<div><h4>f(param0: number) → {string}</h4><div class=\\"description\\">A description</div></div>"`,
+    );
+  });
+
+  it('works for functions with 2 parameters', () => {
+    const testDocs: FunctionDocumentation = {
+      kind: 'function',
+      retType: 'string',
+      description: 'A description',
+      params: [
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param0',
+        },
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param1',
+        },
+      ],
+    };
+
+    expect(docsToHtml(dummySpec, testDocs)).toMatchInlineSnapshot(
+      `"<div><h4>f(param0: number, param1: number) → {string}</h4><div class=\\"description\\">A description</div></div>"`,
+    );
+  });
+
+  it('works for functions with 1 default parameter', () => {
+    const testDocs: FunctionDocumentation = {
+      kind: 'function',
+      retType: 'string',
+      description: 'A description',
+      params: [
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param0',
+        },
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param1',
+          defaultValue: '0',
+        },
+      ],
+    };
+
+    expect(docsToHtml(dummySpec, testDocs)).toMatchInlineSnapshot(
+      `"<div><h4>f(param0: number, param1: number = 0) → {string}</h4><div class=\\"description\\">A description</div></div>"`,
+    );
+  });
+
+  it('works for functions with 2 default parameters', () => {
+    const testDocs: FunctionDocumentation = {
+      kind: 'function',
+      retType: 'string',
+      description: 'A description',
+      params: [
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param0',
+          defaultValue: '0',
+        },
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param1',
+          defaultValue: '1',
+        },
+      ],
+    };
+
+    expect(docsToHtml(dummySpec, testDocs)).toMatchInlineSnapshot(
+      `"<div><h4>f(param0: number = 0, param1: number = 1) → {string}</h4><div class=\\"description\\">A description</div></div>"`,
+    );
+  });
+
+  it('works for functions with optional parameter', () => {
+    const testDocs: FunctionDocumentation = {
+      kind: 'function',
+      retType: 'string',
+      description: 'A description',
+      params: [
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param0',
+          defaultValue: '0',
+        },
+        {
+          paramType: 'optional',
+          type: 'number',
+          name: 'param1',
+        },
+      ],
+    };
+
+    expect(docsToHtml(dummySpec, testDocs)).toMatchInlineSnapshot(
+      `"<div><h4>f(param0: number = 0, param1?: number) → {string}</h4><div class=\\"description\\">A description</div></div>"`,
+    );
+  });
+
+  it('works for functions with rest parameter', () => {
+    const testDocs: FunctionDocumentation = {
+      kind: 'function',
+      retType: 'string',
+      description: 'A description',
+      params: [
+        {
+          paramType: 'regular',
+          type: 'number',
+          name: 'param0',
+          defaultValue: '0',
+        },
+        {
+          paramType: 'rest',
+          type: 'number',
+          name: 'param1',
+        },
+      ],
+    };
+
+    expect(docsToHtml(dummySpec, testDocs)).toMatchInlineSnapshot(
+      `"<div><h4>f(param0: number = 0, ...param1: number) → {string}</h4><div class=\\"description\\">A description</div></div>"`,
+    );
+  });
+});
diff --git a/src/name-extractor/__tests__/modules.test.ts b/src/name-extractor/__tests__/modules.test.ts
index 71d6532d0..b486d4d90 100644
--- a/src/name-extractor/__tests__/modules.test.ts
+++ b/src/name-extractor/__tests__/modules.test.ts
@@ -171,6 +171,7 @@ describe('test name extractor functionality on imports', () => {
   const mockImportDecl: ImportDeclaration = {
     type: 'ImportDeclaration',
     specifiers: [],
+    attributes: [],
     source: {
       type: 'Literal',
       value: 'nothing',
diff --git a/src/name-extractor/index.ts b/src/name-extractor/index.ts
index 6667de77a..f5acd2269 100644
--- a/src/name-extractor/index.ts
+++ b/src/name-extractor/index.ts
@@ -321,7 +321,7 @@ function cursorInIdentifier(node: Node, locTest: (node: Node) => boolean): boole
   }
 }
 
-function docsToHtml(
+export function docsToHtml(
   spec: es.ImportSpecifier | es.ImportDefaultSpecifier,
   obj: ModuleDocsEntry,
 ): string {
@@ -331,11 +331,25 @@ function docsToHtml(
   switch (obj.kind) {
     case 'function': {
       let paramStr: string;
-
       if (obj.params.length === 0) {
         paramStr = '()';
       } else {
-        paramStr = `(${obj.params.map(([name, type]) => `${name}: ${type}`).join(', ')})`;
+        const [otherParams, restParams] = partition(obj.params, each => each.paramType !== 'rest');
+        const paramArgs = otherParams.map(each => {
+          if (each.paramType === 'optional') {
+            return `${each.name}?: ${each.type}`;
+          }
+
+          return `${each.name}: ${each.type}${each.defaultValue === undefined ? '' : ` = ${each.defaultValue}`}`;
+        });
+
+        if (restParams.length >= 1) {
+          // There should only ever be one rest parameter, but if there are we can just ignore the rest
+          const { name: paramName, type: paramType } = restParams[0];
+          paramArgs.push(`...${paramName}: ${paramType}`);
+        }
+
+        paramStr = `(${paramArgs.join(', ')})`;
       }
 
       const header = `${importedName}${paramStr} → {${obj.retType}}`;
diff --git a/src/repl/__tests__/main.test.ts b/src/repl/__tests__/main.test.ts
index c895e1236..b54e1d69e 100644
--- a/src/repl/__tests__/main.test.ts
+++ b/src/repl/__tests__/main.test.ts
@@ -15,7 +15,7 @@ describe('Make sure each subcommand can be run', () => {
   test.each(mainCommand.commands.map(cmd => [cmd.name(), cmd] as [string, Command]))(
     'Testing %s command',
     (_, cmd) => {
-      return expect(cmd.parseAsync(['-h'], { from: 'user' })).rejects.toThrowError(
+      return expect(cmd.parseAsync(['-h'], { from: 'user' })).rejects.toThrow(
         'process.exit called with 0',
       );
     },
diff --git a/src/repl/repl.ts b/src/repl/repl.ts
index a31c7619e..0f2c8b381 100644
--- a/src/repl/repl.ts
+++ b/src/repl/repl.ts
@@ -7,7 +7,7 @@ import { createContext, type IOptions } from '..';
 import { Chapter, Variant } from '../langs';
 import { setModulesStaticURL } from '../modules/loader';
 import { runCodeInSource, sourceFilesRunner } from '../runner';
-import type { RecursivePartial } from '../types';
+import type { RecursivePartial } from '../utils/typeUtils';
 import {
   assertLanguageCombo,
   chapterParser,
diff --git a/src/runner/__tests__/runners.test.ts b/src/runner/__tests__/runners.test.ts
index 2ede7d844..2a10ebbec 100644
--- a/src/runner/__tests__/runners.test.ts
+++ b/src/runner/__tests__/runners.test.ts
@@ -83,6 +83,15 @@ const JAVASCRIPT_CODE_SNIPPETS_NO_ERRORS: CodeSnippetTestCase[] = [
     value: 1,
     errors: [],
   },
+  {
+    name: 'DEFAULT ARGS',
+    snippet: `
+      function f(x, y = 0) { return x + y; }
+      f(5);
+    `,
+    value: 5,
+    errors: [],
+  },
 ];
 
 const JAVASCRIPT_CODE_SNIPPETS_ERRORS: CodeSnippetTestCase[] = [
diff --git a/src/runner/htmlRunner.ts b/src/runner/htmlRunner.ts
index fadfe79db..72d3834b1 100644
--- a/src/runner/htmlRunner.ts
+++ b/src/runner/htmlRunner.ts
@@ -1,5 +1,6 @@
 import type { IOptions, Result } from '..';
-import type { Context, RecursivePartial } from '../types';
+import type { Context } from '../types';
+import type { RecursivePartial } from '../utils/typeUtils';
 
 const HTML_ERROR_HANDLING_SCRIPT_TEMPLATE = `<script>
   window.onerror = (msg, url, lineNum) => {
diff --git a/src/runner/index.ts b/src/runner/index.ts
index 839db746b..8454345de 100644
--- a/src/runner/index.ts
+++ b/src/runner/index.ts
@@ -14,7 +14,7 @@ import {
   defaultSourceBundleImporter,
   defaultSourceTabImporter,
 } from '../modules/loader/importers';
-import type { RecursivePartial } from '../types';
+import type { RecursivePartial } from '../utils/typeUtils';
 import runners from './sourceRunner';
 import { determineExecutionMethod, determineVariant } from './utils';
 
diff --git a/src/runner/utils.ts b/src/runner/utils.ts
index c86b312c4..1c9b8e94e 100644
--- a/src/runner/utils.ts
+++ b/src/runner/utils.ts
@@ -3,7 +3,8 @@ import type { Program } from 'estree';
 import type { IOptions } from '..';
 import type { Variant } from '../langs';
 import { areBreakpointsSet } from '../stdlib/inspector';
-import type { Context, RecursivePartial } from '../types';
+import type { Context } from '../types';
+import type { RecursivePartial } from '../utils/typeUtils';
 import { simple } from '../utils/ast/walkers';
 
 // Context Utils
diff --git a/src/stdlib/__tests__/list.test.ts b/src/stdlib/__tests__/list.test.ts
index 73eee0ec6..9eb807f31 100644
--- a/src/stdlib/__tests__/list.test.ts
+++ b/src/stdlib/__tests__/list.test.ts
@@ -99,13 +99,13 @@ describe(list.build_list, () => {
 
     it('throws error when given a negative integer', () => {
       expect(() => list.build_list(x => x, -1)).toThrow(
-        'build_list: Expected integer greater than 0, got -1.',
+        'build_list: Expected integer ≥ 0, got -1.',
       );
     });
 
     it('throws error when given a float', () => {
       expect(() => list.build_list(x => x, 0.5)).toThrow(
-        'build_list: Expected integer greater than 0, got 0.5.',
+        'build_list: Expected integer ≥ 0, got 0.5.',
       );
     });
   });
@@ -130,7 +130,7 @@ describe(list.build_list, () => {
     // skipped as implementation does not check types, causing infinite recursion.
     test.todo('build_list with float', () => {
       return expectParsedError(`build_list(x => x, 1.5); `, Chapter.SOURCE_2).toEqual(
-        'Line 1: build_list: Expected an integer greater than 0 for n, got 1.5.',
+        'Line 1: build_list: Expected an integer >= 0 for n, got 1.5.',
       );
     });
 
@@ -162,7 +162,7 @@ describe(list.enum_list, () => {
 
     it('throws an error when end < start', () => {
       expect(() => list.enum_list(1, -1)).toThrow(
-        'enum_list: Expected number greater than 1 for end, got -1.',
+        'enum_list: Expected number ≥ 1 for end, got -1.',
       );
     });
 
@@ -174,7 +174,7 @@ describe(list.enum_list, () => {
 
     it('throws an error when end is not a number', () => {
       expect(() => list.enum_list(0, '0' as any)).toThrow(
-        'enum_list: Expected number greater than 0 for end, got "0".',
+        'enum_list: Expected number ≥ 0 for end, got "0".',
       );
     });
   });
@@ -293,7 +293,7 @@ describe(list.for_each, () => {
 describe(list.head, () => {
   describe('javascript', () => {
     it('throws an error when argument is not a pair', () => {
-      expect(() => list.head(0 as any)).toThrowError('head: Expected pair, got 0.');
+      expect(() => list.head(0 as any)).toThrow('head: Expected pair, got 0.');
     });
   });
 
@@ -423,13 +423,11 @@ describe(list.list_ref, () => {
     });
 
     it('throws error when given empty list', () => {
-      expect(() => list.list_ref(null, 0)).toThrowError('list_ref: Index 0 is out of bounds');
+      expect(() => list.list_ref(null, 0)).toThrow('list_ref: Index 0 is out of bounds');
     });
 
     test('throwing out of bounds for populated list', () => {
-      expect(() => list.list_ref(list.list(1, 2), 2)).toThrowError(
-        'list_ref: Index 2 is out of bounds',
-      );
+      expect(() => list.list_ref(list.list(1, 2), 2)).toThrow('list_ref: Index 2 is out of bounds');
     });
   });
 
diff --git a/src/stdlib/__tests__/misc.test.ts b/src/stdlib/__tests__/misc.test.ts
index 0a3e22a63..7bc1856ae 100644
--- a/src/stdlib/__tests__/misc.test.ts
+++ b/src/stdlib/__tests__/misc.test.ts
@@ -28,25 +28,25 @@ describe('parse_int', () => {
 
   test('parse_int with non-integer arg radix throws error', () => {
     return expectParsedError(`parse_int('42', 2.1);`).toEqual(
-      'Line 1: parse_int: Expected integer between 2 and 36 for radix, got 2.1.',
+      'Line 1: parse_int: Expected integer ∈ [2, 36] for radix, got 2.1.',
     );
   });
 
   test('parse_int with radix outside [2, 36] throws error, radix=1', () => {
     return expectParsedError(`parse_int('10', 1);`).toEqual(
-      'Line 1: parse_int: Expected integer between 2 and 36 for radix, got 1.',
+      'Line 1: parse_int: Expected integer ∈ [2, 36] for radix, got 1.',
     );
   });
 
   test('parse_int with radix outside [2, 36] throws error, radix=37', () => {
     return expectParsedError(`parse_int('10', 37);`).toEqual(
-      'Line 1: parse_int: Expected integer between 2 and 36 for radix, got 37.',
+      'Line 1: parse_int: Expected integer ∈ [2, 36] for radix, got 37.',
     );
   });
 
   test('parse_int with string arg radix throws error', () => {
     return expectParsedError(`parse_int('42', '2'); `).toEqual(
-      'Line 1: parse_int: Expected integer between 2 and 36 for radix, got "2".',
+      'Line 1: parse_int: Expected integer ∈ [2, 36] for radix, got "2".',
     );
   });
 });
@@ -60,13 +60,13 @@ describe('char_at', () => {
 
   test('char_at with non nonnegative integer second argument errors', () => {
     return expectParsedError(`char_at('', -1);`).toEqual(
-      'Line 1: char_at: Expected integer greater than 0 for index, got -1.',
+      'Line 1: char_at: Expected integer ≥ 0 for index, got -1.',
     );
   });
 
   test('char_at with string for second argument errors', () => {
     return expectParsedError(`char_at('', "");`).toEqual(
-      'Line 1: char_at: Expected integer greater than 0 for index, got "".',
+      'Line 1: char_at: Expected integer ≥ 0 for index, got "".',
     );
   });
 
diff --git a/src/stdlib/list.ts b/src/stdlib/list.ts
index 5244fe02a..72b6585fd 100644
--- a/src/stdlib/list.ts
+++ b/src/stdlib/list.ts
@@ -8,6 +8,7 @@
 import { GeneralRuntimeError } from '../errors/base';
 import { InvalidParameterTypeError } from '../errors/rttcErrors';
 import type { Value } from '../types';
+import { callWithoutMetadata } from '../utils/operators';
 import { assertFunctionOfLength, assertNumberWithinRange } from '../utils/rttc';
 import type { ArrayLike } from '../utils/stringify';
 
@@ -162,7 +163,9 @@ export function vector_to_list<T>(vector: T[]): List<T> {
 export function accumulate<T, U>(op: (each: T, result: U) => U, initial: U, sequence: List<T>): U {
   // Use CPS to prevent stack overflow
   function $accumulate(xs: typeof sequence, cont: (each: U) => U): U {
-    return is_null(xs) ? cont(initial) : $accumulate(tail(xs), x => cont(op(head(xs), x)));
+    return is_null(xs)
+      ? cont(initial)
+      : $accumulate(tail(xs), x => cont(callWithoutMetadata(op, head(xs), x)));
   }
   return $accumulate(sequence, x => x);
 }
@@ -188,7 +191,9 @@ export function build_list<T>(f: (arg: number) => T, n: number): List<T> {
   assertFunctionOfLength(f, 1, build_list.name);
 
   function $build_list(i: number, already_built: List<T>): List<T> {
-    return i < 0 ? already_built : $build_list(i - 1, pair(f(i), already_built));
+    return i < 0
+      ? already_built
+      : $build_list(i - 1, pair(callWithoutMetadata(f, i), already_built));
   }
 
   return $build_list(n - 1, null);
@@ -216,7 +221,11 @@ export function enum_list(start: number, end: number): List<number> {
 export function filter<T, U extends T>(pred: (arg: T) => arg is U, xs: List<T>): List<U>;
 export function filter<T>(pred: (arg: T) => boolean, xs: List<T>): List<T>;
 export function filter<T>(pred: (arg: T) => boolean, xs: List<T>): List<T> {
-  return accumulate((each, result) => (pred(each) ? pair(each, result) : result), list(), xs);
+  return accumulate(
+    (each, result) => (callWithoutMetadata(pred, each) ? pair(each, result) : result),
+    list(),
+    xs,
+  );
 }
 
 /**
@@ -224,7 +233,7 @@ export function filter<T>(pred: (arg: T) => boolean, xs: List<T>): List<T> {
  */
 export function for_each<T>(op: (arg: T) => void, xs: List<T>): true {
   if (is_null(xs)) return true;
-  op(head(xs));
+  callWithoutMetadata(op, head(xs));
   return for_each(op, tail(xs));
 }
 
@@ -268,7 +277,11 @@ export function list_ref<T>(xs: List<T>, n: number) {
  * a new list containing the results
  */
 export function map<T, U>(op: (each: T) => U, sequence: List<T>): List<U> {
-  return accumulate((each, result) => pair(op(each), result), list(), sequence);
+  return accumulate(
+    (each, result) => pair(callWithoutMetadata(op, each), result),
+    list(),
+    sequence,
+  );
 }
 
 /**
diff --git a/src/stdlib/stream.ts b/src/stdlib/stream.ts
index f202ffe42..8010c65a1 100644
--- a/src/stdlib/stream.ts
+++ b/src/stdlib/stream.ts
@@ -1,6 +1,6 @@
 import { GeneralRuntimeError } from '../errors/base';
 import { InvalidParameterTypeError } from '../errors/rttcErrors';
-import { wrap } from '../utils/operators';
+import { callWithoutMetadata, wrap } from '../utils/operators';
 import { head, is_null, is_pair, type List, type Pair, pair, tail } from './list';
 import { arity } from './misc';
 
@@ -8,7 +8,7 @@ type NonEmptyStream<T = unknown> = Pair<T, () => Stream<T>>;
 export type Stream<T = unknown> = null | NonEmptyStream<T>;
 
 function createStreamPair<T>(item: T, next: () => Stream<T>): NonEmptyStream<T> {
-  const streamTail = wrap(next, false, '() => ...');
+  const streamTail = wrap(next, undefined, undefined, '() => ...');
   return pair(item, streamTail);
 }
 
@@ -79,7 +79,7 @@ export function integers_from(n: number): Stream<number> {
  */
 export function build_stream<T>(f: (n: number) => T, n: number): Stream<T> {
   function build(i: number): Stream<T> {
-    return i >= n ? null : pair(f(i), () => build(i + 1));
+    return i >= n ? null : pair(callWithoutMetadata(f, i), () => build(i + 1));
   }
 
   return build(0);
@@ -92,7 +92,9 @@ export function build_stream<T>(f: (n: number) => T, n: number): Stream<T> {
  * forced by the resulting stream.
  */
 export function stream_map<T, U>(f: (arg: T) => U, s: Stream<T>): Stream<U> {
-  return is_null(s) ? null : pair(f(head(s)), () => stream_map(f, stream_tail(s)));
+  return is_null(s)
+    ? null
+    : pair(callWithoutMetadata(f, head(s)), () => stream_map(f, stream_tail(s)));
 }
 
 /**
@@ -105,7 +107,7 @@ export function stream_filter<T>(f: (arg: T) => boolean, s: Stream<T>): Stream<T
 export function stream_filter<T>(f: (arg: T) => boolean, s: Stream<T>): Stream<T> {
   if (is_null(s)) return null;
 
-  const should = f(head(s));
+  const should = callWithoutMetadata(f, head(s));
 
   return should
     ? pair(head(s), () => stream_filter(f, stream_tail(s)))
@@ -121,7 +123,7 @@ export function stream_for_each<T>(f: (arg: T) => void, s: Stream<T>) {
   if (is_null(s)) {
     return true;
   } else {
-    f(head(s));
+    callWithoutMetadata(f, head(s));
     return stream_for_each(f, stream_tail(s));
   }
 }
@@ -146,7 +148,7 @@ export function stream_accumulate<T, U>(
 
   while (!is_null(entry)) {
     const element = head(entry);
-    res = f(element, res);
+    res = callWithoutMetadata(f, element, res);
     entry = stream_tail(entry);
   }
 
diff --git a/src/stepper/__tests__/__snapshots__/stepper_full.test.ts.snap b/src/stepper/__tests__/__snapshots__/stepper_full.test.ts.snap
index fe117cf2a..95fac3ca7 100644
--- a/src/stepper/__tests__/__snapshots__/stepper_full.test.ts.snap
+++ b/src/stepper/__tests__/__snapshots__/stepper_full.test.ts.snap
@@ -4488,21 +4488,48 @@ exports[`Builtin math > PI returns its value 1`] = `
 "
 `;
 
-exports[`Builtin math > math_sin() returns NaN 1`] = `
-"math_sin();
+exports[`Builtin math > math_max with no arguments 1`] = `
+"math_max();
 [noMarker] Start of evaluation
 
-math_sin();
-[beforeMarker] math_sin runs
+math_max();
+[beforeMarker] math_max runs
 
-NaN;
-[afterMarker] math_sin runs
+-Infinity;
+[afterMarker] math_max runs
+
+-Infinity;
+[noMarker] Evaluation complete
+"
+`;
+
+exports[`Builtin math > math_min with multiple arguments 1`] = `
+"math_min(1, 2, 3);
+[noMarker] Start of evaluation
+
+math_min(1, 2, 3);
+[beforeMarker] math_min runs
+
+1;
+[afterMarker] math_min runs
 
-NaN;
+1;
 [noMarker] Evaluation complete
 "
 `;
 
+exports[`Builtin math > math_sin() with no arguments is error 1`] = `
+"math_sin();
+[noMarker] Start of evaluation
+
+math_sin();
+[beforeMarker] Line 1: math_sin: Expected 1 arguments, but got 0.
+
+math_sin();
+[noMarker] Evaluation stuck
+"
+`;
+
 exports[`Builtin math > negative numbers as arguments 1`] = `
 "math_sin(-1);
 [noMarker] Start of evaluation
@@ -15074,7 +15101,7 @@ exports[`Test catching errors from built in function > Incorrect number of argum
 [noMarker] Start of evaluation
 
 pair(2);
-[beforeMarker] Line 1: Expected 2 arguments, but got 1.
+[beforeMarker] Line 1: pair: Expected 2 arguments, but got 1.
 
 pair(2);
 [noMarker] Evaluation stuck
diff --git a/src/stepper/__tests__/stepper_full.test.ts b/src/stepper/__tests__/stepper_full.test.ts
index 8a848b4b2..5f66d7c16 100644
--- a/src/stepper/__tests__/stepper_full.test.ts
+++ b/src/stepper/__tests__/stepper_full.test.ts
@@ -1,6 +1,6 @@
 import * as acorn from 'acorn';
-import { generate as customGenerate } from '../utils';
 import { describe, expect, test } from 'vitest';
+import { generate as customGenerate } from '../utils';
 import createContext from '../../createContext';
 import { mockContext } from '../../utils/testing/mocks';
 import { convert } from '../generator';
@@ -627,12 +627,14 @@ describe('Builtin math', () => {
     expect(steps[steps.length - 1]).toEqual('3.141592653589793;\n[noMarker] Evaluation complete\n');
     expect(steps.join('\n')).toMatchSnapshot();
   });
-  test('math_sin() returns NaN', () => {
+
+  test('math_sin() with no arguments is error', () => {
     const code = 'math_sin();';
     const steps = codify(acornParser(code));
-    expect(steps[steps.length - 1]).toEqual('NaN;\n[noMarker] Evaluation complete\n');
+    expect(steps[steps.length - 1]).toEqual('math_sin();\n[noMarker] Evaluation stuck\n');
     expect(steps.join('\n')).toMatchSnapshot();
   });
+
   test('negative numbers as arguments', () => {
     const code = `
     math_sin(-1);
@@ -640,6 +642,20 @@ describe('Builtin math', () => {
     const steps = codify(acornParser(code));
     expect(steps.join('\n')).toMatchSnapshot();
   });
+
+  test('math_max with no arguments', () => {
+    const code = 'math_max();';
+    const steps = codify(acornParser(code));
+    expect(steps[steps.length - 1]).toEqual('-Infinity;\n[noMarker] Evaluation complete\n');
+    expect(steps.join('\n')).toMatchSnapshot();
+  });
+
+  test('math_min with multiple arguments', () => {
+    const code = 'math_min(1, 2, 3);';
+    const steps = codify(acornParser(code));
+    expect(steps[steps.length - 1]).toEqual('1;\n[noMarker] Evaluation complete\n');
+    expect(steps.join('\n')).toMatchSnapshot();
+  });
 });
 
 describe('Misc', () => {
diff --git a/src/stepper/builtins/index.ts b/src/stepper/builtins/index.ts
index fd59f42b2..0ef0d9a89 100644
--- a/src/stepper/builtins/index.ts
+++ b/src/stepper/builtins/index.ts
@@ -3,10 +3,10 @@ import { convert } from '../generator';
 import type { StepperExpression } from '../nodes';
 import { StepperIdentifier } from '../nodes/Expression/Identifier';
 import { StepperLiteral } from '../nodes/Expression/Literal';
-import { InvalidNumberOfArgumentsError } from '../../errors/errors';
 import type { StepperFunctionApplication } from '../nodes/Expression/FunctionApplication';
 import type { RedexInfo } from '..';
 import { InvalidParameterTypeError } from '../../errors/rttcErrors';
+import { validateFunctionArgCount } from '../../utils/operators';
 import { auxiliaryBuiltinFunctions } from './auxiliary';
 import { listBuiltinFunctions } from './lists';
 import { miscBuiltinFunctions } from './misc';
@@ -33,6 +33,10 @@ export function prelude(node: es.BaseNode, redex: RedexInfo) {
   return inputNode;
 }
 
+/**
+ * Retrieves the builtin with the given name. Also verifies
+ * the argument count
+ */
 export function getBuiltinFunction(
   name: string,
   call: StepperFunctionApplication,
@@ -41,9 +45,18 @@ export function getBuiltinFunction(
 
   if (name.startsWith('math_')) {
     const mathFnName = name.split('_')[1];
-
     if (mathFnName in Math) {
+      // Is a math function
       const fn = (Math as any)[mathFnName];
+
+      if (mathFnName === 'min' || mathFnName === 'max') {
+        // Assume that only min and max have varargs
+        validateFunctionArgCount(call, args.length, 0, true, name);
+      } else {
+        // And use f.length for everything else
+        validateFunctionArgCount(call, args.length, fn.length, undefined, name);
+      }
+
       const argVal = args.map(arg => (arg as StepperLiteral).value);
       argVal.forEach(arg => {
         if (typeof arg !== 'number' && typeof arg !== 'bigint') {
@@ -58,10 +71,13 @@ export function getBuiltinFunction(
 
   const calledFunction = builtinFunctions[name as keyof typeof builtinFunctions];
 
-  if (calledFunction.arity !== args.length && name !== 'list') {
-    // brute force way to fix this issue
-    throw new InvalidNumberOfArgumentsError(call, calledFunction.arity, args.length);
-  }
+  validateFunctionArgCount(
+    call,
+    args.length,
+    calledFunction.arity,
+    name === 'list' ? true : undefined,
+    name,
+  );
 
   return calledFunction.definition(args);
 }
diff --git a/src/stepper/nodes/Expression/FunctionApplication.ts b/src/stepper/nodes/Expression/FunctionApplication.ts
index 03f6fa3a4..7569bb1fb 100644
--- a/src/stepper/nodes/Expression/FunctionApplication.ts
+++ b/src/stepper/nodes/Expression/FunctionApplication.ts
@@ -4,12 +4,10 @@ import { getBuiltinFunction, isBuiltinFunction } from '../../builtins';
 import { convert } from '../../generator';
 import { StepperBaseNode } from '../../interface';
 import { StepperBlockStatement } from '../Statement/BlockStatement';
-import {
-  CallingNonFunctionValueError,
-  InvalidNumberOfArgumentsError,
-} from '../../../errors/errors';
+import { CallingNonFunctionValueError } from '../../../errors/errors';
 import { GeneralRuntimeError, InternalRuntimeError } from '../../../errors/base';
 import type { RedexInfo } from '../..';
+import { validateFunctionArgCount } from '../../../utils/operators';
 import { StepperBlockExpression } from './BlockExpression';
 
 export class StepperFunctionApplication
@@ -44,11 +42,9 @@ export class StepperFunctionApplication
   }
 
   public override isContractible(redex: RedexInfo): boolean {
-    const isValidCallee =
-      this.callee.type === 'ArrowFunctionExpression' ||
-      (this.callee.type === 'Identifier' && isBuiltinFunction(this.callee.name));
-
-    if (!isValidCallee) {
+    if (this.callee.type === 'ArrowFunctionExpression') {
+      validateFunctionArgCount(this);
+    } else if (this.callee.type !== 'Identifier' || !isBuiltinFunction(this.callee.name)) {
       // Since the callee can not proceed further, calling non callables should result to an error.
 
       if (
@@ -60,17 +56,6 @@ export class StepperFunctionApplication
       return false;
     }
 
-    if (this.callee.type === 'ArrowFunctionExpression') {
-      const arrowFunction = this.callee;
-      if (arrowFunction.params.length !== this.arguments.length) {
-        throw new InvalidNumberOfArgumentsError(
-          this,
-          arrowFunction.params.length,
-          this.arguments.length,
-        );
-      }
-    }
-
     return this.arguments.every(arg => !arg.isOneStepPossible(redex));
   }
 
diff --git a/src/transpiler/__tests__/__snapshots__/transpiled-code.test.ts.snap b/src/transpiler/__tests__/__snapshots__/transpiled-code.test.ts.snap
index 3beabd7ce..5864535f7 100644
--- a/src/transpiler/__tests__/__snapshots__/transpiled-code.test.ts.snap
+++ b/src/transpiler/__tests__/__snapshots__/transpiled-code.test.ts.snap
@@ -107,7 +107,7 @@ exports[`Ensure no name clashes 1`] = `
       wrap7;
       wrap8;
       wrap9;
-    }, false, \\"function f(callIfFuncAndRightArgs, wrap0, wrap1, wrap2, wrap3, wrap4, wrap5, wrap6, wrap7, wrap8, wrap9) {\\\\n  let wrap = 2;\\\\n  wrap0;\\\\n  wrap1;\\\\n  wrap2;\\\\n  wrap3;\\\\n  wrap4;\\\\n  wrap5;\\\\n  wrap6;\\\\n  wrap7;\\\\n  wrap8;\\\\n  wrap9;\\\\n}\\", null);
+    }, 0, undefined, \\"function f(callIfFuncAndRightArgs, wrap0, wrap1, wrap2, wrap3, wrap4, wrap5, wrap6, wrap7, wrap8, wrap9) {\\\\n  let wrap = 2;\\\\n  wrap0;\\\\n  wrap1;\\\\n  wrap2;\\\\n  wrap3;\\\\n  wrap4;\\\\n  wrap5;\\\\n  wrap6;\\\\n  wrap7;\\\\n  wrap8;\\\\n  wrap9;\\\\n}\\", null);
     const native = 123;
   }
 }
diff --git a/src/transpiler/__tests__/transpiled-code.test.ts b/src/transpiler/__tests__/transpiled-code.test.ts
index ee1d89cc3..c725ff3d9 100644
--- a/src/transpiler/__tests__/transpiled-code.test.ts
+++ b/src/transpiler/__tests__/transpiled-code.test.ts
@@ -41,6 +41,19 @@ test('Ensure no name clashes', () => {
   expect(replacedGlobalsLine).toMatchSnapshot();
 });
 
+describe.todo('Wrapping call expressions', () => {
+  test('when callee is a member expression', () => {
+    const code = stripIndent`
+      const obj = {};
+      obj.foo();
+    `;
+    const context = mockContext(Chapter.LIBRARY_PARSER);
+    const { transpiled } = transpile(parse(code, context)!, context, false);
+
+    expect(transpiled).toMatchSnapshot();
+  });
+});
+
 describe(transformImportDeclarations, () => {
   type TestCase = [actualCode: string, expectedCode: string];
 
diff --git a/src/transpiler/transpiler.ts b/src/transpiler/transpiler.ts
index 98b0aa539..bf0ea81f4 100644
--- a/src/transpiler/transpiler.ts
+++ b/src/transpiler/transpiler.ts
@@ -151,11 +151,15 @@ function wrapArrowFunctionsToAllowNormalCallsAndNiceToString(
 ) {
   simple(program, {
     ArrowFunctionExpression(node: es.ArrowFunctionExpression) {
+      const hasRestElement = node.params[node.params.length - 1]?.type === 'RestElement';
+      const optionalParams = node.params.filter(x => x.type === 'AssignmentPattern');
+
       // If it's undefined then we're dealing with a thunk
       if (functionsToStringMap.get(node)! !== undefined) {
         create.mutateToCallExpression(node, globalIds.wrap, [
           { ...node },
-          create.literal(node.params[node.params.length - 1]?.type === 'RestElement'),
+          create.literal(hasRestElement || optionalParams.length),
+          create.identifier('undefined'),
           create.literal(functionsToStringMap.get(node)!),
           create.literal(isPrelude ? 'prelude' : null),
         ]);
@@ -347,6 +351,7 @@ function transformPropertyAccess(program: es.Program, globalIds: NativeIds) {
       const { object, property, computed, loc } = node;
       const { line, column } = (loc ?? UNKNOWN_LOCATION).start;
       const source = loc?.source ?? null;
+
       create.mutateToCallExpression(node, globalIds.getProp, [
         object as es.Expression,
         getComputedProperty(computed, property as es.Expression),
diff --git a/src/types.ts b/src/types.ts
index a048c8174..7ba346adf 100644
--- a/src/types.ts
+++ b/src/types.ts
@@ -27,6 +27,11 @@ export interface CustomBuiltIns {
  * `toString` behaviour
  */
 export interface ReplResult {
+  // toReplString is marked as internal so that documentation generators can be
+  // configured to exclude it for cadet facing types
+  /**
+   * @internal
+   */
   toReplString: () => string;
 }
 
@@ -392,26 +397,6 @@ export type TypeEnvironment = {
   typeAliasMap: Map<string, Type | ForAll>;
 }[];
 
-/**
- * Helper type to recursively make properties that are also objects
- * partial
- *
- * By default, `Partial<Array<T>>` is equivalent to `Array<T | undefined>`. For this type, `Array<T>` will be
- * transformed to Array<Partial<T>> instead
- */
-export type RecursivePartial<T> =
-  T extends Array<any>
-    ? Array<RecursivePartial<T[number]>>
-    : // Apparently typescript considers functions assignable
-      // to records?
-      T extends (...args: any[]) => any
-      ? T
-      : T extends Record<any, any>
-        ? Partial<{
-            [K in keyof T]: RecursivePartial<T[K]>;
-          }>
-        : T;
-
 /**
  * Utility type for selecting extracting the specific Node type when provided
  * the type string.
diff --git a/src/utils/__tests__/misc.test.ts b/src/utils/__tests__/misc.test.ts
index 73b9cee1a..2808b6973 100644
--- a/src/utils/__tests__/misc.test.ts
+++ b/src/utils/__tests__/misc.test.ts
@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
-import { Chapter } from '../../langs';
-import { getChapterName, PromiseTimeoutError, timeoutPromise } from '../misc';
+import { Chapter, Variant } from '../../langs';
+import { getChapterName, getVariantName, PromiseTimeoutError, timeoutPromise } from '../misc';
 
 describe(timeoutPromise, () => {
   const timedResolvedPromise = (duration: number) =>
@@ -38,3 +38,13 @@ describe(getChapterName, () =>
     ['FULL_JS', Chapter.FULL_JS],
   ])('%s', (expected, input) => expect(getChapterName(input)).toEqual(expected)),
 );
+
+describe(getVariantName, () => {
+  test.each([
+    ['DEFAULT', Variant.DEFAULT],
+    ['TYPED', Variant.TYPED],
+    ['NATIVE', Variant.NATIVE],
+    ['WASM', Variant.WASM],
+    ['EXPLICIT_CONTROL', Variant.EXPLICIT_CONTROL],
+  ])('%s', (expected, input) => expect(getVariantName(input)).toEqual(expected));
+});
diff --git a/src/utils/__tests__/operators.test.ts b/src/utils/__tests__/operators.test.ts
index 859f000c0..656ba7766 100644
--- a/src/utils/__tests__/operators.test.ts
+++ b/src/utils/__tests__/operators.test.ts
@@ -1,53 +1,57 @@
-import { assert, describe, expect, test } from 'vitest';
+import { parse } from 'acorn';
+import type { Program } from 'estree';
+import { assert, describe, expect, it, test, vi } from 'vitest';
 import * as operators from '../operators';
 import { stringify } from '../stringify';
 import { GeneralRuntimeError, RuntimeSourceError } from '../../errors/base';
-import { locationDummyNode } from '../ast/astCreator';
+import { callExpression, locationDummyNode } from '../ast/astCreator';
+import { ACORN_PARSE_OPTIONS } from '../../constants';
 
 describe('Wrapping and Calling functions', () => {
   describe('No redefine tests', () => {
     test("Doesn't redefine toReplString if it is already present", () => {
       const x = () => 0;
       x.toReplString = () => 'x';
-      const wrapped = operators.wrap(x, undefined, '() => 0');
+      const wrapped = operators.wrap(x, 0, undefined, '() => 0');
 
       expect(stringify(wrapped)).toEqual('x');
     });
 
     test("Doesn't define toReplString if stringified is undefined", () => {
       const x = () => 0;
-      const wrapped = operators.wrap(x, undefined);
+      const wrapped = operators.wrap(x);
 
       expect(wrapped).not.toHaveProperty('toReplString');
     });
 
-    test("Doesn't redefine minArgsNeeded when present", () => {
-      const x = () => 0;
-      const x1 = operators.wrap(x, 2);
-      const x2 = operators.wrap(x1, 1);
+    test("Doesn't redefine maxArgs when present", () => {
+      const x = (u: number, v = 0) => u + v;
+      const x1 = operators.wrap(x, 1, 'x');
+      // @ts-expect-error Intentionally breaking wrap type safety
+      const x2 = operators.wrap(x1, 2, 'x1');
 
-      expect(operators.callIfFuncAndRightArgs(x2, 0, 0, null, undefined, 'x', 'y')).toEqual(0);
+      expect(operators.callWithoutMetadata(x1, 1)).toEqual(1);
 
-      expect(() => operators.callIfFuncAndRightArgs(x2, 0, 0, null, undefined, 'x')).toThrow(
-        'x: Expected 2 or more arguments, but got 1.',
+      expect(() => operators.callWithoutMetadata(x2 as any, 1, 2, 3)).toThrow(
+        'x1: Expected 2 or fewer arguments, but got 3.',
       );
     });
   });
 
   describe('Wrapped nullary function tests', () => {
     const x = () => 0;
-    const wrapped = operators.wrap(x, undefined, '() => 0');
+    const wrapped = operators.wrap(x, undefined, undefined, '() => 0');
 
     test('toReplString is set correctly', () => {
       expect(stringify(wrapped)).toEqual('() => 0');
     });
 
     test('calling with correct number of function parameters', () => {
-      expect(operators.callIfFuncAndRightArgs(wrapped, 0, 0, null, undefined)).toEqual(0);
+      expect(operators.callWithoutMetadata(wrapped)).toEqual(0);
     });
 
     test('calling with too many parameters', () => {
-      expect(() => operators.callIfFuncAndRightArgs(wrapped, 0, 0, null, undefined, 1)).toThrow(
+      expect(() => operators.callWithoutMetadata(wrapped as any, 1)).toThrow(
         'x: Expected 0 arguments, but got 1.',
       );
     });
@@ -55,24 +59,22 @@ describe('Wrapping and Calling functions', () => {
 
   describe('Wrapped varargs function test', () => {
     const f = (x: any, ...args: any[]) => [x, ...args];
-    const wrapped = operators.wrap(f, 1, '(x, ...args) => [x, ...args]');
+    const wrapped = operators.wrap(f, true, 'f', '(x, ...args) => [x, ...args]');
 
     test('toReplString is set correctly', () => {
       expect(stringify(wrapped)).toEqual('(x, ...args) => [x, ...args]');
     });
 
     test('calling with 1 parameter', () => {
-      expect(operators.callIfFuncAndRightArgs(wrapped, 0, 0, null, undefined, 1)).toEqual([1]);
+      expect(operators.callWithoutMetadata(wrapped, 1)).toEqual([1]);
     });
 
     test('calling with 2 parameters', () => {
-      expect(operators.callIfFuncAndRightArgs(wrapped, 0, 0, null, undefined, 1, 2)).toEqual([
-        1, 2,
-      ]);
+      expect(operators.callWithoutMetadata(wrapped, 1, 2)).toEqual([1, 2]);
     });
 
     test('calling with 0 parameters', () => {
-      expect(() => operators.callIfFuncAndRightArgs(wrapped, 0, 0, null, undefined)).toThrow(
+      expect(() => operators.callWithoutMetadata(wrapped as any)).toThrow(
         'f: Expected 1 or more arguments, but got 0.',
       );
     });
@@ -106,6 +108,7 @@ describe('Wrapping and Calling functions', () => {
           throw new GeneralRuntimeError('', dummy);
         },
         undefined,
+        'f',
         '() => { ... }',
         'prelude',
       );
@@ -128,10 +131,17 @@ describe('Wrapping and Calling functions', () => {
           throw new GeneralRuntimeError('');
         },
         undefined,
+        'prelude',
         '() => {...}',
         null,
       );
-      const notPrelude = operators.wrap(() => prelude(), undefined, '() => {...}', 'prelude');
+      const notPrelude = operators.wrap(
+        () => prelude(),
+        undefined,
+        'notPrelude',
+        '() => {...}',
+        'prelude',
+      );
 
       try {
         operators.callIfFuncAndRightArgs(notPrelude, 2, 2, null, undefined);
@@ -146,3 +156,184 @@ describe('Wrapping and Calling functions', () => {
     });
   });
 });
+
+describe(operators.validateFunctionArgCount, () => {
+  describe('Calling manually', () => {
+    const dummyCall = callExpression({} as any, [], {
+      start: { line: 1, column: 1 },
+      end: { line: 1, column: 1 },
+    });
+
+    // Error case when only a TooFew error is thrown
+    type MinOnlyErrorCase = [received: number, minArgs: number, maxArgs: true, error?: 'min'];
+
+    // Error case when either a TooFew or TooMany error is thrown
+    type MinMaxErrorCase = [
+      received: number,
+      minArgs: number,
+      maxArgs: number | undefined,
+      error?: 'min' | 'max',
+    ];
+
+    type TestCase = MinMaxErrorCase | MinOnlyErrorCase;
+
+    function isMinOnly(c: TestCase): c is MinOnlyErrorCase {
+      const [, , max] = c;
+      return max === true;
+    }
+    const cases: TestCase[] = [
+      // No error cases
+      [2, 2, undefined],
+      [2, 2, 2],
+      [2, 1, 2],
+      [20, 1, true],
+
+      // Min error cases
+      [0, 1, undefined, 'min'],
+      [0, 1, 3, 'min'],
+      [0, 1, true, 'min'],
+
+      // Max error cases
+      [10, 1, undefined, 'max'],
+      [10, 1, 4, 'max'],
+    ];
+
+    it.for(cases)('received = %d, min = %d, max = %s, error = %s', c => {
+      if (isMinOnly(c)) {
+        const [received, min, max, error] = c;
+        if (error === 'min') {
+          // TooFew error expected
+          expect(() =>
+            operators.validateFunctionArgCount(dummyCall, received, min, max, 'f'),
+          ).toThrow(`f: Expected ${min} or more arguments, but got ${received}.`);
+          return;
+        } else {
+          // No error expected
+          expect(() =>
+            operators.validateFunctionArgCount(dummyCall, received, min, max, 'f'),
+          ).not.toThrow();
+          return;
+        }
+      } else {
+        const [received, min, max, error] = c;
+        const expectedMax = max ?? min;
+
+        switch (error) {
+          case 'min': {
+            // TooFew error expected
+            expect(() =>
+              operators.validateFunctionArgCount(dummyCall, received, min, max, 'f'),
+            ).toThrow(
+              `f: Expected ${min} ${min !== expectedMax ? 'or more ' : ''}arguments, but got ${received}.`,
+            );
+            return;
+          }
+          case 'max': {
+            // TooMany error expected
+            expect(() =>
+              operators.validateFunctionArgCount(dummyCall, received, min, max, 'f'),
+            ).toThrow(
+              `f: Expected ${expectedMax} ${min !== expectedMax ? 'or fewer ' : ''}arguments, but got ${received}.`,
+            );
+            return;
+          }
+          default: {
+            // No error expected
+            expect(() =>
+              operators.validateFunctionArgCount(dummyCall, received, min, max, 'f'),
+            ).not.toThrow();
+            return;
+          }
+        }
+      }
+    });
+  });
+
+  describe('Calling with call expression', () => {
+    const getNode = vi.defineHelper((code: string) => {
+      const program = parse(code, ACORN_PARSE_OPTIONS) as Program;
+      const node0 = program.body[0];
+      assert(
+        node0.type === 'ExpressionStatement',
+        'Expected first node of program to be ExpressionStatement',
+      );
+      assert(
+        node0.expression.type === 'CallExpression',
+        'Expected first node to be call to function',
+      );
+      return node0.expression;
+    });
+
+    type TestCase = [code: string, error?: 'min' | 'max'];
+
+    const cases: TestCase[] = [
+      ['(() => {})()'],
+      ['(x => {})(x)'],
+      ['((x, y) => {})(x, y)'],
+      ['((x, y = 0) => {})(x)'],
+      ['((x, y = 0) => {})(x, y)'],
+      ['((...x) => {})()'],
+      ['((...x) => {})(x, y)'],
+
+      // Min Errors
+      ['(x => {})()', 'min'],
+      ['((x, y) => {})()', 'min'],
+      ['((x, y = 0) => {})()', 'min'],
+      ['((x, ...y) => {})()', 'min'],
+
+      // Max Errors
+      ['(() => {})(x)', 'max'],
+      ['((x = 0) => {})(x, y)', 'max'],
+
+      // Case for invalid call expression
+      ['eval();'],
+    ];
+
+    it.for(cases)('%s', ([code, error]) => {
+      const expr = getNode(code);
+      const { callee } = expr;
+
+      if (callee.type !== 'ArrowFunctionExpression' && callee.type !== 'FunctionExpression') {
+        expect(() => operators.validateFunctionArgCount(expr)).toThrow(
+          'validateFunctionArgCount: When called with CallExpression only, callee must be a function node',
+        );
+        return;
+      }
+
+      const min = callee.params.filter(
+        x => x.type !== 'AssignmentPattern' && x.type !== 'RestElement',
+      ).length;
+      const max =
+        (callee.params.length > 0 &&
+          callee.params[callee.params.length - 1].type === 'RestElement') ||
+        callee.params.length;
+      const received = expr.arguments.length;
+
+      switch (error) {
+        case 'min': {
+          // Expected a TooFew error
+          expect(() => operators.validateFunctionArgCount(expr)).toThrow(
+            `Expected ${min} ${min !== max ? 'or more ' : ''}arguments, but got ${received}.`,
+          );
+          return;
+        }
+        case 'max': {
+          if (max === true) {
+            expect.fail('Node has rest param, but TooMany error was expected.');
+          }
+
+          // TooMany error expected
+          expect(() => operators.validateFunctionArgCount(expr)).toThrow(
+            `Expected ${max} ${min !== max ? 'or fewer ' : ''}arguments, but got ${received}.`,
+          );
+          return;
+        }
+        default: {
+          // No error expected
+          expect(() => operators.validateFunctionArgCount(expr)).not.toThrow();
+          return;
+        }
+      }
+    });
+  });
+});
diff --git a/src/utils/__tests__/rttc.test.ts b/src/utils/__tests__/rttc.test.ts
index 41b03de75..cf9e70b68 100644
--- a/src/utils/__tests__/rttc.test.ts
+++ b/src/utils/__tests__/rttc.test.ts
@@ -30,6 +30,19 @@ describe('rttc Type Guards', () => {
       expect(rttc.typeOf(obj)).toEqual('object');
     });
   });
+
+  test('TypeofConstantsToType', () => {
+    expectTypeOf<rttc.TypeOfConstantToType<'array'>>().toEqualTypeOf<unknown[]>();
+    expectTypeOf<rttc.TypeOfConstantToType<'bigint'>>().toEqualTypeOf<bigint>();
+    expectTypeOf<rttc.TypeOfConstantToType<'boolean'>>().toEqualTypeOf<boolean>();
+    expectTypeOf<rttc.TypeOfConstantToType<'function'>>().toEqualTypeOf<(...args: any[]) => any>();
+    expectTypeOf<rttc.TypeOfConstantToType<'regexp'>>().toEqualTypeOf<RegExp>();
+    expectTypeOf<rttc.TypeOfConstantToType<'null'>>().toEqualTypeOf<null>();
+    expectTypeOf<rttc.TypeOfConstantToType<'number'>>().toEqualTypeOf<number>();
+    expectTypeOf<rttc.TypeOfConstantToType<'object'>>().toEqualTypeOf<object>();
+    expectTypeOf<rttc.TypeOfConstantToType<'string'>>().toEqualTypeOf<string>();
+    expectTypeOf<rttc.TypeOfConstantToType<'undefined'>>().toEqualTypeOf<undefined>();
+  });
 });
 
 interface Fixtures {
@@ -383,12 +396,16 @@ describe(rttc.isFunctionOfLength, () => {
 
     const func3: unknown = (_a: any) => {};
     if (rttc.isFunctionOfLength(func3, 1)) {
-      expectTypeOf(func3).toEqualTypeOf<(a: unknown) => unknown>();
+      expectTypeOf(func3).toEqualTypeOf<(a: unknown, ...args: unknown[]) => unknown>();
     } else {
       expectTypeOf(func3).toEqualTypeOf<unknown>();
       expect.fail('Type guard failed unexpectedly');
     }
   });
+
+  test('returns false for non function', () => {
+    expect(rttc.isFunctionOfLength(0, 1)).toEqual(false);
+  });
 });
 
 describe(rttc.assertFunctionOfLength, () => {
@@ -422,6 +439,32 @@ describe(rttc.isTupleOfLength, () => {
     const tup: unknown = [0, 0];
     expect(rttc.isTupleOfLength(tup, 1)).toEqual(false);
   });
+
+  test('with predicate type guard', () => {
+    const tup: unknown = [0, 0];
+    if (rttc.isTupleOfLength(tup, 2, x => typeof x === 'number')) {
+      expectTypeOf(tup).toEqualTypeOf<[number, number]>();
+    } else {
+      expect.fail();
+    }
+  });
+
+  test('with string type guard', () => {
+    const tup: unknown = [0, 0];
+    if (rttc.isTupleOfLength(tup, 2, 'number')) {
+      expectTypeOf(tup).toEqualTypeOf<[number, number]>();
+    } else {
+      expect.fail();
+    }
+  });
+});
+
+describe(rttc.assertTupleOfLength, () => {
+  test('throws correct error', () => {
+    expect(() => rttc.assertTupleOfLength(0, 1, 'foo')).toThrow(
+      'foo: Expected tuple of length 0, got 0.',
+    );
+  });
 });
 
 describe(rttc.isNumberWithinRange, () => {
@@ -521,7 +564,7 @@ describe(rttc.isNumberWithinRange, () => {
 describe(rttc.assertNumberWithinRange, () => {
   test('throws InvalidNumberParameterError', () => {
     expect(() => rttc.assertNumberWithinRange(0, 'foo', 1)).toThrow(
-      'foo: Expected integer greater than 1, got 0.',
+      'foo: Expected integer ≥ 1, got 0.',
     );
   });
 });
diff --git a/src/utils/__tests__/typeUtils.test.ts b/src/utils/__tests__/typeUtils.test.ts
new file mode 100644
index 000000000..874b6f70c
--- /dev/null
+++ b/src/utils/__tests__/typeUtils.test.ts
@@ -0,0 +1,89 @@
+import { describe, expectTypeOf, test } from 'vitest';
+import type * as types from '../typeUtils';
+
+describe('HasCorrectParamters', () => {
+  type NullaryFunc = () => void;
+  type BinaryFunc = (arg0: number, arg1: string) => number;
+  type OneDefFunc = (arg0: number, arg1?: string) => number;
+  type TwoDefFunc = (arg0: number, arg1?: string, arg2?: string) => number;
+  type OnlyRestArgs = (...arg1: string[]) => number;
+  type RestArgs = (arg0: number, ...arg1: string[]) => number;
+  type RestAndDefArgs = (arg0: number, arg1?: boolean, ...arg2: string[]) => number;
+
+  test('Nullary func', () => {
+    type TestType1 = types.HasCorrectParameters<NullaryFunc, 0>;
+    expectTypeOf<TestType1>().toEqualTypeOf<NullaryFunc>();
+
+    type TestType2 = types.HasCorrectParameters<NullaryFunc, 1>;
+    expectTypeOf<TestType2>().toEqualTypeOf<never>();
+
+    type TestType3 = types.HasCorrectParameters<NullaryFunc, true>;
+    expectTypeOf<TestType3>().toEqualTypeOf<never>();
+  });
+
+  test('Binary func', () => {
+    type TestType1 = types.HasCorrectParameters<BinaryFunc, 0>;
+    expectTypeOf<TestType1>().toEqualTypeOf<BinaryFunc>();
+
+    type TestType2 = types.HasCorrectParameters<BinaryFunc, 2>;
+    expectTypeOf<TestType2>().toEqualTypeOf<never>();
+
+    type TestType3 = types.HasCorrectParameters<BinaryFunc, true>;
+    expectTypeOf<TestType3>().toEqualTypeOf<never>();
+  });
+
+  test('Function with one default', () => {
+    type TestType1 = types.HasCorrectParameters<OneDefFunc, 0>;
+    expectTypeOf<TestType1>().toEqualTypeOf<never>();
+
+    type TestType2 = types.HasCorrectParameters<OneDefFunc, 1>;
+    expectTypeOf<TestType2>().toEqualTypeOf<OneDefFunc>();
+
+    type TestType3 = types.HasCorrectParameters<OneDefFunc, 2>;
+    expectTypeOf<TestType3>().toEqualTypeOf<never>();
+
+    type TestType4 = types.HasCorrectParameters<OneDefFunc, true>;
+    expectTypeOf<TestType4>().toEqualTypeOf<never>();
+  });
+
+  test('Function with two defaults', () => {
+    type TestType1 = types.HasCorrectParameters<TwoDefFunc, 0>;
+    expectTypeOf<TestType1>().toEqualTypeOf<never>();
+
+    type TestType2 = types.HasCorrectParameters<TwoDefFunc, 1>;
+    expectTypeOf<TestType2>().toEqualTypeOf<never>();
+
+    type TestType3 = types.HasCorrectParameters<TwoDefFunc, 2>;
+    expectTypeOf<TestType3>().toEqualTypeOf<TwoDefFunc>();
+
+    type TestType4 = types.HasCorrectParameters<TwoDefFunc, true>;
+    expectTypeOf<TestType4>().toEqualTypeOf<never>();
+  });
+
+  test('Function with only rest parameter', () => {
+    type TestType1 = types.HasCorrectParameters<OnlyRestArgs, 0>;
+    expectTypeOf<TestType1>().toEqualTypeOf<never>();
+
+    type TestType2 = types.HasCorrectParameters<OnlyRestArgs, true>;
+    expectTypeOf<TestType2>().toEqualTypeOf<OnlyRestArgs>();
+  });
+
+  test('Function with rest parameter and 1 arg', () => {
+    type TestType1 = types.HasCorrectParameters<RestArgs, 0>;
+    expectTypeOf<TestType1>().toEqualTypeOf<never>();
+
+    type TestType2 = types.HasCorrectParameters<RestArgs, true>;
+    expectTypeOf<TestType2>().toEqualTypeOf<RestArgs>();
+  });
+
+  test('Function with rest parameter, 1 default arg and 1 arg', () => {
+    type TestType1 = types.HasCorrectParameters<RestAndDefArgs, 0>;
+    expectTypeOf<TestType1>().toEqualTypeOf<never>();
+
+    type TestType2 = types.HasCorrectParameters<RestAndDefArgs, true>;
+    expectTypeOf<TestType2>().toEqualTypeOf<RestAndDefArgs>();
+
+    type TestType3 = types.HasCorrectParameters<RestAndDefArgs, 1>;
+    expectTypeOf<TestType3>().toEqualTypeOf<never>();
+  });
+});
diff --git a/src/utils/ast/__tests__/helpers.test.ts b/src/utils/ast/__tests__/helpers.test.ts
index dc8a689b4..4db5a5d8e 100644
--- a/src/utils/ast/__tests__/helpers.test.ts
+++ b/src/utils/ast/__tests__/helpers.test.ts
@@ -29,13 +29,13 @@ describe(getSourceVariableDeclaration, () => {
   test('throws an error when given a declaration with multiple declarators', () => {
     expect(() =>
       getSourceVariableDeclaration(getAst('const x = 0, y = 0;') as VariableDeclaration),
-    ).toThrowError('Variable Declarations in Source should only have 1 declarator!');
+    ).toThrow('Variable Declarations in Source should only have 1 declarator!');
   });
 
   test('throws an error when given an uninitialized declaration', () => {
-    expect(() =>
-      getSourceVariableDeclaration(getAst('let x;') as VariableDeclaration),
-    ).toThrowError('Variable declarations in Source must be initialized!');
+    expect(() => getSourceVariableDeclaration(getAst('let x;') as VariableDeclaration)).toThrow(
+      'Variable declarations in Source must be initialized!',
+    );
   });
 });
 
diff --git a/src/utils/ast/helpers.ts b/src/utils/ast/helpers.ts
index 514f0d069..6d0ea932f 100644
--- a/src/utils/ast/helpers.ts
+++ b/src/utils/ast/helpers.ts
@@ -14,36 +14,36 @@ export function getModuleDeclarationSource(node: ModuleDeclarationWithSource): s
   return node.source.value;
 }
 
+export function extractIdsFromPattern(pattern: es.Pattern): es.Identifier[] {
+  switch (pattern.type) {
+    case 'ArrayPattern':
+      return pattern.elements.flatMap(extractIdsFromPattern);
+    case 'AssignmentPattern':
+      return extractIdsFromPattern(pattern.left);
+    case 'Identifier':
+      return [pattern];
+    case 'ObjectPattern':
+      return pattern.properties.flatMap(prop => {
+        if (prop.type === 'Property') {
+          return extractIdsFromPattern(prop.value);
+        }
+        return extractIdsFromPattern(prop);
+      });
+    case 'RestElement':
+      return extractIdsFromPattern(pattern.argument);
+    default:
+      throw new InternalRuntimeError(
+        `Should not encounter a ${pattern.type} in ${extractDeclarations.name}`,
+        pattern,
+      );
+  }
+}
+
 /**
  * Extracts all the identifiers being declared by a VariableDeclaration
  */
 export function extractDeclarations(decl: es.VariableDeclaration) {
-  function recurser(pattern: es.Pattern): es.Identifier[] {
-    switch (pattern.type) {
-      case 'ArrayPattern':
-        return pattern.elements.flatMap(recurser);
-      case 'AssignmentPattern':
-        return recurser(pattern.left);
-      case 'Identifier':
-        return [pattern];
-      case 'ObjectPattern':
-        return pattern.properties.flatMap(prop => {
-          if (prop.type === 'Property') {
-            return recurser(prop.value);
-          }
-          return recurser(prop);
-        });
-      case 'RestElement':
-        return recurser(pattern.argument);
-      default:
-        throw new InternalRuntimeError(
-          `Should not encounter a ${pattern.type} in ${extractDeclarations.name}`,
-          pattern,
-        );
-    }
-  }
-
-  return decl.declarations.flatMap(({ id }) => recurser(id));
+  return decl.declarations.flatMap(({ id }) => extractIdsFromPattern(id));
 }
 
 /**
diff --git a/src/utils/misc.ts b/src/utils/misc.ts
index d5dd09492..a508d6216 100644
--- a/src/utils/misc.ts
+++ b/src/utils/misc.ts
@@ -1,6 +1,6 @@
 import { TimeoutError } from '../errors/timeoutErrors';
 import type { Node } from '../types';
-import { Chapter, Variant } from '../langs';
+import { Chapter, type ChapterStrings, Variant } from '../langs';
 
 export class PromiseTimeoutError extends TimeoutError {
   public override explain() {
@@ -46,7 +46,7 @@ export function objectKeys<T extends string | number | symbol>(obj: Record<T, an
  * Given the chapter value, return the string name of that chapter
  */
 export function getChapterName(chapter: Chapter) {
-  return objectKeys(Chapter).find(name => Chapter[name] === chapter)!;
+  return Chapter[chapter] as ChapterStrings;
 }
 
 /**
diff --git a/src/utils/operators.ts b/src/utils/operators.ts
index 9114a3a20..1a0581dbc 100644
--- a/src/utils/operators.ts
+++ b/src/utils/operators.ts
@@ -1,10 +1,11 @@
-import type { BinaryOperator, UnaryOperator } from 'estree';
+import type { BinaryOperator, CallExpression, UnaryOperator } from 'estree';
 
 import {
   CallingNonFunctionValueError,
   ExceptionError,
   GetInheritedPropertyError,
-  InvalidNumberOfArgumentsError,
+  TooFewArgumentsError,
+  TooManyArgumentsError,
 } from '../errors/errors';
 import { RuntimeSourceError } from '../errors/base';
 import {
@@ -16,6 +17,8 @@ import type { NativeStorage } from '../types';
 import * as create from './ast/astCreator';
 import { callExpression, locationDummyNode } from './ast/astCreator';
 import * as rttc from './rttc';
+import { HasCorrectParameters } from './typeUtils';
+import assert from './assert';
 
 export function throwIfTimeout(
   nativeStorage: NativeStorage,
@@ -114,7 +117,7 @@ interface FunctionDetails {
    * was originally defined in
    */
   source: string | null;
-  minArgsNeeded?: number;
+  maxArgsAllowed: number | true;
 }
 
 const funcDetSymbol = Symbol();
@@ -125,11 +128,83 @@ function getFunctionDetails(f: Function): FunctionDetails {
   }
 
   return {
-    minArgsNeeded: f.length, // no way to check if the function hasVarArgs
+    maxArgsAllowed: f.length, // no way to check if the function hasVarArgs
     source: null,
   };
 }
 
+/**
+ * Check that the number of arguments provided falls within the range specified.
+ *
+ * You can call it with just a {@link CallExpression}, in which case its `callee` should be either a
+ * {@link FunctionExpression} or {@link ArrowFunctionExpression}.
+ *
+ * Otherwise, the node is just used for location information and you have to manually specify
+ * everything else.
+ *
+ * - If `maxArgs` is true, then there is no maximum number of arguments. Useful for functions
+ * with a rest parameter.
+ * - If `maxArgs` is a number, then that value is the maximum number of arguments.
+ * - If `maxArgs` is `undefined` or not provided, then the maximum number of arguments is assumed
+ * to be `minArgs`.
+ */
+export function validateFunctionArgCount(exp: CallExpression): void;
+export function validateFunctionArgCount(
+  exp: CallExpression,
+  received: number,
+  minArgs: number,
+  maxArgs?: number | true,
+  funcName?: string,
+): void;
+export function validateFunctionArgCount(
+  exp: CallExpression,
+  received?: number,
+  rawMinArgs?: number,
+  rawMaxArgs?: number | true,
+  funcName?: string,
+) {
+  let minArgs: number;
+  let maxArgs: number | true;
+
+  if (received === undefined) {
+    assert(
+      exp.callee.type === 'ArrowFunctionExpression' || exp.callee.type === 'FunctionExpression',
+      `${validateFunctionArgCount.name}: When called with CallExpression only, callee must be a function node`,
+    );
+
+    const func = exp.callee;
+    received = exp.arguments.length;
+    minArgs = func.params.filter(
+      x => x.type !== 'AssignmentPattern' && x.type !== 'RestElement',
+    ).length;
+    maxArgs =
+      (func.params.length > 0 && func.params[func.params.length - 1].type === 'RestElement') ||
+      func.params.length;
+  } else {
+    minArgs = rawMinArgs!;
+    maxArgs = rawMaxArgs ?? rawMinArgs!;
+  }
+
+  assert(
+    typeof maxArgs !== 'number' || maxArgs >= minArgs,
+    `MaxArgs was a number (${maxArgs}) but less than MinArgs = ${minArgs}`,
+  );
+
+  if (received < minArgs) {
+    throw new TooFewArgumentsError(
+      exp,
+      received,
+      minArgs,
+      maxArgs === true || maxArgs !== minArgs,
+      funcName,
+    );
+  }
+
+  if (maxArgs !== true && received > maxArgs) {
+    throw new TooManyArgumentsError(exp, received, maxArgs, maxArgs !== minArgs, funcName);
+  }
+}
+
 /**
  * Calls the provided value as if it were a function being called from the `line` and `column`
  * within the provided `source` file, checking for argument count.
@@ -161,9 +236,8 @@ export function callIfFuncAndRightArgs(
       );
     }
 
-    const expectedLength = f.length;
     const receivedLength = args.length;
-    const { minArgsNeeded, source: funcSource } = getFunctionDetails(f);
+    const { maxArgsAllowed, source: funcSource } = getFunctionDetails(f);
 
     if (funcSource === 'prelude') {
       // Once we call into a prelude function, everything that follows
@@ -171,20 +245,17 @@ export function callIfFuncAndRightArgs(
       isPrelude = true;
     }
 
-    const hasVarArgs = minArgsNeeded !== undefined;
-    if (hasVarArgs ? minArgsNeeded > receivedLength : expectedLength !== receivedLength) {
-      throw new InvalidNumberOfArgumentsError(
-        callExpression(dummy, args, {
-          start: { line, column },
-          end: { line, column },
-          source,
-        }),
-        hasVarArgs ? minArgsNeeded : expectedLength,
-        receivedLength,
-        f.name,
-        hasVarArgs,
-      );
-    }
+    validateFunctionArgCount(
+      callExpression(dummy, args, {
+        start: { line, column },
+        end: { line, column },
+        source,
+      }),
+      receivedLength,
+      f.length,
+      maxArgsAllowed,
+      f.name,
+    );
 
     let res;
     try {
@@ -240,49 +311,84 @@ export function callIfFuncAndRightArgs(
   }
 }
 
+/**
+ * Convenience wrapper for {@link callIfFuncAndRightArgs} that doesn't require any
+ * extra metadata to be passed into the function.
+ */
+export function callWithoutMetadata<T extends (...args: any[]) => any>(
+  f: T,
+  ...args: Parameters<T>
+): ReturnType<T> {
+  return callIfFuncAndRightArgs(f, -1, -1, null, undefined, ...args);
+}
+
 /**
  * Augment the given function with the necessary information for it to be called
  * properly by {@link callIfFuncAndRightArgs}. It won't redefine any existing details
  * that the function has already been wrapped with.
  *
- * - `hasVarArgs`
- *   - If `hasVarArgs` is `false` or `undefined`, then `f` is assumed not to have variadic args.
- *   - If `hasVarArgs` is `true`, `minArgsNeeded` is inferred from `f.length`.
- *   - If `hasVarArgs` is a number, it is used for `minArgsNeeded`.
+ * @example
+ * ```ts
+ * export const wrapped = wrap((...args: any[]) => args.length, true, 'wrapped');
+ * ```
+ *
+ * - `optArgCount`: Represents the number of optional arguments the function has
+ *   - If set to `undefined`, it will be assumed to be 0
+ *   - If set to a number, that will be taken to be the number of optional arguments
+ *   - If set to `true`, the function is assumed to have a rest argument
  *
  * - If `stringified` is `undefined`, the function won't try to define `toReplString`.
  * - `funcName`
  *   - If `funcName` is `undefined`, the function won't try to define the `name` property.
  *   - If `funcName` is provided, the `name` property will get overriden.
  */
+export function wrap<T extends (...args: any[]) => any, OptArgs extends number>(
+  f: HasCorrectParameters<T, OptArgs>,
+  optArgCount: OptArgs,
+  funcName?: string,
+  stringified?: string,
+  source?: string | null,
+): T;
 export function wrap<T extends (...args: any[]) => any>(
-  f: T,
-  hasVarArgs: boolean | undefined | number,
+  f: HasCorrectParameters<T, true>,
+  optArgCount: true,
+  funcName?: string,
   stringified?: string,
-  source: string | null = null,
+  source?: string | null,
+): T;
+export function wrap<T extends (...args: any[]) => any>(
+  f: HasCorrectParameters<T, 0>,
+  optArgCount?: undefined,
   funcName?: string,
-): T {
-  let minArgsNeeded: number | undefined;
-  if (hasVarArgs === true) {
-    minArgsNeeded = f.length;
-  } else if (typeof hasVarArgs === 'number') {
-    minArgsNeeded = hasVarArgs;
-  }
-
+  stringified?: string,
+  source?: string | null,
+): T;
+export function wrap(
+  f: (...args: any[]) => any,
+  optArgCount?: number | true,
+  funcName?: string,
+  stringified?: string,
+  source: string | null = null,
+) {
   if (funcName !== undefined) {
     Object.defineProperty(f, 'name', { value: funcName });
   }
 
+  const maxArgsAllowed =
+    optArgCount === true ? true : optArgCount === undefined ? f.length : f.length + optArgCount;
+
   if (!(funcDetSymbol in f)) {
-    (f as any)[funcDetSymbol] = {
-      minArgsNeeded,
+    const details: FunctionDetails = {
+      maxArgsAllowed,
       source,
     };
+
+    (f as any)[funcDetSymbol] = details;
   } else {
     const funcDets = getFunctionDetails(f);
 
-    if (typeof funcDets.minArgsNeeded !== 'number') {
-      funcDets.minArgsNeeded = minArgsNeeded;
+    if (typeof funcDets.maxArgsAllowed !== 'number' && funcDets.maxArgsAllowed !== true) {
+      funcDets.maxArgsAllowed = maxArgsAllowed;
     }
 
     if (typeof funcDets.source !== 'string') {
@@ -298,6 +404,21 @@ export function wrap<T extends (...args: any[]) => any>(
   return f;
 }
 
+/**
+ * A type-agnostic version of {@link wrap} to make it easier
+ * when the function type is not known.
+ */
+export function wrapUnsafe<T extends (...args: any[]) => any>(
+  f: T,
+  optArgCount?: number | true,
+  funcName?: string,
+  stringified?: string,
+  source?: string | null,
+) {
+  // @ts-expect-error Ignore type safety
+  return wrap(f, optArgCount, funcName, stringified, source);
+}
+
 export function setProp(
   obj: any,
   prop: any,
diff --git a/src/utils/rttc.ts b/src/utils/rttc.ts
index 4c975a765..9ffc3ca86 100644
--- a/src/utils/rttc.ts
+++ b/src/utils/rttc.ts
@@ -8,6 +8,7 @@ import {
 import { RuntimeSourceError } from '../errors/base';
 import { Chapter } from '../langs';
 import type { Node, Value } from '../types';
+import { TupleOfLength } from './typeUtils';
 
 const LHS = ' on left hand side of operation';
 const RHS = ' on right hand side of operation';
@@ -37,21 +38,43 @@ export class RuntimeTypeError extends RuntimeSourceError<Node> {
 
 type TypeOfConstants =
   | 'array'
-  | 'boolean'
   | 'bigint'
+  | 'boolean'
   | 'function'
-  | 'number'
   | 'null'
+  | 'number'
   | 'object'
   | 'regexp'
   | 'string'
   | 'undefined';
 
+export type TypeOfConstantToType<T extends TypeOfConstants> = T extends 'array'
+  ? unknown[]
+  : T extends 'bigint'
+    ? bigint
+    : T extends 'boolean'
+      ? boolean
+      : T extends 'function'
+        ? (...args: any[]) => any
+        : T extends 'null'
+          ? null
+          : T extends 'number'
+            ? number
+            : T extends 'object'
+              ? object
+              : T extends 'regexp'
+                ? RegExp
+                : T extends 'string'
+                  ? string
+                  : T extends 'undefined'
+                    ? undefined
+                    : never;
+
 /**
  * A wrapper around the typeof operator to account for `null` and arrays.
  */
-export function typeOf(v: boolean): 'boolean';
 export function typeOf(v: bigint): 'bigint';
+export function typeOf(v: boolean): 'boolean';
 export function typeOf(v: number): 'number';
 export function typeOf(v: RegExp): 'regexp';
 export function typeOf(v: string): 'string';
@@ -282,14 +305,9 @@ export function checkArray(
   }
 }
 
-type TupleOfLengthHelper<T extends number, U, V extends U[] = []> = V['length'] extends T
-  ? V
-  : TupleOfLengthHelper<T, U, [...V, U]>;
-
-/**
- * Utility type that represents a tuple of a specific length
- */
-export type TupleOfLength<T extends number, U = unknown> = TupleOfLengthHelper<T, U>;
+// TODO: Should it be the "proper" signature?
+// type FunctionOfLength<T extends number> = (...args: [...TupleOfLength<T>, ...unknown[]]) => unknown;
+type FunctionOfLength<T extends number> = (...args: TupleOfLength<T>) => unknown;
 
 /**
  * Type guard for checking that the provided value is a function and that it has the specified number of parameters.
@@ -299,10 +317,7 @@ export function isFunctionOfLength<T extends (...args: any[]) => any>(
   f: (...args: any) => any,
   l: Parameters<T>['length'],
 ): f is T;
-export function isFunctionOfLength<T extends number>(
-  f: unknown,
-  l: T,
-): f is (...args: TupleOfLength<T>) => unknown;
+export function isFunctionOfLength<T extends number>(f: unknown, l: T): f is FunctionOfLength<T>;
 export function isFunctionOfLength(f: unknown, l: number) {
   // TODO: Need a variation for rest parameters
   return typeof f === 'function' && f.length === l;
@@ -330,7 +345,7 @@ export function assertFunctionOfLength<T extends number>(
   func_name: string,
   type_name?: string,
   param_name?: string,
-): asserts f is (...args: TupleOfLength<T>) => unknown;
+): asserts f is FunctionOfLength<T>;
 export function assertFunctionOfLength(
   f: unknown,
   l: number,
@@ -344,13 +359,33 @@ export function assertFunctionOfLength(
 }
 
 /**
- * Function for checking if the given `obj` is a tuple of the given length.
+ * Function for checking if the given `obj` is a tuple of the given length. Optionally, providing a type guard
+ * function or string can type check the entire tuple.
  */
 export function isTupleOfLength<T extends number, U>(obj: U[], l: T): obj is TupleOfLength<T, U>;
+export function isTupleOfLength<T extends number, U>(
+  obj: unknown,
+  l: T,
+  guard: (arg: unknown) => arg is U,
+): obj is TupleOfLength<T, U>;
+export function isTupleOfLength<T extends number, U extends TypeOfConstants>(
+  obj: unknown,
+  l: T,
+  guard: U,
+): obj is TupleOfLength<T, TypeOfConstantToType<U>>;
 export function isTupleOfLength<T extends number>(obj: unknown, l: T): obj is TupleOfLength<T>;
-export function isTupleOfLength<T extends number>(obj: unknown, l: T): obj is TupleOfLength<T> {
+export function isTupleOfLength<T extends number>(
+  obj: unknown,
+  l: T,
+  guard?: ((arg: unknown) => boolean) | TypeOfConstants,
+): boolean {
   if (!Array.isArray(obj)) return false;
-  return obj.length === l;
+  if (obj.length !== l) return false;
+
+  if (typeof guard === 'string') return obj.every(each => typeOf(each) === guard);
+  else if (guard !== undefined) return obj.every(guard);
+
+  return true;
 }
 
 /**
diff --git a/src/utils/stringify.ts b/src/utils/stringify.ts
index ba9994f7c..2a21ea26e 100644
--- a/src/utils/stringify.ts
+++ b/src/utils/stringify.ts
@@ -2,7 +2,7 @@ import { MAX_LIST_DISPLAY_LENGTH } from '../constants';
 import Closure from '../cse-machine/closure';
 import { InternalRuntimeError } from '../errors/base';
 import type { Type, Value } from '../types';
-import { callIfFuncAndRightArgs } from './operators';
+import { callWithoutMetadata } from './operators';
 
 export interface ArrayLike {
   replPrefix: string;
@@ -437,7 +437,7 @@ export function valueToStringDag(value: Value): StringDag {
       // callIfFuncAndRight args is necessary because if we implement toReplString as a function
       // in Source, it gets wrapped by the transpiler
       // this allows object literals to implement toReplString
-      const reprValue = callIfFuncAndRightArgs(v.toReplString.bind(v), -1, -1, null, undefined);
+      const reprValue = callWithoutMetadata(v.toReplString.bind(v));
       return convertRepr(reprValue);
     } else if (typeof v !== 'object') {
       return convertRepr(v.toString());
diff --git a/src/utils/testing/__tests__/testing.test.ts b/src/utils/testing/__tests__/testing.test.ts
index f982ab78c..fd88929e5 100644
--- a/src/utils/testing/__tests__/testing.test.ts
+++ b/src/utils/testing/__tests__/testing.test.ts
@@ -150,17 +150,15 @@ describe('Extra test results', () => {
       context: { visualiseListResult },
     } = await testSuccess(`draw_data(list(1, 2));`, Chapter.SOURCE_2);
     expect(visualiseListResult).toMatchInlineSnapshot(`
-Array [
-  Array [
-    Array [
-      1,
       Array [
-        2,
-        null,
-      ],
-    ],
-  ],
-]
-`);
+        Array [
+          1,
+          Array [
+            2,
+            null,
+          ],
+        ],
+      ]
+    `);
   });
 });
diff --git a/src/utils/testing/index.ts b/src/utils/testing/index.ts
index eece4fb78..33a1d7bf8 100644
--- a/src/utils/testing/index.ts
+++ b/src/utils/testing/index.ts
@@ -3,7 +3,7 @@ import { parseError, runInContext } from '../..';
 import createContext, { defineBuiltin } from '../../createContext';
 import { Chapter } from '../../langs';
 import type { CustomBuiltIns } from '../../types';
-import { assertIsFinished, processTestOptions } from './misc';
+import { processTestOptions } from './misc';
 import { mockContext } from './mocks';
 import type { TestContext, TestOptions, TestResults } from './types';
 
@@ -90,6 +90,7 @@ export async function testInContext(code: string, rawOptions: TestOptions) {
   const context = createTestContext(options);
   const result = await runInContext(code, context);
   return {
+    verboseErrors: options.verboseErrors,
     context,
     result,
   };
@@ -101,11 +102,12 @@ export async function testInContext(code: string, rawOptions: TestOptions) {
  */
 export async function testSuccess(code: string, options: TestOptions = {}) {
   const { context, result } = await testInContext(code, options);
-  if (result.status !== 'finished') {
-    console.log(context.errors);
+  if (result.status === 'error') {
+    expect.fail(parseError(context.errors));
+  } else if (result.status === 'suspended-cse-eval') {
+    expect.fail('Program was suspended');
   }
 
-  assertIsFinished(result);
   return {
     context,
     result,
@@ -119,7 +121,7 @@ export async function testSuccess(code: string, options: TestOptions = {}) {
 export async function testFailure(code: string, options: TestOptions = {}) {
   const res = await testInContext(code, options);
   expect(res.result.status).toEqual('error');
-  return parseError(res.context.errors);
+  return parseError(res.context.errors, res.verboseErrors);
 }
 
 /**
@@ -130,12 +132,7 @@ export const expectFinishedResult = vi.defineHelper(
   (code: string, options: TestOptions = {}): RemoveMatcher<Promisify<Assertion<Promise<any>>>> => {
     return removeMatcher(
       expect(
-        testInContext(code, options).then(({ result, context }) => {
-          if (result.status === 'error') {
-            const errStr = parseError(context.errors);
-            console.log(errStr);
-          }
-          assertIsFinished(result);
+        testSuccess(code, options).then(({ result }) => {
           return result.value;
         }),
       ).resolves,
@@ -150,16 +147,8 @@ export const expectFinishedResult = vi.defineHelper(
 export const expectParsedError = (
   code: string,
   options: TestOptions = {},
-  verbose?: boolean,
 ): RemoveMatcher<Promisify<Assertion<Promise<string>>>> => {
-  return removeMatcher(
-    expect(
-      testInContext(code, options).then(({ result, context }) => {
-        expect(result.status).toEqual('error');
-        return parseError(context.errors, verbose);
-      }),
-    ).resolves,
-  );
+  return removeMatcher(expect(testFailure(code, options)).resolves);
 };
 
 export const expectNativeToTimeoutAndError = vi.defineHelper(
diff --git a/src/utils/testing/mocks.ts b/src/utils/testing/mocks.ts
index 3687cf45b..6b0d40758 100644
--- a/src/utils/testing/mocks.ts
+++ b/src/utils/testing/mocks.ts
@@ -26,6 +26,7 @@ export function mockImportDeclaration(): es.ImportDeclaration {
         },
       },
     ],
+    attributes: [],
     source: {
       type: 'Literal',
       value: 'mock-path',
diff --git a/src/utils/testing/types.ts b/src/utils/testing/types.ts
index 76cc22a58..7f645824b 100644
--- a/src/utils/testing/types.ts
+++ b/src/utils/testing/types.ts
@@ -8,6 +8,7 @@ export type TestOptions =
       variant?: Variant;
       testBuiltins?: TestBuiltins;
       languageOptions?: LanguageOptions;
+      verboseErrors?: boolean;
     }
   | Chapter;
 
diff --git a/src/utils/typeUtils.ts b/src/utils/typeUtils.ts
new file mode 100644
index 000000000..a79f7033f
--- /dev/null
+++ b/src/utils/typeUtils.ts
@@ -0,0 +1,63 @@
+type TupleOfLengthHelper<T extends number, U, V extends U[] = []> = V['length'] extends T
+  ? V
+  : TupleOfLengthHelper<T, U, [...V, U]>;
+
+/**
+ * Utility type that represents a tuple of a specific length
+ */
+export type TupleOfLength<T extends number, U = unknown> = TupleOfLengthHelper<T, U>;
+
+/**
+ * Given the number of required and optional elements, evaluates to true if the specified tuple
+ * indeed has the specified number of elements, false otherwise.
+ */
+type CheckTupleHelper<
+  T extends any[],
+  OptArgs extends number,
+  OptionalElements extends any[],
+> = T extends []
+  ? OptionalElements['length'] extends OptArgs
+    ? true
+    : false
+  : Partial<T> extends T
+    ? CheckTupleHelper<[], OptArgs, Required<T>>
+    : T extends [any, ...infer Rest]
+      ? CheckTupleHelper<Rest, OptArgs, []>
+      : never;
+
+/**
+ * Given the number of required and optional
+ * parameters, determine if the provided function
+ * type has the correct signature
+ */
+export type HasCorrectParameters<
+  T extends (...args: any[]) => any,
+  OptArgs extends number | true,
+> = OptArgs extends number
+  ? number extends Parameters<T>['length']
+    ? never
+    : CheckTupleHelper<Parameters<T>, OptArgs, []> extends true
+      ? T
+      : never
+  : number extends Parameters<T>['length']
+    ? T
+    : never;
+
+/**
+ * Helper type to recursively make properties that are also objects
+ * partial
+ *
+ * By default, `Partial<Array<T>>` is equivalent to `Array<T | undefined>`. For this type, `Array<T>` will be
+ * transformed to Array<Partial<T>> instead
+ */
+export type RecursivePartial<T> =
+  T extends Array<any>
+    ? Array<RecursivePartial<T[number]>>
+    : // to records?
+      T extends (...args: any[]) => any
+      ? T
+      : T extends Record<any, any>
+        ? Partial<{
+            [K in keyof T]: RecursivePartial<T[K]>;
+          }>
+        : T;
diff --git a/src/validator/validator.ts b/src/validator/validator.ts
index bc7db602b..b44a4f4c4 100644
--- a/src/validator/validator.ts
+++ b/src/validator/validator.ts
@@ -4,7 +4,7 @@ import { ConstAssignmentError, UndefinedVariableError } from '../errors/errors';
 import { NoAssignmentToForVariableError } from '../errors/validityErrors';
 import { parse } from '../parser/parser';
 import type { Context, Node, NodeWithInferredType } from '../types';
-import { getSourceVariableDeclaration } from '../utils/ast/helpers';
+import { extractIdsFromPattern, getSourceVariableDeclaration } from '../utils/ast/helpers';
 import { ancestor, base, type FullWalkerCallback } from '../utils/ast/walkers';
 import {
   getFunctionDeclarationNamesInProgram,
@@ -207,13 +207,7 @@ export function checkForUndefinedVariables(
   ) {
     identifiersIntroducedByNode.set(
       node,
-      new Set(
-        node.params.map(id =>
-          id.type === 'Identifier'
-            ? id.name
-            : ((id as es.RestElement).argument as es.Identifier).name,
-        ),
-      ),
+      new Set(node.params.flatMap(each => extractIdsFromPattern(each).map(({ name }) => name))),
     );
   }
   const identifiersToAncestors = new Map<es.Identifier, es.Node[]>();