Appendix A: Language Reference

Quick Reference

This appendix is your cheat sheet. When you forget syntax or need to look up a feature quickly, start here.

Keywords

fn          Function definition
struct      Structure definition
enum        Enumeration definition
type        Type alias
var         Mutable variable
const       Immutable variable
if          Conditional
else        Alternative branch
match       Pattern matching
while       Loop
for         Loop
break       Exit loop
continue    Skip iteration
return      Return from function
import      Import module
pub         Public visibility
spawn       Concurrent task
channel     Communication channel
some        Option variant
none        Option variant
ok          Result variant
err         Result variant

Operators

Arithmetic

+    Addition
-    Subtraction
*    Multiplication
/    Division
%    Modulo (remainder)

Comparison

==   Equal
!=   Not equal
<    Less than
<=   Less than or equal
>    Greater than
>=   Greater than or equal

Logical

and   Logical AND
or    Logical OR
not   Logical NOT

Other

=    Assignment
.    Member access
::   Static access
?    Error propagation
[]   Indexing

Types

Primitive Types

int      64-bit integer
float    64-bit floating point
string   UTF-8 string
bool     Boolean (true/false)

Compound Types

[T]              Array of T
HashMap<K, V>    Hash map from K to V
Option<T>        Optional value (concrete: OptionInt, int?, ...)
ResultInt        Result-or-error (also ResultString, ResultFloat, ResultBool)

Type Syntax

var x: int = 42              // Explicit type
var y = 42                   // Inferred type
const PI: float = 3.14159    // Constant with type

Variables

Declaration

var mutable = 10        // Mutable
const immutable = 20    // Immutable

Scope

{
    var inner = 10      // Scoped to block
}
// inner not accessible here

Shadowing

var x = 5
var x = x + 1          // Shadows previous x
var x = "hello"        // Can change type

Functions

Definition

fn function_name(param1: Type1, param2: Type2) -> ReturnType {
    // body
    return value
}

Examples

fn add(a: int, b: int) -> int {
    return a + b
}

fn greet(name: string) -> int {
    print("Hello, " + name)
    return 0
}

Generic Functions

fn identity<T>(x: T) -> T {
    return x
}

fn swap<T>(a: T, b: T) -> (T, T) {
    return (b, a)
}

Structs

Definition

struct StructName {
    field1: Type1,
    field2: Type2
}

Creation

var instance = StructName {
    field1: value1,
    field2: value2
}

Methods

fn StructName.method_name(self) -> ReturnType {
    return self.field1
}

Generic Structs

struct Container<T> {
    value: T
}

Enums

Definition

enum EnumName {
    VARIANT1,
    VARIANT2,
    VARIANT3
}

to_string

enum Color { Red, Green, Blue }
Color.Red.to_string()    // "Red"
var c = Color.Blue
c.to_string()            // "Blue"

With Data

enum Result<T, E> {
    ok(T),
    err(E)
}

enum Option<T> {
    some(T),
    none
}

Control Flow

If Statement

if (condition) {
    // true branch
} else if (other_condition) {
    // else if branch
} else {
    // else branch
}

While Loop

while (condition) {
    // body
}

For Loop

for (var i = 0; i < 10; i = i + 1) {
    // body
}

For-in Loop

for item in array { }
for i in 0..10 { }
for i, v in array { }   // indexed iteration

Match Expression

match value {
    pattern1 => action1,
    pattern2 => action2,
    _ => default_action
}

Pattern Matching

Literals

match x {
    0 => "zero",
    1 => "one",
    _ => "other"
}

Enums

match result {
    ok(value) => use_value(value),
    err(message) => handle_error(message)
}

Ranges and Or-Patterns

match n {
    1 | 3 | 5 => "odd",
    1..5 => "small (exclusive end)",
    1..=5 => "small (inclusive end)",
    _ => "other"
}

Guards

match n {
    _ if n < 0 => "negative",
    0 => "zero",
    _ => "positive"
}

Collections

Arrays

var arr = [1, 2, 3, 4, 5]
arr[0]              // Access
arr.len()           // Length
arr.push(6)         // Append
arr.contains(3)     // Check membership

HashMaps

