);
}
```
## JavaScript API
### `AilangREPL` Class
```javascript
const repl = new AilangREPL();
```
#### Methods
##### `init(wasmPath)`
Initialize the WASM module.
```javascript
await repl.init('/wasm/ailang.wasm');
```
**Parameters:**
- `wasmPath` (string): Path to `ailang.wasm` file
**Returns:** Promise that resolves when REPL is ready
##### `eval(input)`
Evaluate an AILANG expression.
```javascript
const result = repl.eval('1 + 2');
// Returns: "3 :: Int"
```
**Parameters:**
- `input` (string): AILANG code to evaluate
**Returns:** Result string (includes value and type)
##### `command(cmd)`
Execute a REPL command.
```javascript
const type = repl.command(':type \x. x');
// Returns: "\x. x :: a -> a"
```
**Parameters:**
- `cmd` (string): REPL command (e.g., `:type`, `:help`)
**Returns:** Command output string
##### `reset()`
Reset the REPL environment.
```javascript
repl.reset();
```
**Returns:** Status message
##### `onReady(callback)`
Register callback for when REPL is ready.
```javascript
repl.onReady(() => {
console.log('REPL initialized!');
});
```
##### `getVersion()`
Get version information.
```javascript
const version = repl.getVersion();
// Returns: "v0.7.2" (or null if not ready)
```
**Returns:** Version string or `null`
##### `getVersionInfo()`
Get detailed version information.
```javascript
const info = repl.getVersionInfo();
// Returns: { version: "v0.7.2", buildTime: "2026-02-06T...", platform: "js/wasm" }
```
**Returns:** Object with `version`, `buildTime`, `platform` fields, or `null`
##### `needsContinuation(line)`
Check if a line needs continuation (for multi-line input UIs).
```javascript
repl.needsContinuation('let x = 5 in'); // true
repl.needsContinuation('1 + 2'); // false
```
**Returns:** `boolean`
### Module Loading API (v0.7.1+)
The WASM REPL supports loading complete AILANG modules, enabling complex browser-based demos with multiple function definitions.
:::tip Why Module Loading?
The REPL evaluates expressions line-by-line, so function definitions like `let add = \x. \y. x + y` don't persist in scope for subsequent calls. The Module Loading API solves this by compiling entire modules and storing their exports for later use.
:::
##### `loadModule(name, code)`
Load an AILANG module into the registry.
```javascript
const result = repl.loadModule('math', `
let add: Int -> Int -> Int = \\x. \\y. x + y
let mul: Int -> Int -> Int = \\x. \\y. x * y
`);
if (result.success) {
console.log('Exports:', result.exports);
// Exports: ["add", "mul"]
} else {
console.error('Error:', result.error);
}
```
**Parameters:**
- `name` (string): Module name (e.g., `"math"`, `"invoice_processor"`)
- `code` (string): AILANG source code
**Returns:** Object with:
- `success` (boolean): Whether loading succeeded
- `exports` (string[]): List of exported function names (on success)
- `error` (string): Error message (on failure)
:::warning Type Annotations Required
For functions with numeric operations, you must include explicit type annotations:
```javascript
// ✅ Works
let add: Int -> Int -> Int = \\x. \\y. x + y
// ❌ Fails with "ambiguous type variable"
let add = \\x. \\y. x + y
```
:::
:::info Export Behavior (v0.7.1.2+)
Modules can use explicit exports or export all bindings:
**Explicit exports** (recommended for libraries):
```javascript
// Only public_func is exported, private_func is hidden
repl.loadModule('mylib', `
module mylib
export pure func public_func(x: int) -> int = x * 2
pure func private_func(x: int) -> int = x * 3
`);
// result.exports: ["public_func"]
```
**Implicit exports** (for REPL-style code):
```javascript
// All top-level bindings are exported
repl.loadModule('utils', `
let double: Int -> Int = \\x. x * 2
let triple: Int -> Int = \\x. x * 3
`);
// result.exports: ["double", "triple"]
```
:::
##### `listModules()` (v0.7.1+)
List all loaded modules.
```javascript
const modules = repl.listModules();
// Returns: ["math", "utils"]
```
**Returns:** Array of module names
##### `importModule(moduleName)` (v0.7.1+)
Import a module's exports into the REPL environment.
```javascript
repl.importModule('math');
// Now you can use: repl.eval('add(2)(3)')
```
**Parameters:**
- `moduleName` (string): Name of a loaded module
**Returns:** Import result message
##### `call(moduleName, funcName, ...args)`
Call a function from a loaded module. This is a convenience method that:
1. Looks up the function from the module registry
2. Converts JavaScript arguments to AILANG values
3. Invokes the function directly (no eval)
```javascript
// Load a module
repl.loadModule('math', `
let add: Int -> Int -> Int = \\x. \\y. x + y
let greet = \\name. "Hello, " <> name
`);
// Call functions
const sum = repl.call('math', 'add', 2, 3);
if (sum.success) {
console.log(sum.result); // "5 :: Int"
}
const greeting = repl.call('math', 'greet', 'World');
if (greeting.success) {
console.log(greeting.result); // "\"Hello, World\" :: String"
}
```
**Parameters:**
- `moduleName` (string): Module containing the function
- `funcName` (string): Function to call
- `...args` (any): Arguments (converted to AILANG values)
**Returns:** Object with:
- `success` (boolean): Whether the call succeeded
- `result` (string): Result with value and type (on success)
- `error` (string): Error message (on failure)
**Supported argument types:**
| JavaScript Type | AILANG Syntax |
|-----------------|---------------|
| `number` | `42` or `3.14` |
| `string` | `"text"` |
| `boolean` | `true` / `false` |
| `array` | `[1, 2, 3]` |
### Module Loading Example
Here's a complete example building an invoice processor demo:
```html
