mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 08:38:14 +01:00
106 lines
4.3 KiB
Markdown
106 lines
4.3 KiB
Markdown
# Glossary
|
|
|
|
#### Coroutine
|
|
|
|
A function that can suspend execution and, when called again later, resume
|
|
where it left off, in the middle of the function body. See the
|
|
[coroutines](/doc/note/coroutines.md) note for more details.
|
|
|
|
#### Dependent Type
|
|
|
|
A type that depends on another value. For example, a variable `n`'s type might
|
|
be "the length of `s`", for some other
|
|
[slice](/doc/note/slices-arrays-and-tables.md)-typed variable `s`. Dependent
|
|
types are *a* way to implement [bounds checking](/doc/note/bounds-checking.md),
|
|
but they're not the only way. Wuffs does not use them.
|
|
|
|
#### Effect
|
|
|
|
An extension of the type system, such as purity (freedom from side effects),
|
|
applied to functions. See the [effects](/doc/note/effects.md) note for more
|
|
details.
|
|
|
|
Syntactically, effects are the exclamation and question marks, `!` and `?`, at
|
|
function definitions and function calls. These denote impure and
|
|
[coroutine](/doc/note/coroutines.md) functions.
|
|
|
|
#### Fact
|
|
|
|
A boolean expression (e.g. `x > y`) that happens to be true at a given point in
|
|
a program. See the [facts](/doc/note/facts.md) note for more details.
|
|
|
|
#### Flick
|
|
|
|
A unit of time. One [flick](https://github.com/OculusVR/Flicks) (frame-tick) is
|
|
`1 / 705_600_000` of a second.
|
|
|
|
#### Interval Arithmetic
|
|
|
|
Arithmetic on numerical ranges. See the [interval
|
|
arithmetic](/doc/note/interval-arithmetic.md) note for more details.
|
|
|
|
#### Method
|
|
|
|
A function whose first argument (the receiver) has special syntactic support.
|
|
For example, an expression like `foo.bar(etc)` might effectively be a function
|
|
call whose first argument is `foo` and whose remaining arguments are the `etc`.
|
|
It is syntactic sugar for `type_of_foo__bar(self: foo, etc)`. On the callee
|
|
(not the caller) side, that implicit argument is often named `self` or `this`,
|
|
depending on the language (e.g. Wuffs per se uses `this`, but Wuffs transpiled
|
|
to C uses `self` to avoid confusion with C++'s `this`). Wuffs has no free
|
|
standing functions, only methods.
|
|
|
|
#### Modular Arithmetic
|
|
|
|
Arithmetic that wraps around at a certain modulus, such as `256` for the
|
|
`base.u8` type. For example, if `x` is a `base.u8` with value `200`, then `(x +
|
|
70)` has value `270` and would overflow, but `(x ~mod+ 70)` has value `14`.
|
|
|
|
#### Operator Precedence
|
|
|
|
A ranking of arithmetic operators so that an expression like `a + b * c` is
|
|
unambiguous (for the computer), equivalent to exactly one of `(a + b) * c` or,
|
|
more conventionally, `a + (b * c)`. While good for brevity, Wuffs does not have
|
|
operator precedence: the bare `a + b * c` is an invalid Wuffs expression and
|
|
the parentheses must be explicit. The ambiguity (for the human) can be a source
|
|
of bugs in other [security-concious file format
|
|
parsers](https://github.com/jbangert/nail/issues/7).
|
|
|
|
Some binary operators (`+`, `*`, `&`, `|`, `^`, `and`, `or`) are also
|
|
associative: `(a + b) + c` and `a + (b + c)` are equivalent, and can be written
|
|
in Wuffs as `a + b + c`.
|
|
|
|
#### Refinement Type
|
|
|
|
A basic type further constrained to a subset of its natural
|
|
[range](/doc/note/ranges-and-rects.md). For example, if `x` has type `base.u8[0
|
|
..= 99]` then it is an unsigned 8-bit integer whose value must be less than
|
|
`100`. Without the refinement, `x` could be as high as `255`.
|
|
|
|
`base.u8[0 ..= 99]` and `base.u32[0 ..= 99]` are two different types. They can
|
|
have different run-time representations.
|
|
|
|
Non-nullable pointer types can be thought of as a refinement of regular pointer
|
|
types, where the refined range excludes the `nullptr` value.
|
|
|
|
#### Saturating Arithmetic
|
|
|
|
Arithmetic that stops at certain bounds, such as `0` and `255` for the
|
|
`base.u8` type. For example, if `x` is a `base.u8` with value `200`, then `(x +
|
|
70)` has value `270` and would overflow, but `(x ~sat+ 70)` has value `255`.
|
|
|
|
#### Situation
|
|
|
|
The set of [facts](/doc/note/facts.md) at a given point in a program.
|
|
|
|
#### Utility Type
|
|
|
|
An empty struct (with no fields) used as a placeholder. Every written-in-Wuffs
|
|
function is a method: the receiver is mandatory. A Wuffs utility type's methods
|
|
are to its package what C++ or Java's static methods are to its class.
|
|
|
|
"Utility type" is merely a Wuffs naming convention. For example, Wuffs' `base`
|
|
package has a type called `base.utility`, similar to how the `zlib` package has
|
|
a type called `zlib.decoder`. Unlike "dependent type" or "refinement type",
|
|
"utility type" is not a phrase used in programming language type theory.
|