TEMP_JS Programming Language

The Story of TEMP_JS

TEMP_JS was born out of a desire to help developers focus purely on logic in programming and worry less about superficial rules. It is a statically-typed, transpiled language that embraces simplicity using intelligent type inference to give you the safety of a compiled language with the lightweight feel of a scripting language, combining aspects of famous languages like Python, Rust, JavaScript, and more.

The core philosophy behind TEMP_JS is safety through minimalism. We ditched semicolons and made variables immutable by default to prevent accidental state changes, requiring an explicit mut keyword to allow reassignment. Whether you are iterating through arrays or evaluating complex logical expressions, the language gets out of your way and catches your logical errors at compile-time.

TEMP_JS serves as a complete showcase of modern compiler architecture. Through semantic analysis and constant-folding optimization down to its final JavaScript code generation, everything is designed to make the programmer feel at ease with their work.

Language Features

Core Type System

num: Support for both integers and floating-point numbers.
str: Standard string literals defined by double quotes ("...").
bool: Boolean logic using true and false.
array: Typed array literals (e.g., [1, 2, 3]).
Enums: User-defined types for categorical data.

Variables & State

let x = 5: Creates an immutable binding; the value cannot be changed.
mut x = 5: Creates a mutable binding. The variable is type-locked upon initialization but allows reassignment.
x = 5: Reassigns a value to an existing mut variable.
a[0] = 99: Performs index assignment (supported for mut arrays only).

Expressions & Operators

Arithmetic: +, -, *, /, %, and ** (exponentiation).
Comparison: ==, !=, <, <=, >, >=.
Logical: && (AND), || (OR), ! (NOT).
F-strings: Powerful template literals using f"hello {name}" syntax.
Accessors: Array indexing via a[i] and enum member access via Color.Red.

Control Flow

Branching: if / else blocks for conditional logic.
Iteration: while loops for condition-based entry and for...in loops for array traversal.
Pattern Matching: The match statement provides robust branching with mandatory exhaustiveness checking.
Jump Statements: break to exit loops and return (with or without a value) for functions.

Safety & Optimization

Static Analysis: Enforces scope isolation, detects undeclared variables, and ensures type consistency.
Match Exhaustiveness: Ensures all possible cases are covered (booleans, enums, or wildcards for nums/strs).
Optimizer: Includes constant folding, dead code elimination, and strength reduction (e.g., simplifying x * 1 to x).

Static Semantics & Language Constraints

TEMP_JS features a custom static analyzer that enforces type safety, immutability, and safe control flow before your code ever runs. Below are the rules and constraints enforced by the compiler.

Variables and Mutability

Declaration Required: All variables must be declared using let or mut before they are accessed or modified.
Immutability by Default: Variables declared with let are strictly immutable. They cannot be reassigned, modified via compound assignments (+=, -=), incremented/decremented (++, --), or have their array indices modified.
Loop Variables: The iteration variable introduced in a for ... in loop is implicitly treated as an immutable let binding within the loop body.

Type System

Strong Type Inference: Variable types are inferred from their initial assignment. Any subsequent assignments (for mut variables) must perfectly match the initially inferred type.
Math Operations: The -, *, /, // (floor division), %, and ** operators strictly require numeric (num) operands. The + operator requires either both num or both string (str) operands. Unary - requires a num operand.
Compound Assignments: -= requires num operands. += requires both operands to match and must be either num or str.
Comparisons: Relational operators (<, <=, >, >=) require numeric operands. Equality operators (==, !=) require both operands to be of the exact same type.
Booleans: if statements, while loops, unary !, and binary logical operators (&&, ||) strictly require boolean (bool) expressions.

Functions

Valid Invocation: Function calls must reference a previously declared function or a built-in (range, floor_div).
Strict Arity: The number of arguments passed to a function must exactly match the function's declared parameter count.
Return Consistency: A function's return type is inferred from the first evaluated return statement. All subsequent return statements in that same function must yield values of the identical inferred type.
Scope Limits: The return keyword is strictly prohibited outside of a function body.

Arrays and Iteration

