Initial set of primitives

[pjcavalcanti]

Initial set of primitives

Implement the primitives described in the list below. See Notes to coordinate with other tasks.

Note on JIT (#27)

• If common functions are kept as defs (e.g. map / fold / length / concat / split),
  a JIT could accelerate them without turning them into primitives.

Note on FFI (#28)

• read_file / write_file might be implemented via FFI with C,
  instead of dedicated primitives.

---

Proposed primitives

Debug / observability (can inspect without consuming the term)

• Rationale: inspect terms in lazy mode without altering evaluation.
• %show(x: a) -> String
  • Stringifies without reducing and without consuming the term.
  • Use the current printing format (normalize mode / no collapse).
• %trace(msgs: List<String>, x: a) -> a
  • Prints the concatenation of msgs and returns x without consuming it.
  • Use the current printing format (normalize mode / no collapse).

Control / error

• Rationale: explicit failures and error messages.
• %panic(msg: String) -> a
  • Aborts with a message; only triggers if evaluated.

IO

• Rationale: basic input/output effects with explicit errors.
• %log(s: String) -> #Nil (existing)
  • String = list of #Chr.
  • Kept as-is (returns []).
• %read_file(path: String) -> #Ok{String} | #Err{String}
  • IO with explicit error; no silent failure.
• %write_file(path: String, data: String) -> #Ok{} | #Err{String}
  • IO with explicit error.
• %read_bytes(path: String) -> #Ok{List<#U8{NUM}>} | #Err{String}
  • Byte = #U8{n} with n stored in 8 bits.
• %write_bytes(path: String, data: List<#U8{NUM}>) -> #Ok{} | #Err{String}
  • Byte = #U8{n} with n stored in 8 bits.

Effects / nondeterminism

• Rationale: time and RNG utilities while keeping clear semantics.
• %time_ms() -> NUM
  • Monotonic; effectful; result depends on when it is demanded.
• %rand(seed: NUM, bits: NUM) -> #Pair{seed2, value}
  • Pure/deterministic PRNG; bits defines width.
  • Supported term bit sizes:
    • 7 (TAG), 24 (EXT), 32 (VAL).
  • Supported common sizes: 8 / 16 / 64.
  • bits outside this set: panic.

Common FP utilities

• Rationale: basic library building blocks; decide whether they remain defs or become primitives.
• Lists: map, fold, length, concat, split
• Strings: num_to_str, str_to_num

[VictorTaelin]

%trace(msgs: List<String>, x: a) -> a
Prints the concatenation of msgs and returns x without consuming it.
Use the current printing format (normalize mode / no collapse).

this is not right, see how %log works. we use a strict lambda to force the %log. so there is no such a thing as a continuation argument x.

%show(x: a) -> String
Stringifies without reducing and without consuming the term.
Use the current printing format (normalize mode / no collapse).

stringifying without reducing should not be a primitive, I don't think this would work or be deterministic, am I mistaken? we could make something like a %show but it has to reduce

%read_bytes, %write_bytes, are OK and can be implemented

%read_file, %write_file need thought about the reading mode. is it UTF-32? (should be)

we need way more file operations than that, how Node / Deno does it? we should probably have a similar interface with a complete API

%time_ms is a bad name, probably %now is better, but we need to return a pair since we only have 32-bit numbers

%rand shouldn't receive a seed or bits. just return a random number on the u32 range. pris are effects