Skip to content

Coming from another language

Pick the language you know best. Its page lists what carries over, what will trip you up and what is only spelled differently, then shows one program written in both languages.

Rust. Enums with payloads, exhaustive matching, Result with a postfix ?, impl blocks, bounded generics and derive carry over, and a trait is an interface. There is no ownership, no mut, no value.method() call and no macros: a library generates code into ordinary files instead.

Go. Errors as values, structs, interfaces, one formatter, channels and a single executable carry over, and a Nomi program can call Go packages. Values never change, an error passes up with a postfix ?, a type says which interfaces it implements, and tasks run only inside a concurrent block, which waits for them.

Elixir. Immutable data, pipes, pattern matching, functions called through their module and supervised tasks carry over. Types are static, an enum variant stands where an atom or a tagged tuple would, Iter does the work of Enum and Stream, and tasks talk over channels, with std::actors for a server like a GenServer.

TypeScript. Static types with inference for locals, generics, lambdas and ${...} interpolation carry over, and a discriminated union is an enum. Nothing is null or undefined, a failure is a Result rather than a thrown error, and Int, Float and Decimal are separate types.

Python. Little punctuation, named arguments with defaults, tuples you unpack and first-class functions carry over. Every type is checked before the program runs, a block ends with end, values never change, and a failure is a value the function returns.

Kotlin. val bindings, data classes, sealed hierarchies with an exhaustive when, named arguments with defaults and structured concurrency carry over. A nullable type is a Maybe, errors are values, and there are no methods or extension functions.

Swift. Value types, enums with associated values, optionals that must be handled, protocols a type adopts by saying so and the leading dot of .small carry over. Every value is immutable, a function that throws returns a Result instead, and a function is called through its owner.

Ruby. The last expression as the result, Enumerable chains, => in a hash and case/in patterns carry over. Types are checked before the program runs, values never change, there are no methods to call on a value, and a class is never reopened.

Gleam has no page of its own. Custom types with variants, Result, no null, pipes and code built from expressions carry over, and Option is Maybe. Nomi adds bindings without let, interfaces with impl Interface for Type, derive, app fields, defer, typed literals, and early return, break and continue.

After that, the Language Tour covers the whole language, and the Cheat Sheet lists the rules most often written wrong.