Coming from Rust
If you know Rust, tape will feel familiar in its philosophy — explicit, no hidden costs, errors are values. The difference is tape trades some compile-time guarantees for simpler ergonomics.
ownership & borrowing
Rust
Borrow checker, lifetimes, &/&mut, Clone/Copy traits. Compile errors for aliased mutation.
Tape
Move by default for managed types. Compiler inserts drops at scope exit. No borrow checker — use pointers explicitly when sharing.
generics & traits
Rust
fn foo — type parameters, trait bounds, monomorphization, impl blocks.
Tape
@tape fn gen(T: type) — run code at compile time to generate specialized types/functions. Explicit, debuggable, no inference.
error handling
Rust
Result, ? operator, From trait for error conversion.
Tape
T or E, or return to propagate, or { } to handle. Same concept, less syntax.
concurrency
Rust
Send/Sync traits, async/await, tokio/async-std, Arc
Tape
Actor-model worker threads. Typed channels (emits). No async/await — explicit thread boundaries, no colored functions.
what stays the same
- - No garbage collection (t0/t1)
- - Errors are values, not exceptions
- - Explicit over implicit everywhere
- - Enums / tagged unions with exhaustive match
- - Zero-cost abstractions as a design value