rename intrinsics

LANGUAGE.md

@@ -25,11 +25,11 @@ roadmap and milestone history.
 - target-dependent C scalar primitives from `c_char` through `c_longdouble`, kept semantically distinct from native scalars
 - contextual integer/float/character literals, backward type-demand inference through names and arithmetic, and compile-time folding for numeric constant expressions
 - strict numeric conversion by default, widening where valid, C scalar coercions at C boundaries, and explicit scalar keyword casts such as `i32(x)` / `c_float(x)`
-- compile-time `min_value(T)` and `max_value(T)` bounds for concrete native and C integer scalar types
+- compile-time `minval!(T)` and `maxval!(T)` bounds for concrete native and C integer scalar types
 - arrays `[N]T`, inferred-count arrays `[_]T`, sentinel arrays `[N;S]T`, compile-time expression array counts, slices `[]T` / `[;S]T`, single-item pointers `@T`, many-item pointers `*T`, and sentinel many-item pointers `[*;S]T`
 - pointer mutability via `mut`, optional pointers as nullable pointers, pointer arithmetic for many-item pointers, postfix dereference `^`, and trapping optional unwrap `?`
 - pointer-to-array `.len`, indexing, slicing, `.ptr` on slices and pointers-to-arrays, implicit address-taking for array-variable slices, and pointer/slice sentinel weakening
-- `ptr_cast(T, ptr)` as a first-pass pointer-child retype that preserves optionality, pointer kind, mutability, and sentinel shape
+- `ptrcast!(T, ptr)` as a first-pass pointer-child retype that preserves optionality, pointer kind, mutability, and sentinel shape
 - UTF-8 string literals as immutable pointers to static zero-terminated byte arrays, plus raw backtick multiline strings
 - narrow immutable zero-terminated byte pointer/slice conversion to `*c_char` / `?*c_char` without general `u8`/`c_char` interchange
 - optionals with `none`, `orelse`, postfix `?`, conditional unwraps, guarded unwraps, and left-to-right short-circuiting multi-unwraps
@@ -98,47 +98,51 @@ fields. `_` is not a keyword member name.
 
 #### division
 
+Compiler intrinsics use direct unqualified `name!(...)` syntax. The `!` marks the call as an
+intrinsic; it is not part of the identifier. Bare and qualified calls without `!` resolve as
+ordinary user functions, while qualified bang calls are rejected.
+
 `/` and `/=` accept only floating-point operands. Integer division must state its rounding and
-remainder convention with one of these unqualified builtins:
+remainder convention with one of these intrinsics:
 
 | Builtin | Result |
 | --- | --- |
-| `div_trunc(a, b)` | quotient rounded toward zero |
-| `div_floor(a, b)` | quotient rounded toward negative infinity |
-| `div_exact(a, b)` | truncated quotient; traps unless it divides exactly |
-| `div_ceil(a, b)` | quotient rounded toward positive infinity |
-| `rem(a, b)` | remainder paired with `div_trunc`; sign follows `a` |
-| `mod(a, b)` | modulus paired with `div_floor`; sign follows `b` |
+| `divtrunc!(a, b)` | quotient rounded toward zero |
+| `divfloor!(a, b)` | quotient rounded toward negative infinity |
+| `divexact!(a, b)` | truncated quotient; traps unless it divides exactly |
+| `divceil!(a, b)` | quotient rounded toward positive infinity |
+| `rem!(a, b)` | remainder paired with `divtrunc!`; sign follows `a` |
+| `mod!(a, b)` | modulus paired with `divfloor!`; sign follows `b` |
 
 The operands may be compatible concrete integer or float scalars. Existing literal coercion and
 numeric widening rules apply, the result has the common operand type, and float quotients are
 integral-valued floats. These identities hold when representable:
 
 ```bro
-div_trunc(a, b) * b + rem(a, b) == a
-div_floor(a, b) * b + mod(a, b) == a
+divtrunc!(a, b) * b + rem!(a, b) == a
+divfloor!(a, b) * b + mod!(a, b) == a
 ```
 
 Negative operands distinguish the operations:
 
 ```bro
-div_trunc(-5, 3) == -1
-div_floor(-5, 3) == -2
-div_ceil(-5, 3) == -1
-rem(-5, 3) == -2
-mod(-5, 3) == 1
-mod(5, -3) == -1
+divtrunc!(-5, 3) == -1
+divfloor!(-5, 3) == -2
+divceil!(-5, 3) == -1
+rem!(-5, 3) == -2
+mod!(-5, 3) == 1
+mod!(5, -3) == -1
 ```
 
 All six builtins diagnose a zero denominator at comptime and trap at runtime, including float
-zero. Quotient operations also trap for signed `min_value(T), -1`; `rem` and `mod` return zero for
-that pair. `div_exact` traps when `div_trunc(a, b) * b == a` is false in the operand type, so float
+zero. Quotient operations also trap for signed `minval!(T), -1`; `rem!` and `mod!` return zero for
+that pair. `divexact!` traps when `divtrunc!(a, b) * b == a` is false in the operand type, so float
 exactness follows floating-point equality. Other float NaN and infinity behavior follows the
 underlying IEEE operations. Ordinary float `/` remains unchecked and therefore preserves IEEE
 infinity/NaN behavior.
 
-The six spellings are reserved only as direct unqualified calls. A qualified call such as
-`math.div_floor(a, b)` resolves to an ordinary package function.
+Only the six bang calls are intrinsic. Bare calls such as `divfloor(a, b)` and qualified calls such
+as `math.divfloor(a, b)` resolve to ordinary functions.
 
 ### functions, C interop, and linking
 
@@ -188,7 +192,7 @@ The six spellings are reserved only as direct unqualified calls. A qualified cal
 - non-plain C record layouts such as bitfields, packed records, flexible arrays, qualified fields, and C variadic record arguments
 - arenas, pools, build-mode heap policy, and escaping-allocation diagnostics
 - recursive type factories, type reflection, and type-producing unions/enums
-- broader Zig-style pointer/result casts beyond V1 `ptr_cast(T, ptr)`
+- broader Zig-style pointer/result casts beyond V1 `ptrcast!(T, ptr)`
 - sum-type ABI/layout polish, including dynamic tag-width shrinking, all-void channel collapse, and cross-module global-id determinism
 - backed/C enum composition and must-consume fallible linting
 - result-to-argument type-demand propagation through function call boundaries