Several intrinsics are polymorphic in their data argument: @save, @savem, @savej, @write, @hash, @show, @schema, and @typeof accept a value of any type. @load, @read, and @next return a value of any type, inferred from context. @stdin, @stdout, @stderr, @open, and @append are polymorphic in their handle’s element type, which is resolved by inline ascription at the open site. @collect is polymorphic in the stream element type a, read off the sink its producer is handed. @throw is polymorphic in its return type because it never returns — the return slot unifies with whatever the surrounding context expects. @try passes its argument’s effect row through unchanged.

Two patterns run through the table. Anything that touches the world carries <IO>, and anything that can fail returns a Try (see Failure is not an effect): a missing file, a full disk, a broken pipe or a decode mismatch arrives as an Err arm rather than as an effect label. Most entries have both. The exceptions on the failure side are @close, @tell, @stream, @stdout and @stderr, which do setup, teardown or bookkeeping with no failure mode addressable from morloc code; @read is the exception on the other side, fallible but pure, because parsing a string touches nothing. The remaining intrinsics (@version, @compiled, @lang, @datafile) are compile-time constants, and @hash, @show, @schema and @typeof are pure functions of their argument’s type or serialized bytes.

@hash computes a fast, non-cryptographic hash (xxhash) of any value. The value is first serialized to MessagePack internally, then hashed. The result is a 16-character hexadecimal string.

The two differ because the integer 1 and the string "1" have different MessagePack encodings, which is the point of the paragraph below.

Hashing is deterministic: the same value always produces the same hash. Two values of different types may hash differently even if they look similar (e.g., the integer 1 and the string "1"), because their MessagePack serializations differ.

The @version, @compiled, and @lang intrinsics are resolved at compile time. They can be used anywhere a Str value is expected.

The @lang value depends on where the expression is evaluated. When the list literal above is assembled at the nexus level (not inside a sourced function), @lang resolves to "morloc". To observe the language-pool identifier, pass @lang into a sourced function and let it be evaluated inside that pool: the value will be that pool’s canonical language identifier — the name field from its lang.yaml ("py", "cpp", "r", …​).

@lang deliberately returns this short canonical identifier, not a human-facing display name like "Python3" or "C++". Intrinsics are low-level primitives where stability outweighs presentation: the lang.yaml name is the guaranteed-unique, stable identifier for a language backend, so it is the correct value for conditional logic and tooling. Map it to a prettier label yourself if you need one.

The @savem and @savej intrinsics write a single value to a file path, and @load reads it back. Together they provide a type-safe file persistence mechanism for one-shot writes. For multi-element accumulation use an OStream and @write instead (see Random access and streaming).

@savem uses MessagePack, which is compact and portable across different machines and architectures. @savej writes plain JSON, which is human-readable and can be edited by hand or consumed by other tools.

@load auto-detects the file format. Files written by @savem carry a small header that identifies them as MessagePack. If no header is present, @load tries to parse the file as JSON. @load also recognises morloc stream and voidstar packets, so any file produced by the morloc runtime round-trips through it.

@load returns <IO> (Try Str a). A missing file, decode failure, or schema mismatch against the caller’s expected type all come back as an Err arm rather than an exception — see Failure and recovery.

Here is a basic round-trip example:

The bare @savem writes the integer to the given path; nothing reads its result, so a write failure stops the block there (see A bare statement checks its result). Ok v ← @load path reads the value back and unwraps it, throwing if the load failed. The signature is plain <IO> Int, because neither failure survives as a value.

import root is doing work here: Try and its two constructors are declared in the standard library, so a module that names Ok or Err needs it.

You can also use @savej when you want the output to be readable:

The resulting file is plain JSON that can be inspected in any text editor. The trailing () is not decoration: a do-block’s last statement is its return value, so leaving @savej there would make the block return the Try rather than discharge it. A do-block does not return a Try gives the three ways to write this and when each is right.

A common pattern is to check whether a cached result exists before recomputing it. @load gives an Err arm when the file is missing (or on any decode failure), so match on the result and compute in the Err arm:

On the first call the cache file does not exist, so the Err arm runs expensiveComputation, saves the result and returns it. On the second the Ok arm returns the stored value and the computation never runs. An arm may be a whole do-block, which is what makes the recomputation lazy: only the arm that is taken evaluates. Both arms of a match have one type, so once the Err arm is a do-block the Ok arm wraps its value in do too (see The rules); a bare v there is a type error.

The bare @savem inside the Err arm still checks itself, so a cache that cannot be written stops the program rather than silently returning an uncached value. If you would rather carry on, bind it: _ ← @savem cachePath (id fresh).

You can also use @hash to build content-addressed caches where the cache path depends on the input:

Each distinct input gets its own cache file, keyed by the xxhash of its serialized form.

The @datafile intrinsic resolves a relative file path to its location in the installed program directory. When you compile with morloc make --install, source files and data files listed in package.yaml are copied into the install directory. At runtime, these files are no longer at their original paths. @datafile bridges this gap by resolving the path at compile time.

Here @datafile "defaults.json" evaluates to the absolute path where defaults.json is installed (for example, ~/.local/share/morloc/exe/main/defaults.json). The Python function receives this path as a plain string and can open the file normally.

When running without --install (plain morloc make), @datafile returns the relative path unchanged, so the program works from the project directory as expected.

The @schema and @typeof intrinsics return information about how the compiler represents a type. The value argument is not evaluated at runtime — only its type matters.

@typeof returns the morloc abstract type name (the same way the type would be written in a signature): "Int", "Str", "Real", "Bool", "[Int]", "?Int", "(Int, Str)", and so on. It does not return the language-native type name in the current pool.

@schema returns the internal serialization schema string used by the compiler for MessagePack and binary serialization. The encoding is short, byte-oriented, and stable for a given compiler version. The alphabet:

There are no separators anywhere in the encoding. Reading a few real ones is the quickest way to internalize it:

@schema is primarily useful for debugging and for cross-language tools that inspect morloc wire formats.

Failure in Morloc is a value, not an effect: a fallible operation returns Try e a and the caller matches on it. Failure is not an effect makes that case; this section covers the two intrinsics that sit at its edges. @throw produces a failure that is not a value — a native exception that unwinds — and @try turns one back into a value.