A language for systems developers

linear struct WriteTxn {
    wal_slot: u64
}
impl WriteTxn {
    fn commit(sink self) -> u64 {
        let WriteTxn { wal_slot } = self;
        wal_slot
    }
    fn abort(sink self) {
        let WriteTxn { wal_slot } = self;
    }
}
fn main() -> u64 {
    let tx = WriteTxn { wal_slot: 42 };
    tx.commit()
}

copy struct Broker {
    index: u64,
    metrics: u64,
    config: u64
}
// A checked failure may not abort across an inout parameter, so these
// counters are explicitly modular.
fn append(inout broker.{index, metrics}: Broker, in config: u64) {
    broker.index = wrapping_add(broker.index, config);
    broker.metrics = wrapping_add(broker.metrics, 1);
}
fn main() -> u64 {
    let broker = Broker {
        index: 1,
        metrics: 0,
        config: 41
    };
    append(inout broker, in broker.config);
    broker.index
}

fn divide(divisor: i64) -> i64 eff [Fail[RuntimeError]] {
    84 / divisor
}
fn main() -> i64 {
    handle Fail[RuntimeError] in {
        divide(0)
    } with {
        return value => value,
        raise(error, _) => match error {
            RuntimeError::DivisionByZero => 42,
            RuntimeError::IndexOutOfBounds => 0,
        },
    }
}