The provided material is a technical specification for C*, a systems programming language designed to bridge the gap between C and Zig in terms of semantics, while utilizing syntax inspired by Rust.

Analyze and Adopt

• Domain: Programming Language Design and Systems Architecture.
• Persona: Senior Language Designer and Compiler Architect.
• Tone: Technical, objective, and analytically dense.

Abstract

The C* Language Reference Manual defines a general-purpose systems language targeting the performance and explicitness of C with the expressive power of higher-level constructs. C* utilizes manual memory management and an LLVM backend to ensure zero-cost abstractions, avoiding the implicit overhead associated with garbage collection or complex runtime environments. The language is characterized by an expression-oriented design, a robust type system (including slices and fat pointers), and a monadic error-handling model using Option and Result types. Key architectural features include destructive move semantics (via memcpy), monomorphized generics, and a unique postfix-heavy syntax designed to enhance IDE autocompletion and developer flow. The document concludes with a roadmap detailing current implementation restrictions, such as limited UTF-8 support and the temporary omission of certain "syntactic sugar" features like tuples and if/else (initially handled via match).

Summary of the C Language Reference Manual*

• [Overview] Language Positioning: C* sits semantically between C and Zig, providing a "zero-cost" abstraction layer. It aims for C-level speed and simplicity while incorporating Rust-like syntax for safety and expressiveness.
• [A C Program] Module System:* Programs are composed of modules where every file is implicitly a module. Top-level items include use, let, fn, struct, enum, union, and impl blocks. Publicity is private by default (pub(self)).
• [Comments] Structural Comments (/-): In addition to standard single-line and nested multi-line comments, C* introduces structural comments that allow developers to comment out the next item in the Abstract Syntax Tree (AST), regardless of its length or complexity.
• [Type System] Primitive and Compound Types:
  • Primitives: Includes unit (), bool (defined as an enum), fixed-width integers (up to u128/i128), floats, and 32-bit char (Unicode scalar values).
  • Reference Types: Supports immutable (&) and mutable (&mut) references; null references are impossible by design (requiring Option<T&> instead).
  • Slices and Fat Pointers: Slices (T[]) are unsized types consisting of a length and a pointer. References to slices are "fat pointers."
• [Destructive Moves] Move Semantics: Passing variables is performed via destructive moves (a simple memcpy). The language lacks move constructors; explicit cloning is required for @impl(Clone) types, while Copy types (primitives) remain implicit.
• [Literals] Numeric and String Literals:
  • Numbers: Supports multiple bases (binary, octal, hex) and scientific notation, with explicit bit-size suffixes (e.g., u32, f64, usize).
  • Strings: Includes UTF-8 String (borrowed), StringBuf (owned/growable), b"byte strings", c"C-strings" (null-terminated), and f"format strings" (non-allocating interpolation via anonymous structs).
• [Control Flow] Expression-Oriented Logic: Nearly all constructs, including blocks and loops, are expressions.
  • Pattern Matching: Uses match for exhaustive destructuring of integers, enums, pointers, and slices.
  • Sugar: if and else are treated as syntactic sugar for match expressions.
• [impl Blocks] Methods and Associated Items: Methods are defined in impl blocks. The first parameter is typically self: Self or self: *Self. C* requires explicit referencing (.& or .&mut) for method calls to ensure mutability and cost transparency.
• [Error Handling] Monadic Model: Errors are handled via Option<T> and Result<T, E>.
  • Try Operator (.?): Used within try blocks to bubble up errors.
  • Panicking: Unrecoverable errors call .unwrap(), leading to a program abort without stack unwinding or execution of defer blocks.
• [Defer and Undefer] Resource Management: defer schedules a statement to run upon block exit. undefer allows for the conditional cancellation of a labeled defer statement, useful in multi-step resource initialization.
• [Roadmap] Implementation Restrictions: Current versions are restricted to x86_64-linux-gnu, lack full UTF-8 source support, and temporarily omit features like tuples, unions, and defer (which are slated for later implementation).