Core Types

Option<T>

Generic optional value container. Represents a value that may or may not exist.

import core.option

Constructors

let some = Some(42)          // Option with value
let none = None<Int>()       // Empty option
let opt = Option<Int>.New()  // Empty option (alternative)

Methods

Example

fun findUser(id: Int) r: Option<String> {
    if id == 1 {
        return Some("Alice")
    }
    return None<String>()
}

fun main() {
    let user = findUser(1)
    if user.isSome() {
        println("Found: {user.unwrap()}")
    }
    let name = findUser(99).unwrapOr("Unknown")
}

Result<T, E>

Container for success/error values.

import core.result

Constructors

let ok = Ok<Int, String>(42)
let err = Err<Int, String>("not found")

Methods

The ? Operator

Propagates errors:

fun process() r: Result<Int, String> {
    let x = parse("42")?   // returns Err early if parse fails
    return Ok(x * 2)
}

Allocation Errors

memory/allocation defines the resource-safety side of Seen's memory model.

import memory.allocation

Types

Functions

Example

fun divide(a: Int, b: Int) r: Result<Int, String> {
    if b == 0 {
        return Err("division by zero")
    }
    return Ok(a / b)
}

fun main() {
    let result = divide(10, 3)
    if result.isOkay() {
        println("Result: {result.unwrap()}")
    } else {
        println("Error: {result.unwrapErr()}")
    }
}

Unit

The unit type, used as a placeholder when no value is needed:

import core.unit

let u = unit()

Useful as the value type in Result<Unit, E> or map types like HashMap<String, Unit> (set semantics).

Ordering

Comparison result type:

import core.ord

enum Ordering {
    Less
    Equal
    Greater
}

Functions

Type Conversion

import core.convert

core/convert defines conversion helpers and the Convertible class-style surface used by stdlib conversion code.

Int conversions

Float conversions

String conversions

Casting with as

let x: Int = 42
let f = x as Float     // 42.0
let s = x as String    // "42"

ToString Trait

@trait class ToString {
    fun toString() r: String
}

Free function converters:

• Int_toString(value: Int) r: String
• Float_toString(value: Float) r: String
• Bool_toString(value: Int) r: String
• Char_toString(value: Int) r: String

core/to_string also exposes FromString for parse-like conversions.

Prelude and Helpers

core/prelude contains common functions available to ordinary programs through the compiler/runtime prelude, including printing, assertions, and basic constructors.

Other core modules: