Implementation Status

Aria v0.1 is under active development. The compiler is self-hosting (written in Aria) and can compile its own source code. This page tracks what's implemented vs. planned.

Fully Implemented

Core Language

  • Basic types: i64, f64, bool, str, char, arrays, maps
  • Hex (0xFF), octal (0o77), binary (0b1010) literals with underscore separators
  • Immutable bindings with :=, mutable with mut, constants with const
  • Mutability enforcement (E0500 error on immutable reassignment)
  • Functions with generics and trait bounds (including multi-bounds like T: Eq + Hash)
  • Single-expression functions (fn f(x: i64) -> i64 = x * 2)
  • Closures with capture semantics
  • String interpolation and string methods
  • Pipeline operator (|>)
  • Compound assignment (+=, -=, *=, /=, %=)
  • defer (up to 4 per function)
  • For/while/loop with break/continue
  • If/else if/else as expressions

Type System

  • Structs and sum types with all variant kinds (tag-only, tuple, struct)
  • Type aliases (alias Name = Type)
  • Exhaustive pattern matching (E0400 for missing variants)
  • Or-patterns (A | B =>), named patterns (name @ Pattern)
  • Array/slice patterns ([first, ..rest]), tuple patterns, float patterns
  • Refutable bindings (Pattern := expr else { })
  • Guards in match arms
  • Result types (Ok/Err) with ?, !, and catch
  • Optional types (Some/None) with ?? and ?.
  • dyn Trait with vtable dispatch
  • Supertraits (trait B: A)
  • Associated types in traits
  • Convert/TryConvert traits (.to[T](), .trunc[T](), T(x) widening)
  • derives codegen with actual method bodies (Eq, Clone, Debug)
  • Struct ==/!= field-by-field comparison
  • Float Eq/Hash prohibition
  • where clauses with multi-bound checking

Resource Management

  • Drop trait with per-scope LIFO destruction
  • with resource blocks (RAII)
  • Send/Share marker traits auto-derived for primitives

Effects & Visibility

  • Effect system enforcement (warnings for impure calls from pure functions)
  • pub visibility enforcement (E0704 for private access across files)
  • Import aliases (use mod as alias)

Concurrency

  • spawn with .await()
  • Channels (send/recv)
  • Mutexes

Standard Library

  • TCP networking
  • PostgreSQL support
  • HTTP server
  • JSON library (encode/decode)
  • File I/O

Compiler Infrastructure

  • Multi-file compilation with directory expansion
  • Self-hosting (compiler compiles itself)
  • Native ARM64 Mach-O output (macOS)
  • LLVM IR generation (cross-platform via Clang)
  • JSON diagnostic output (--format=json)
  • Test blocks with test runner

Planned for v0.1 (Not Yet Implemented)

Concurrency

  • Structured scope { } blocks
  • select expression
  • spawn.detach, cancellation tokens
  • Directional channels, channel iteration
  • RWMutex, Atomic, WaitGroup, Once, Barrier

Strings & Literals

  • Raw strings (r"..."), triple-quoted strings
  • Duration literals (30s, 5ms), size literals (512kb)
  • Format specifiers ({val:.4})
  • StringBuilder
  • .chars(), .charCount(), .graphemes()

Error Handling

  • Error traces with TraceFrame
  • Error transformation (? |e| transform)
  • Typed catch arms
  • Error union in signatures (! E1 | E2)

Memory Management

  • Garbage collector (currently malloc-only)
  • @stack, @arena, @inline annotations
  • Pool[T]
  • Use-after-move analysis

Compiler Tooling

  • aria fix, aria explain commands
  • "Did you mean?" suggestions
  • DWARF debug info
  • Cross-compilation
  • Benchmark blocks, property-based testing

Deferred to v0.2+

  • Blanket implementations
  • Generic traits (trait Container[T])
  • Conditional impls (impl[T: Eq] Eq for Stack[T])
  • Phantom types
  • Default method bodies in traits
  • Partial application
  • FFI (extern "C" fn)
  • Annotations (@deprecated, @cold)
  • Compile-time functions (comptime fn)
  • Const generics
  • LSP server
  • PGO / LTO optimizations