Strict Indexing: Bracket notation (array[index]) can only be used on variables of type array. Furthermore, the index expression must evaluate to a num.
Iterable Loops: The iterable expression in a for ... in loop must evaluate to an array.
Control Flow: The break statement is only permitted inside the boundaries of a loop body.

Enums and Pattern Matching

Enum Resolution: Enums must be declared before use. Any member access (e.g., MyEnum. Variant) must reference a valid variant defined inside that specific enum block.
Exhaustive Matching: All match expressions must be exhaustive to guarantee safe execution. Booleans must match true and false. Numbers and strings strictly require a wildcard arm. Enums must explicitly cover every declared variant or provide a wildcard.
Pattern Safety: A match arm's pattern type must explicitly match the type of the expression being evaluated. Duplicate patterns are not allowed.
Wildcard Rules: If a wildcard pattern (_) is used, it must appear as the very last arm in the match block.

Reserved Keywords

You cannot use the following reserved language keywords as variable or function identifiers:

fn, let, mut, if, else, while, for, in, return, break, print, true, false, match, enum

Example Programs

Here are five complete programs covering every syntactic form in TEMP_JS. Try running them or modifying the code!

1. Enums and Pattern Matching

This example demonstrates how to define Enums and use the Match statement to handle data variants. It showcases how TEMP_JS ensures exhaustiveness—meaning you must account for every possible enum variant or boolean state.

enum Direction { North South East West }

enum Season { Spring Summer Fall Winter }

fn describe_direction(d) {
    match d {
        Direction.North => { return "Heading north" }
        Direction.South => { return "Heading south" }
        Direction.East  => { return "Heading east" }
        Direction.West  => { return "Heading west" }
    }
}

fn is_warm(s) {
    match s {
        Season.Spring => { return true }
        Season.Summer => { return true }
        Season.Fall   => { return false }
        Season.Winter => { return false }
    }
}

fn main() {
    let d = Direction.North
    print(describe_direction(d))

    let dirs = [Direction.North, Direction.South, Direction.East, Direction.West]
    for dir in dirs {
        print(describe_direction(dir))
    }

    let s = Season.Summer
    let warm = is_warm(s)
    match warm {
        true  => { print("Warm season") }
        false => { print("Cold season") }
    }
}

2. Functions and String Interpolation

Here you can see Function declarations in action, along with f-strings (formatted strings). This example also highlights how scoping works within if/else branches and how the compiler handles mathematical expressions within print statements.

fn greet(name) {
  return f"Hello, {name}!"
}

fn describe_score(score) {
  let grade = "unknown"
  if score >= 90 {
    let grade = "A"
    print(f"Score: {score} — Grade: {grade}")
  } else {
    if score >= 80 {
      let grade = "B"
      print(f"Score: {score} — Grade: {grade}")
    } else {
      print(f"Score: {score} — Grade: {grade}")
    }
  }
}

fn main() {
  let name = "Alice"
  let msg = greet(name)
  print(msg)

  let x = 7
  let y = 3
  print(f"{x} + {y} = {x + y}")
  print(f"{x} * {y} = {x * y}")

  describe_score(95)
  describe_score(82)
  describe_score(70)
}

3. Conditionals and While Loops

This program utilizes a while loop and mutable variables to iterate through a sequence. It combines these with a match statement to transform raw numbers into descriptive strings, demonstrating how the language handles logic flow and state changes.

fn day_name(n) {
    match n {
        1 => { return "Monday" }
        2 => { return "Tuesday" }
        3 => { return "Wednesday" }
        4 => { return "Thursday" }
        5 => { return "Friday" }
        6 => { return "Saturday" }
        7 => { return "Sunday" }
        _ => { return "Unknown" }
    }
}

fn is_weekend(n) {
    match n {
        6 => { return true }
        7 => { return true }
        _ => { return false }
    }
}

fn day_type(weekend) {
    match weekend {
        true => { return "Weekend" }
        false => { return "Weekday" }
    }
}