var map = {"key1": 1, "key2": 2}
map["key1"]         // Access
map["key3"] = 3     // Insert
map.has("key1")     // Check key
map.remove("key2")  // Remove
map.len()           // Size

HashSets

var set = {:"a", "b", "c"}
set.contains("a")   // Check membership
set.insert("d")     // Add
set.remove("b")     // Remove
set.len()           // Size

Error Handling

Result Type

fn operation() -> Result<int, string> {
    if (error_condition) {
        return Err("error message")
    }
    return Ok(42)
}

Option Type

fn find(arr: [int], target: int) -> Option<int> {
    // ...
    if (found) {
        return some(index)
    }
    return none
}

Error Propagation

fn chain() -> Result<int, string> {
    var x = operation1()?
    var y = operation2(x)?
    return Ok(y)
}

Modules

Import

import module_name
import path.to.module
import module as alias

Export

pub fn public_function() -> int {
    return 0
}

fn private_function() -> int {
    return 0
}

Extension Methods

Definition

fn TypeName.method_name(self) -> ReturnType {
    return self.field
}

Static Methods

fn TypeName.static_method() -> ReturnType {
    return value
}

Concurrency

Spawn

spawn function_call()           // fire and forget
var f = spawn function_call()   // keep a handle
var result = await f            // wait for the result

Channels

var ch = channel(4)    // capacity 4
ch.send(42)
var value = ch.recv()
ch.close()

Type Aliases

type UserId = int
type Email = string

Comments

// Single-line comment

// Multi-line comments use
// multiple single-line comments

String Escapes

"\n"    Newline
"\t"    Tab
"\\"    Backslash
"\""    Quote

Operator Precedence

From highest to lowest:

1. Method call (.), indexing ([])
2. Unary (not, -)
3. Multiplication (*, /, %)
4. Addition (+, -)
5. Comparison (<, <=, >, >=)
6. Equality (==, !=)
7. Logical AND (and)
8. Logical OR (or)
9. Assignment (=)

Use parentheses to override precedence.

Common Patterns

Error Handling

match result {
    ok(value) => use_value(value),
    err(msg) => handle_error(msg)
}

Option Handling

match option {
    some(value) => use_value(value),
    none => use_default()
}

Iteration

for (var i = 0; i < arr.len(); i = i + 1) {
    process(arr[i])
}

Method Chaining

var result = text.trim().upper().reverse()

Naming Conventions

snake_case          Variables, functions
SCREAMING_SNAKE     Constants
PascalCase          Types (structs, enums)

File Extensions

.wyn    Wyn source file

Compilation

wyn run program.wyn          # Compile and run
wyn build program.wyn        # Build a binary
./program                    # Run it
wyn help                     # Help

Common Mistakes

Forgetting Return Type

// Wrong
fn add(a: int, b: int) {
    return a + b
}

// Right
fn add(a: int, b: int) -> int {
    return a + b
}

Parentheses in Conditions Are Optional

// Both are fine
if x > 0 { }
if (x > 0) { }

Ignoring Result/Option

// Wrong
var value = option  // Option<T>, not T

// Right
match option {
    some(value) => use_value(value),
    none => handle_none()
}

Forgetting pub

// Wrong (if you want it public)
fn helper() -> int { }

// Right
pub fn helper() -> int { }

Quick Examples

Hello World

fn main() -> int {
    print("Hello, World!")
    return 0
}

Read File

fn read_file(path: string) -> ResultString {
    if not File.exists(path) {
        return Err("file not found: " + path)
    }
    return Ok(File.read(path))
}

fn main() -> int {
    var result = read_file("data.txt")
    match result {
        ok(contents) => print(contents),
        err(msg) => print("Error: " + msg)
    }
    return 0
}

HTTP Request

fn main() -> int {
    var result = Http.get("https://api.example.com/data")
    match result {
        ok(response) => print(response.body),
        err(msg) => print("Error: " + msg)
    }
    return 0
}

Concurrent Tasks

fn producer(ch: int) -> int {
    Task.send(ch, 42)
    return 0
}

fn main() -> int {
    var ch = channel(4)
    var f = spawn producer(ch)

    var value = ch.recv()
    print(value)

    await f
    return 0
}

---

This reference covers the essential syntax and patterns. For detailed explanations, see the main chapters. For complete API documentation, see Appendix B.