septima-lang 0.1.0 → 0.2.0

package/README.md

@@ -0,0 +1,435 @@
+# Septima: An Overview
+
+Septima is a programming language that closely follows JavaScript, not just in syntax but also in behavior. If you're familiar with JavaScript, you'll feel right at home with Septima's objects, arrays, functions, and built-in methods. However, Septima makes some deliberate departures from JavaScript to promote cleaner, more predictable code:
+
+- It is immutable - variables cannot be reassigned after definition
+- Side effect free - a computation is only affected by its inputs. The only "trace" that a computation leaves is the value that it computed.
+- All expressions, including `if...else`, return values
+- There are no `null` values - only `undefined`
+- There's no automatic type coercion
+- No global scope or `var` keyword - only lexical block scoping with `let`
+- No classes or prototypes - You can create objects using JavaScript's standard object notation (`{a: 'foo'}`).
+
+## Why Septima?
+
+Septima excels in scenarios where you need to safely execute user-provided code within your application, particularly in backend systems. Common use cases include:
+
+- **Configuration as Code**: Allow users to write complex configuration logic using a familiar JavaScript-like syntax instead of being limited to static JSON or YAML files
+- **Business Rules Engines**: Enable domain experts to define and maintain business rules in a familiar syntax without risking system stability
+- **ETL Transformations**: Let users write data transformation logic that can safely process data without accessing external systems
+- **Plugin Systems**: Implement extensible architectures where third-party code can be safely executed in a controlled environment
+- **Customizable Workflows**: Allow users to define custom workflow logic while ensuring system security
+
+Key benefits that make Septima ideal for these scenarios:
+
+1. **Secured**:
+
+   - No file system or network access
+   - No `eval()` or dynamic code execution
+   - No access to system resources
+
+2. **Reliable**:
+
+   - Functional programming paradigm (no loops) makes code more robust
+   - Immutability and lack of side effects make code easier to reason about
+   - No type coercion reduces unexpected behavior
+   - Modules allow you to organize and manage large Septima codebases
+
+3. **Friendly**:
+   - JavaScript-like syntax reduces learning curve
+   - Highly compatible with JavaScript - code ports easily in both directions
+
+Unlike alternatives such as JavaScript's `vm` module or `eval()`, Septima provides a secure environment for running user-provided code without sacrificing expressiveness or ease of use. It strikes a balance between power and safety that makes it particularly well-suited for enterprise applications where reliability and security are paramount.
+
+## Table of Contents
+
+- [Language Fundamentals](#language-fundamentals)
+  - [Numbers and Arithmetic](#numbers-and-arithmetic)
+  - [Booleans and Logic](#booleans-and-logic)
+  - [Control Flow and Expressions](#control-flow-and-expressions)
+  - [Variables and Immutability](#variables-and-immutability)
+  - [Arrays and Objects](#arrays-and-objects)
+  - [Conversions](#conversions)
+- [Coding in Septima](#coding-in-septima)
+  - [Functions](#functions)
+  - [Extended Operators](#extended-operators)
+  - [Built-in Methods](#built-in-methods)
+  - [Console Output](#console-output-for-debugging)
+  - [Modules](#modules)
+  - [Error Handling](#error-handling)
+
+## Language Fundamentals
+
+Like JavaScript, Septima works with familiar data types like numbers, strings, and booleans. However, its treatment of these types is more strict and predictable than JavaScript's loose type handling.
+
+### Numbers and Arithmetic
+
+Numbers in Septima work similarly to JavaScript, but without the quirks. There's no automatic type coercion in arithmetic operations.
+
+```javascript
+// Similar to JavaScript
+5 // Integer literal
+3.14 // Floating point literal
+8 * 2 // Multiplication
+3 + 1 // Addition
+
+// Different from JavaScript - no type coercion
+'5' + 3 // Error: Cannot add string and number
+5 + '3' // Error: Cannot add number and string
+```
+
+### Booleans and Logic
+
+Boolean operations in Septima are similar to JavaScript but stricter. They only work with actual boolean values.
+
+```javascript
+// Similar to JavaScript
+true || false // Logical OR
+true && false // Logical AND
+
+// Different from JavaScript - no truthy/falsy values
+1 && 2 // Error: Expected boolean values
+'' || 'default' // Error: Expected boolean values
+```
+
+### Control Flow and Expressions
+
+Unlike JavaScript, all control structures in Septima are expressions that return values.
+
+```javascript
+// Different from JavaScript - if expressions return values
+let result = if (4 > 3) 200 else -100  // Valid in Septima
+
+// Different from JavaScript - no if statements without else
+if (x > 0) doSomething()  // Error in Septima - must have else
+
+// Ternary operator works the same as JavaScript
+let result = (4 > 3) ? 200 : -100
+```
+
+### Variables and Immutability
+
+One of the biggest differences from JavaScript is Septima's immutability. Variables cannot be reassigned after definition.
+
+```javascript
+// Similar to JavaScript - initial definition
+let x = 5
+
+// Different from JavaScript - no reassignment
+x = 6 // Error: Cannot reassign variables
+
+// Different from JavaScript - no var or const
+var y = 10 // Error: var is not supported
+const z = 15 // Error: const is not supported
+```
+
+### Arrays and Objects
+
+Arrays and objects in Septima are immutable by default, unlike their mutable JavaScript counterparts.
+
+```javascript
+// Similar to JavaScript - creation and access
+let arr = [1, 2, 3]
+arr[0] // Returns 1
+
+// Different from JavaScript - no mutation methods
+arr.push(4) // Error: Arrays are immutable
+arr[0] = 2 // Error: Arrays are immutable
+
+// Object behavior
+let obj = { a: 1, b: 2 }
+obj.a // Returns 1
+
+// Different from JavaScript - no mutation
+obj.c = 3 // Error: Objects are immutable
+obj.a = 2 // Error: Objects are immutable
+```
+
+### Conversions
+
+Unlike JavaScript's automatic type coercion, Septima requires explicit conversion between different types. It provides three conversion functions that closely mirror their JavaScript counterparts in behavior.
+
+The `String` function converts any value to its string representation:
+
+```javascript
+String(42) // "42"
+String(3.14) // "3.14"
+String(true) // "true"
+String(undefined) // "undefined"
+```
+
+For objects and arrays, `String` produces a JSON representation of its argument:
+
+```javascript
+String({ a: 1 }) // "{"a":1}"
+String([1, 2]) // "[1,2]"
+```
+
+The `Boolean` function implements standard truthiness rules, converting values to `true` or `false`:
+
+```javascript
+Boolean(42) // true
+Boolean(0) // false
+Boolean('hello') // true
+Boolean('') // false
+Boolean(undefined) // false
+Boolean({}) // true
+Boolean([]) // true
+```
+
+The `Number` function converts values to numbers where possible, returning `NaN` when conversion fails:
+
+```javascript
+Number('42') // 42
+Number('3.14') // 3.14
+Number('abc') // NaN
+Number(true) // 1
+Number(false) // 0
+Number(undefined) // NaN
+```
+
+Unlike JavaScript, Septima requires these explicit conversions and does not perform automatic type coercion:
+
+```javascript
+"42" + 7                  // Error: Cannot add string and number
+7 + "42"                  // Error: Cannot add number and string
+let x = if ("hello") 1 else -1 // Error: Condition must be boolean
+```
+
+## Coding in Septima
+
+### Functions
+
+Functions in Septima are similar to JavaScript arrow functions, but with some key differences in scope and purity.
+
+```javascript
+// Similar to JavaScript - arrow functions
+const double = x => x * 2
+
+// Different from JavaScript - no function declarations
+function double(x) {
+  return x * 2
+} // Error: Use arrow syntax
+
+// Different from JavaScript - pure functions
+let counter = 0
+let increment = () => counter++ // Error: Cannot modify external state
+
+// Different from JavaScript - no this binding
+let obj = {
+  name: 'test',
+  getName: function () {
+    return this.name
+  }, // Error: No this keyword
+}
+```
+
+### Extended Operators
+
+#### Spread Operator (...)
+
+The spread operator creates shallow copies of arrays and objects:
+
+```javascript
+// Objects
+let user = { name: 'Sam', id: 123 }
+let userWithRole = { ...user, role: 'admin' } // { name: 'Sam', id: 123, role: 'admin' }
+
+// Arrays
+let numbers = [1, 2, 3]
+let moreNumbers = [...numbers, 4, 5] // [1, 2, 3, 4, 5]
+```
+
+#### Nullish Coalescing (??)
+
+The nullish coalescing operator provides a way to handle undefined values:
+
+```javascript
+let config = {
+  port: undefined,
+  host: 'localhost',
+}
+
+let port = config.port ?? 8080 // Returns 8080 (fallback when undefined)
+let host = config.host ?? 'default' // Returns 'localhost' (keeps defined value)
+```
+
+Note: Unlike JavaScript, Septima doesn't have `null`, so the nullish coalescing operator only works with `undefined`.
+
+### Built-in Methods
+
+Septima provides common methods for working with arrays, strings, and objects. These methods follow JavaScript conventions while maintaining Septima's no-side-effects guarantee. As such, methods such as Array.push() are not supported.
+
+#### Modifying Arrays
+
+Instead of mutating methods like `push()` use the spread operator to create new arrays:
+
+```javascript
+let nums = [1, 2, 3]
+nums.push(4)       // Error: Array.push is not supported
+[...nums, 4]       // Returns [1, 2, 3, 4]
+```
+
+#### Array and String Methods
+
+Transform strings and arrays using familiar methods (non-exhaustive list):
+
+```javascript
+// String methods
+'hello'.toUpperCase() // Returns "HELLO"
+'hello_world'.split('_') // Returns ['hello', 'world']
+'  piano  '
+  .trim() // Returns "piano"
+
+  [
+    // Array methods
+    (1, 2, 3)
+  ].map(x => x * 2) // Returns [2, 4, 6]
+  [(19, 6, 8, 3, 10)].filter(x => x > 5) // Returns [19, 6, 8, 10]
+  [(1, 2, 3, 4)].reduce((a, b) => a + b, 0) // Returns 10
+```
+
+#### Object Methods
+
+Access and transform object properties and structure:
+
+```javascript
+let user = {
+  name: 'Sam',
+  role: 'admin',
+  active: true,
+}
+
+// Get object keys as array
+Object.keys(user) // Returns ['name', 'role', 'active']
+
+// Get key-value pairs as array
+Object.entries(user) // Returns [['name', 'Sam'], ['role', 'admin'], ['active', true]]
+
+// Create object from key-value pairs
+let pairs = [
+  ['name', 'Pat'],
+  ['role', 'user'],
+]
+Object.fromEntries(pairs) // Returns { name: 'Pat', role: 'user' }
+```
+
+#### Array.isArray()
+
+Checks whether the given input is an array:
+
+```javascript
+Array.isArray([1, 2, 3]) // Returns true
+Array.isArray('not array') // Returns false
+Array.isArray({ key: 'val' }) // Returns false
+```
+
+#### Cryptographic Hashing
+
+Septima provides a secure hashing function through the `crypto.hash224()` method, which computes SHA-224 hashes of any value. The method takes a single argument of any type and returns a hexadecimal string representing the hash.
+
+```javascript
+// Hash a simple string
+crypto.hash224('hello') // Returns a 56-character hex string
+
+// Hash numbers
+crypto.hash224(42) // Hashes the number 42
+
+// Hash complex objects
+crypto.hash224({ name: 'Alice', roles: ['admin', 'user'], settings: { theme: 'dark' } }) // Hashes the entire object structure
+
+// Hashes are deterministic but unique per input
+crypto.hash224('A') === crypto.hash224('A') // true (same input = same hash)
+crypto.hash224('A') !== crypto.hash224('B') // true (different input = different hash)
+```
+
+Note: Septima's `crypto` object is not intended to be compatible with Node.js's `crypto` module. It provides its own simplified cryptographic utilities specifically designed for Septima's use cases.
+
+### Console Output for Debugging
+
+Like JavaScript, Septima provides `console.log()` for debugging and monitoring your code. However, unlike JavaScript's `console.log()` which can take multiple arguments, Septima's version accepts only a single argument. In keeping with Septima's functional nature, `console.log()` returns its argument, making it useful within expressions.
+
+```javascript
+// Basic logging - single argument only
+console.log('Hello World') // Prints: Hello World
+
+// Different from JavaScript - can't log multiple values
+console.log('x', 42) // Error: Too many arguments
+
+// Logging within expressions works because console.log returns its argument
+let result = 5 * console.log(3) // Prints: 3, returns: 15
+
+// Logging with arrays and objects
+let arr = [1, 2, 3]
+console.log(arr) // Prints: [1, 2, 3]
+let obj = { a: 1, b: 2 }
+console.log(obj) // Prints: {"a":1,"b":2}
+
+// To log multiple values, you need to combine them first
+console.log([x, y, z]) // Use an array
+console.log({ x: x, y: y, z: z }) // Or an object
+console.log('x=' + x + ', y=' + y) // Or string concatenation
+```
+
+### Modules
+
+Septima provides a module system for organizing code across files, supporting exports and namespace imports.
+
+#### Exports
+
+Use the `export` keyword to expose values from a module:
+
+```javascript
+// utils.septima.js
+export let capitalize = str => str.charAt(0).toUpperCase() + str.slice(1)
+
+// config.septima.js
+export let timeoutInSeconds = 30
+export let retries = 3
+```
+
+Key points:
+
+- Only top-level definitions can be exported
+- Multiple exports per file are allowed
+- No default exports
+
+#### Imports
+
+Import using the namespace pattern:
+
+```javascript
+import * as utils from './utils.septima.js'
+import * as config from './config.septima.js'
+
+// Use imported values
+let result = utils.capitalize('hello')
+let timeoutInMillis = config.timeoutInSeconds * 1000
+```
+
+Key points:
+
+- Files must end with `.septima.js`
+- Only namespace imports (`* as`) supported
+- Imports must be at file top
+- Paths are relative to current file
+- No circular dependencies
+
+### Error Handling
+
+Unlike JavaScript's sometimes forgiving nature, Septima is strict about type checking and provides clear error messages. It doesn't do automatic type coercion or silent failures.
+
+```javascript
+// JavaScript allows this
+'5' + 3 // "53"
+
+// Septima throws an error
+'5' + 3 // Error: Cannot add string and number
+
+// JavaScript returns undefined
+let obj = {}
+obj.nonexistent.prop // TypeError: Cannot read property 'prop' of undefined
+
+// Septima provides better error message
+obj.nonexistent.prop // Error: Attempting to access property of undefined
+```

package/change-log.md

@@ -0,0 +1,57 @@
+### PR/153
+
+- allow semicolons before the expression: `;;; 4.8`
+- allow shorthand notation attributes in an object: `let n = 42; { n }`
+
+### PR/163
+
+- retire `sink` - it was too confusing + there are some things that undefined (in JS) can do but sink could not
+
+### PR/164
+
+- `undefined` is now a first class value: `let x = undefined`
+- `{a: undefined, n: 42}` is identical to `{n: 42}`
+- `undefined ?? 42` is `42`
+
+### PR/165
+
+- spreading `undefined` in an array is a no-op: `[42, ...undefined, 'poo']` is `[42, 'poo']`
+- spreading `undefined` in an object is a no-op: `{n: 42, ...undefined, p: 'poo'}` is `{n: 42, p: 'poo'}`
+- support `String(x)`, `Boolean(x)`, `Number(x)`
+
+### PR/168
+
+- support `Array.isArray(x)`
+- support `console.log('my message')`
+
+### PR/172
+
+- supoort `JSON.parse(s)`
+- supoort sorting an array: `[97, 100, 50].sort()`, `['the', 'quick', 'brown', 'fox'].sort((a, b) => a.length - b.length)`
+- fix object comparsion
+
+### PR/173
+
+- support block comments `4 + /* now five */ 5`
+- support default values for function args: `(a, b = 1000) => a + b`
+- inspect the runtime type of a value via `constructor.name`
+
+### PR/174
+
+- allow a dangling comma after last formal arg of an arrow function `(a,b,) => a + b`
+
+### PR/176
+
+- allow computing hash values: `crypto.hash224({a: 1, b: 2})`
+
+### PR/177
+
+- support throwing: `throw "boom"`
+
+### PR/182
+
+- support template literals: `` `name is ${x}` ``
+
+### PR/183
+
+- support `const` keyword (behaves like `let`): `const x = 5`

package/dist/tests/parser.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/parser.spec.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ast_node_1 = require("../src/ast-node");
+const parser_1 = require("../src/parser");
+const scanner_1 = require("../src/scanner");
+const source_code_1 = require("../src/source-code");
+function parse(arg) {
+    const parser = new parser_1.Parser(new scanner_1.Scanner(new source_code_1.SourceCode(arg, '<test-file>')));
+    const ast = parser.parse();
+    return ast;
+}
+describe('parser', () => {
+    test('show()', () => {
+        expect((0, ast_node_1.show)(parse(`5`))).toEqual('5');
+        expect((0, ast_node_1.show)(parse(`fun (x) x*9`))).toEqual('fun (x) (x * 9)');
+    });
+    test('syntax errors', () => {
+        expect(() => parse(`a + #$%x`)).toThrowError('Unparsable input at (<test-file>:1:5..8) #$%x');
+        expect(() => parse(`{#$%x: 8}`)).toThrowError('Expected an identifier at (<test-file>:1:2..9) #$%x: 8}');
+        expect(() => parse(`"foo" "goo"`)).toThrowError('Loitering input at (<test-file>:1:7..11) "goo"');
+    });
+    describe('unit', () => {
+        test('show', () => {
+            expect((0, ast_node_1.show)(parse(`import * as foo from './bar';'a'`))).toEqual(`import * as foo from './bar';\n'a'`);
+            expect((0, ast_node_1.show)(parse(`let f = x => x*x; f(2)`))).toEqual(`let f = fun (x) (x * x); f(2)`);
+            expect((0, ast_node_1.show)(parse(`let f = x => x*x; let g = n => n+1`))).toEqual(`let f = fun (x) (x * x); let g = fun (n) (n + 1);`);
+            expect((0, ast_node_1.show)(parse(`export let a = 1; let b = 2; export let c = 3;`))).toEqual(`export let a = 1; let b = 2; export let c = 3;`);
+        });
+        test('const keyword', () => {
+            expect((0, ast_node_1.show)(parse(`const x = 5; x`))).toEqual(`let x = 5; x`);
+            expect((0, ast_node_1.show)(parse(`const f = x => x*x; f(2)`))).toEqual(`let f = fun (x) (x * x); f(2)`);
+            expect((0, ast_node_1.show)(parse(`const a = 1; let b = 2; const c = 3`))).toEqual(`let a = 1; let b = 2; let c = 3;`);
+            expect((0, ast_node_1.show)(parse(`export const a = 1;`))).toEqual(`export let a = 1;`);
+        });
+    });
+    describe('expression', () => {
+        test('show', () => {
+            expect((0, ast_node_1.show)(parse(`'sunday'`))).toEqual(`'sunday'`);
+            expect((0, ast_node_1.show)(parse(`true`))).toEqual(`true`);
+            expect((0, ast_node_1.show)(parse(`500`))).toEqual(`500`);
+            expect((0, ast_node_1.show)(parse(`if (3+4 > 8) "above" else "below"`))).toEqual(`if (((3 + 4) > 8)) 'above' else 'below'`);
+            expect((0, ast_node_1.show)(parse(`(3+4 > 8) ? "above" : "below"`))).toEqual(`((3 + 4) > 8) ? 'above' : 'below'`);
+        });
+        test('can have an optional throw token', () => {
+            expect((0, ast_node_1.show)(parse(`throw 'sunday'`))).toEqual(`throw 'sunday'`);
+            expect((0, ast_node_1.show)(parse(`let a = 8;throw 'sunday'`))).toEqual(`let a = 8; throw 'sunday'`);
+            expect((0, ast_node_1.show)(parse(`{a: [45 + 8*3 > 2 + (throw 'err')]}`))).toEqual(`{a: [((45 + (8 * 3)) > (2 + throw 'err'))]}`);
+            expect((0, ast_node_1.show)(parse(`if (5 > 8) 'yes' else throw 'no'`))).toEqual(`if ((5 > 8)) 'yes' else throw 'no'`);
+            expect((0, ast_node_1.show)(parse(`let f = x >= 0 ? x : throw 'negative'`))).toEqual(`let f = (x >= 0) ? x : throw 'negative';`);
+        });
+    });
+    describe('lambda', () => {
+        test('show', () => {
+            expect((0, ast_node_1.show)(parse(`(a) => a*2`))).toEqual(`fun (a) (a * 2)`);
+            expect((0, ast_node_1.show)(parse(`(a, b = {x: 1, y: ['bee', 'camel']}) => a*2 + b.x`))).toEqual(`fun (a, b = {x: 1, y: ['bee', 'camel']}) ((a * 2) + b.x)`);
+        });
+    });
+    describe('template literal', () => {
+        test('show', () => {
+            expect((0, ast_node_1.show)(parse('`hello`'))).toEqual('`hello`');
+            expect((0, ast_node_1.show)(parse('`hello ${x} world`'))).toEqual('`hello ${x} world`');
+            expect((0, ast_node_1.show)(parse('`${a}${b}`'))).toEqual('`${a}${b}`');
+            expect((0, ast_node_1.show)(parse('`start ${x + y} end`'))).toEqual('`start ${(x + y)} end`');
+        });
+        test('span', () => {
+            expect((0, ast_node_1.span)(parse('`hello`'))).toEqual({ from: { offset: 0 }, to: { offset: 6 } });
+            expect((0, ast_node_1.span)(parse('`hi ${x} bye`'))).toEqual({ from: { offset: 0 }, to: { offset: 12 } });
+        });
+        test('unterminated template literal', () => {
+            expect(() => parse('`hello')).toThrowError('Unterminated template literal');
+            expect(() => parse('`hello ${x}')).toThrowError('Unterminated template literal');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tests/septima-compile.spec.d.ts

@@ -0,0 +1 @@
+export {};