Rust → zust

use std::boxed::Box;
fn main() {
    let b = Box::new(42);
    println!("{}", b);
} // dropped automatically

const safe = @import("safe");
fn foo(allocator: std.mem.Allocator) !void {
    var b = try safe.Box(i32).init(allocator, 42);
    std.debug.print("{d}", .{b.ptr.*});
    _ = b.deinit(); // type error if forgotten
}

let mut vec = Vec::new();
vec.push(1);
vec.push(2);
let x = vec.pop(); // Option

var list = safe.ArrayList(i32).init(allocator);
defer list.deinit(allocator);
try list.append(allocator, 1);
try list.append(allocator, 2);
const x = list.pop(); // i32 (panic if empty)

use std::collections::HashMap;
let mut map = HashMap::new();
map.insert("key", 42);
let val = map.get("key");

var map = safe.HashMap(safe.String, i32).init(allocator);
defer map.deinit(allocator);
try map.put(allocator, "key", 42);
const val = map.get("key"); // ?i32

use std::sync::Arc;
let a = Arc::new(42);
let b = Arc::clone(&a);
println!("{}", Arc::strong_count(&a));

var a = try safe.Arc(i32).init(allocator, 42);
defer a.deinit();
var b = a.clone();
std.debug.print("{d}", .{a.strong_count()});

use std::sync::Mutex;
let m = Mutex::new(0);
{
    let mut guard = m.lock().unwrap();
    *guard += 1;
} // unlocked automatically

var m = safe.Mutex(i32).init(0);
defer m.deinit();
{
    var guard = m.lock();
    guard.ptr.* += 1;
    guard.deinit(); // required in Zig
}

let mut s = String::new();
s.push_str("hello");
s.push_str(" world");
println!("{}", s);

var s = safe.String.init(allocator);
defer s.deinit(allocator);
try s.appendSlice("hello");
try s.appendSlice(" world");
std.debug.print("{s}", .{s.slice()});

let x: Option = Some(42);
let y = x.unwrap(); // panics if None
let z = x.unwrap_or(0);

const x: ?i32 = 42;
const y = x.?; // compile error if null path untaken
const z = x orelse 0;

let v = vec![1, 2, 3];
let doubled: Vec = v.iter()
    .map(|x| x * 2)
    .collect();

var v = safe.ArrayList(i32).init(allocator);
// ... populate ...
var iter = safe.SliceIter(i32).init(v.slice());
var doubled = try iter.map(allocator, struct {
    fn f(x: i32) i32 { return x * 2; }
}.f);