fn main() {
    mut day = 1
    while day <= 7 {
        let name = day_name(day)
        let weekend = is_weekend(day)
        let kind = day_type(weekend)
        print(name)
        print(kind)
        day = day + 1
    }
}

4. Ranges and For-In Loops

This example showcases the built-in range() function. It demonstrates the three ways to call range (single argument, start/stop, and start/stop/step) and how to use the for-in loop to iterate through these sequences efficiently.

fn sum_range(n) {
  mut total = 0
  for i in range(n) {
    total += i
  }
  return total
}

fn main() {
  # range(stop) — 0 up to stop
  for x in range(5) {
    print(x)
  }

  # range(start, stop)
  for x in range(10, 15) {
    print(x)
  }

  # range(start, stop, step)
  for x in range(0, 20, 4) {
    print(x)
  }

  let s = sum_range(10)
  print(f"Sum 0..9 = {s}")
}

5. Arrays and Mutability

The "Kitchen Sink" example focuses on Array manipulation. It shows how to pass arrays to functions, iterate over them, and perform index assignment on mut arrays. It serves as a practical look at how TEMP_JS handles collections and data mutability.

fn sum(nums) {
    mut total = 0
    for n in nums {
        total = total + n
    }
    return total
}

fn main() {
    let nums = [1, 2, 3, 4, 5]
    let result = sum(nums)
    print(result)

    mut scores = [10, 20, 30]
    scores[0] = 99
    print(scores[0])

    for x in [10, 20, 30] {
        print(x)
    }
}

6. Structs and Field Access

This example introduces structs, TEMP_JS's named record type. It shows how to declare a structs, create both immutable and mutable instances, read fields with dot notation, mutate fields on mut variables, pass structs into functions, and store them in arrays.

    struct Point { x y }

    struct Rectangle { width height }

    fn area(r) {
        return r.width * r.height
    }

    fn perimeter(r) {
        return 2 * r.width + 2 * r.height
    }

    fn distance_sq(p) {
        return p.x * p.x + p.y * p.y
    }

fn main() {
    let p = Point { x: 3, y: 4 }
    print(f"Point: ({p.x}, {p.y})")
    print(f"Distance squared from origin: {distance_sq(p)}")

    mut q = Point { x: 0, y: 0 }
    q.x = 6
    q.y = 8
    print(f"Moved point: ({q.x}, {q.y})")
    print(f"Distance squared from origin: {distance_sq(q)}")

    let r = Rectangle { width: 5, height: 3 }
    print(f"Rectangle: {r.width}x{r.height}")
    print(f"Area: {area(r)}")
    print(f"Perimeter: {perimeter(r)}")

    let points = [Point { x: 1, y: 2 }, Point { x: 3, y: 4 }, Point { x: 5, y: 6 }]
    for pt in points {
        print(f"({pt.x}, {pt.y})")
    }
}

7. Interfaces and Method Calls

This example demonstrates interfaces and impl blocks. An interface declares the method signatures a type must provide; the impl block attaches those methods to a struct, with self referring to the instance.

interface Describable {
    fn describe()
}

struct Circle { radius }
struct Rect { width height }

impl Circle for Describable {
    fn describe() {
        return f"Circle with radius {self.radius}"
    }
}

impl Rect for Describable {
    fn describe() {
        return f"Rect {self.width}x{self.height}"
    }
}

fn main() {
    let c = Circle { radius: 5 }
    let r = Rect { width: 4, height: 6 }
    print(c.describe())
    print(r.describe())

    let shapes = [Circle { radius: 1 }, Circle { radius: 3 }, Circle { radius: 7 }]
    for s in shapes {
        print(s.describe())
    }
}

The Creators

Quinn Austin

Focused on the semantic analyzer and type inference engine, along with the JavaScript backend. Quinn built out the core logic that makes TEMP_JS safe and reliable.

Colin Bajo-Smith

Worked on Ohm grammar design, custom AST generation pipeline, and the webpage/embedded compiler. Colin ensured the syntax remained clean and minimalist.

Max Lehmann

Created constant folding and JavaScript code generation. Max designed and implemented everything relating to the test suites and code flow.