Tense Compositions

2026-05-31 · updated 2026-06-01

CLEAR separates Tenses (Temporal, Optional, Failable) from pure memory layout (Types) from capabilities.

See Sharing Capabilities for more details.

Tenses:

• Future Tense: ~T
  • A T that is not guaranteed to be available now, but at some point in the future will be.
• Failable Tense: !T
  • A T that could be an error or a T.
• Optional Tense: ?T
  • A T that could be Nil or a T.

Combinations:

• ~?T[] = A stream of optional Ts (common - this is an unbound finite stream)
• ? (~T[]) = An optional stream of Ts (uncommon)
• ~(T[]) = A future to an Optional Array of Ts (uncommon)
• ~(?T[]) = A future to an Optional Array of Ts (VERY uncommon)

To some, this may be considered far less readable than Rust/C style:

• Stream<Optional<T>>
• Future<Optional<T>>
• Optional<Stream<T>>
• Future<T[]>

However, the further these compose with CLEAR's capabilities and failables, the harder Rust types are to read.

Compare simple cases:

Compare complex cases:

CLEAR reads better left to right:

• You immediately know what it is and what you must do to access it.
• It is clearly separated what you are allowed to do with it (how it can be shared, and the cost of that).

CLEAR's tense system can look like Sigil Soup, but for the vast majority of cases it is more readable if you take a minute to learn the 3 sigils / tenses.

In the cases where you have tons of nested capabilities and tenses, CLEAR believes its system is much easier to parse to separate the concerns of what is important.

In short, CLEAR separates:

1. What you need to do before you can use data (tenses),
2. From the memory layout (types),
3. From what you're allowed to do with it / how it can be shared, and optimizations on it (capabilities)

Order of symbols:

Tense symbols are read left-to-right.

Following the ordered list above, the come first (left most) because they dictate what must be done first to use the underlying data (the actual type):

If something is FOR SURE a future -> it starts with ~ no space for other tenses:

• A future to an optional ~?T
• A future to a fallible ~!T
• A future to a fallible optional (bad design) ~!?T

If something is FOR SURE fallible -> it starts with ! and a space & parens if other tenses:

• A fallible !T
• A fallible future ! (~T)

If something is FOR SURE optional -> it starts with ? and a space & parens if other tenses:

• An optional ?T
• An optional future ? (~T)

Fallible optionals (typically bad design) are combined before a space:

• A fallible optional future !? (T)

When combined with arrays:

• A for sure finite unbounded stream that could fail: ~!?T[]
• An optional stream where each item can fail: ? (~!T[])
• A fallible stream where each item is optional: ! (~?T[])

The leftmost character lets you know what you can do with it right away.

Therefore if something is fallible, the ! must come first:

• If it’s optional, the ? must come next.
• If it’s temporal / a future, the ~ must come next.

Complex 2d arrays are NOT representable by design (as they do not make sense in terms of memory layout):

• T[]?[] # illegal
• ? (T[])[] # illegal
• T[]![] # illegal
• ! (T[])[] # illegal

This is not unique to CLEAR. This is not allowed in Rust, C, or Go either.

Styling

Note that there is a space between optionals and errors, when combine with any non-trivial tense:

• !T
• ?T
• !?T
• ? (~T)
• ! (~T[])
• ! (~?T)
• !? (~T)

If you don't include the spaces and parentheses, the compiler will typically auto-correct it for you.

In practice, complex types like these are often created inline, via streaming pipelines, and you never need to know the correct formatting.

Streaming Arrays:

Streaming HashMaps:

m: ~T{} = getInfMap(); // infinite
m2: ~?T{} = getUnboundFiniteMap(); // unbound, finite

# Loop through mutations as they hit the map
WHILE NEXT m AS (key, value) {
    print("Key {key} changed to {value}");
}

# Loop through mutations as they hit the map
WHILE NEXT m2 AS (key, value) {
  IF value AS v {
    print("Key {key} changed to {v}");
  }
  ELSE {
    print("Key {key} was deleted");
  }
}
print("stream closed.");

Combine with failibility:

Source: docs/tense-composition.md