Unfinished Ideas

Admittedly, many ideas for Cilia are not yet fully developed, but these really do need some more work.

T^ to Objects of Other Languages

We can redefine T^ for interoperability with other languages, e.g. garbage collected languages like C# and Java.

T^ is defined via type traits SharedPtrType:

T+ is defined via type traits UniquePtrType:

Exotic Operators (e.g. Unicode)

Logical / Bool Operators

It is also possible to use the mathematical symbols ∧, ∨, ⊼, ⊽, ¬ for and, or, nand, nor, not.

operator (Bool a) ∧ (Bool b) -> Bool { return a and b }
operator (Bool a) ∨ (Bool b) -> Bool { return a or b }
operator (Bool a) ⊼ (Bool b) -> Bool { return a nand b }
operator (Bool a) ⊽ (Bool b) -> Bool { return a nor b }
operator (Bool a) ⊻ (Bool b) -> Bool { return a xor b }
operator ¬(Bool a) -> Bool { return not a }

Vector / Matrix Operators

operator (Vec3 a) × (Vec3 b) -> Vec3       { ... }   // cross product (beware of confusion with the letter 'x')
operator (Vec a) ⋅ (Vec b) -> Float        { ... }   // dot / scalar / inner product

operator (Matrix a) ⊙ (Matrix b) -> Matrix { ... }   // Hadamard (element-wise) product
operator (Matrix a) ⊘ (Matrix b) -> Matrix { ... }   // Hadamard (element-wise) division
operator (Matrix a) ⊞ (Matrix b) -> Matrix { ... }   // element-wise addition ("boxplus")
operator (Matrix a) ⊟ (Matrix b) -> Matrix { ... }   // element-wise subtraction ("boxminus")
operator (Matrix a) ⊗ (Matrix b) -> Matrix { ... }   // tensor / Kronecker product

operator (Vec a) ⊕ (Vec b) -> Vec          { ... }   // direct sum: {1 2} ⊕ {3 4} -> {1 2 3 4}
operator ⊖(Vec a) -> Vec                   { ... }   // negation (unary)
operator (Vec a) ⊖ (Vec b) -> Vec          { ... }   // subtraction (binary)
operator (Signal a) ⊛ (Signal b) -> Signal { ... }   // convolution
operator (Signal a) ∗ (Signal b) -> Signal { ... }   // convolution (alternative)

func ∠(Vec a, b) -> Float        { ... }  // angle between two vectors
func ∠(Point3D a, b, c) -> Float { ... }  // angle between three points (vectors ab and bc)

Unclear, if these should have an epsilon (ε) value here. And then they would be function calls, not infix operators:

operator (Vec a) ⟂ (Vec b) -> Bool { ... }   // perpendicular / orthogonal
operator (Vec a) ∥ (Vec b) -> Bool { ... }   // parallel to
operator (Vec a) ∦ (Vec b) -> Bool { ... }   // not parallel to

Set Operators

Set operators fall into two precedence groups (see precedence diagram below). They are unrelated to scalar relational operators such as ==, !=, <, or > — there is no precedence ordering between the two domains, and meaningful expressions do not mix them.

Membership / subset — ∈, ∉, ∋, ∌, ⊆, ⊇, ⊂, ⊃ parse as binary infix operators returning Bool. Subset relations are chaining (A ⊆ B ⊂ C), membership is non-associative.

Algebraic — ∪, ∩, ∖ parse as binary infix operators returning sets. They bind tighter than membership/subset (so x ∈ A ∪ B parses as x ∈ (A ∪ B)) but looser than range (.., ..<). Mixed algebraic expressions such as A ∪ B ∩ C require parentheses.

// Set membership
operator (T x) ∈ (Set<T> s) -> Bool { return s.contains(x) }
operator (T x) ∉ (Set<T> s) -> Bool { return not s.contains(x) }
operator (Set<T> s) ∋ (T x) -> Bool { return s.contains(x) }
operator (Set<T> s) ∌ (T x) -> Bool { return not s.contains(x) }

// Subset / superset
operator (Set<T> a) ⊆ (Set<T> b) -> Bool { return a.isSubsetOf(b) }
operator (Set<T> a) ⊇ (Set<T> b) -> Bool { return a.isSupersetOf(b) }
operator (Set<T> a) ⊂ (Set<T> b) -> Bool { return a.isProperSubsetOf(b) }
operator (Set<T> a) ⊃ (Set<T> b) -> Bool { return a.isProperSupersetOf(b) }
// Set algebra
operator (Set<T> a) ∪ (Set<T> b) -> Set<T> { return a.union(b) }
operator (Set<T> a) ∩ (Set<T> b) -> Set<T> { return a.intersection(b) }
operator (Set<T> a) ∖ (Set<T> b) -> Set<T> { return a.difference(b) }

Operator Precedence

Group names in the diagram below correspond to precedence declarations (see Custom Operators with Declared Precedence).

List of all currently known operators:

Possible future operators (optional, not yet in the precedence diagram):

Operator precedence is a partial ordering, not a global one, as nobody can remember all these precedence levels.

See Carbon Expression Precedence:

Expressions are interpreted based on a partial precedence ordering. Expression components which lack a relative ordering must be disambiguated by the developer, for example by adding parentheses; otherwise, the expression will be invalid due to ambiguity. Precedence orderings will only be added when it’s reasonable to expect most developers to understand the precedence without parentheses.

Also see Circle simpler_precedence

In the diagram below, nodes higher up bind tighter; arrows point from looser toward tighter binding.

graph BT
    primary["Primary
(…)
{…}
[…](…) {…}
x"]

    suffixOps --> primary
    suffixOps{"Postfix
x.y
x.(…)
x->y
x->(…)
x?.y
x(…)
x[y]"}

    postIncDec --> suffixOps
    postIncDec["PostfixIncrementDecrement
x++
x--"]

    pointer --> postIncDec
    pointer{"Indirection
*x
&x"}

    prefixArithmetic & root & complement & incDec --> pointer
    complement["PrefixBitwise
~x"]
    prefixArithmetic["PrefixArithmetic
-x
+x
⊖x"]
    root{"Root
√x
∛x
∜x"}
    incDec["IncrementDecrement
++x
--x"]

    unary --> prefixArithmetic & root & complement & incDec
    unary((" "))


    %% Longer arrow to for alternatibg positions
    modulo ----> unary
    rotate ---> unary
    shift  ----> unary
    bitwiseAnd ---> unary
    bitwiseOr  ----> unary
    bitwiseXor ---> unary
    modulo["Modulo
x % y
x mod y"]
    rotate["Rotation
x <<< y
x >>> y"]
    shift[/"Shift
x << y
x >> y"/]
    bitwiseAnd[/"BitwiseAnd
x & y"/]
    bitwiseOr[/"BitwiseOr
x | y"/]
    bitwiseXor[/"BitwiseXor
x ^ y"/]

    %% No edge to prefixArithmetic/root/complement/incDec: `-x ** 2` and `√x ** 2` require parentheses
    power --> pointer
    power[\"Power
x ** y"\]

    product --> power & unary
    product((" "))

    %% The product-like groups are unordered relative to each other (`6 / 2 × 3` requires parentheses),
    %% except `×` tighter than `⋅` (scalar triple product `a ⋅ (b × c)`)
    tensor --> product
    tensor[/"Tensor
x ⊗ y"/]

    multiplication --> product
    multiplication[/"Multiplication
x * y
x / y
x ÷ y"/]

    hadamard --> product
    hadamard[/"Hadamard
x ⊙ y
x ⊘ y"/]

    crossProduct --> product
    crossProduct["CrossProduct
x × y"]

    dotProduct --> crossProduct
    dotProduct["DotProduct
x ⋅ y
x ∙ y"]

    convolution --> product
    convolution[/"Convolution
x ⊛ y
x ∗ y"/]

    %% `⊗` tighter than `⊕` (as in algebra), but `⊕` unordered relative to `+`
    directSum --> tensor
    directSum[/"DirectSum
x ⊕ y
x ⊖ y"/]

    addition --> tensor & multiplication & hadamard & dotProduct & convolution
    addition[/"Addition
x + y
x - y
x ⊞ y
x ⊟ y"/]

    binaryOps --> modulo & rotate & shift & bitwiseAnd & bitwiseOr & bitwiseXor & directSum & addition
    binaryOps((" "))

    %% `as` is unordered relative to arithmetic and bitwise operators: `a * b as T` requires parentheses,
    %% but `x as Int == 3` is `(x as Int) == 3`
    cast ------> unary
    cast["Cast
x as T"]

    %% Ranges bind looser than arithmetic/bitwise, tighter than the relational operators
    range --> binaryOps & cast
    range["RangeFormation
x .. y
x ..< y"]

    setUnion & setIntersection & setDifference --> range
    setUnion[/"Union
x ∪ y"/]
    setIntersection[/"Intersection
x ∩ y"/]
    setDifference[/"SetDifference
x ∖ y"/]

    setOps --> setUnion & setIntersection & setDifference
    setOps((" "))

    subset & membership --> setOps

    subset@{ shape: hex, label: "Subset
x ⊆ y
x ⊇ y
x ⊂ y
x ⊃ y" }
    membership["Membership
x ∈ y
x ∉ y
x ∋ y
x ∌ y"]

    %% `??` is unordered relative to arithmetic, bitwise, and range: `x ?? 0 + 1` requires parentheses,
    %% but `a ?? b == c` is `(a ?? b) == c`
    nullCoalescing ------> unary
    nullCoalescing[\"NullCoalescing
x ?? y"\]

    %% Set equality: `A ∪ B == C` is `(A ∪ B) == C`
    equality --> setOps & nullCoalescing
    comparison --> nullCoalescing
    comparison & threeWay & parallel --> range
    equality["Equality
x == y
x != y
x ≠ y"]
    comparison@{ shape: hex, label: "Comparison
x < y
x > y
x <= y
x >= y
x ≤ y
x ≥ y" }
    threeWay["ThreeWayComparison
x <=> y"]
    parallel["Parallel
x ⟂ y
x ∥ y
x ∦ y"]

    %% `!` and `¬` are unordered relative to equality/comparison: in C/C++ `!a == b` is `(!a) == b`,
    %% and in math `¬` binds tightly, too, so require parentheses
    %% `!x++` is `!(x++)`, as in C/C++ (and as `-x++` is `-(x++)`)
    %% Use a longer arrow here to put `!`/`¬` next to other unary operators
    bang ---------> postIncDec
    bang["LogicalNegationSymbol
!x
¬x"]

    %% `is` is unordered relative to equality/comparison: `x is T == b` requires parentheses
    isType ------> unary
    isType["TypeTest
x is T"]


    logicalOperand --> subset & membership & equality & comparison & threeWay & parallel & bang & isType
    logicalOperand((" "))


    %% `not` binds looser than equality/comparison/set relations (as in Carbon and Python): `not a == b` is `not (a == b)`,
    %% but tighter than the binary logical operators: `not a and b` is `(not a) and b`
    %% (`not` --> `!`/`¬` is irrelevant, as a prefix operator applied to another one is never ambiguous)
    not --> logicalOperand
    not["LogicalNegation
not x"]

    and        ---> not
    or         --> not
    andSymbol  ---> not
    orSymbol   --> not
    andMath    ---> not
    orMath     --> not
    xorNandNor ---> not

    and[/"LogicalAnd
x and y"/]
    or[/"LogicalOr
x or y"/]
    andSymbol[/"LogicalAndSymbol
x && y"/]
    orSymbol[/"LogicalOrSymbol
x || y"/]
    andMath[/"LogicalAndMath
x ∧ y"/]
    orMath[/"LogicalOrMath
x ∨ y"/]
    xorNandNor["LogicalXOrNandNor
x xor y
x nand y
x nor y
x ⊻ y
x ⊼ y
x ⊽ y"]


    logicalExpression --> and & or & andSymbol & orSymbol & andMath & orMath & xorNandNor
    logicalExpression((" "))


    insideParens & assignment --> logicalExpression
    insideParens["Parenthesized
(…)"]
    assignment["Assignment
x = y
x += y
x -= y
x *= y
x /= y
x %= y
x <<= y
x >>= y
x <<<= y
x >>>= y
x &= y
x |= y
x ^= y
x &&= y
x ||= y
x ??= y"]

Notes on the value expressions:

Evaluation order is as in C++17 and later (no Cilia-specific extensions):

Order-dependent expressions are checked by the Cilia compiler (not left to the C++ compiler), syntactically on the AST, similar to Clang’s -Wunsequenced:

Why not leave this to the C++ compiler:

Type expressions are a separate syntactic context (declarations, parameter and return types, template arguments, right operand of as and is), with their own small precedence graph. So T** (pointer to pointer) never competes with x ** y (power), nor T* with x * y, nor T& with x & y. At the start of a statement, where both could occur (A* b = c, A& b, A+ b, …), name lookup decides, as in C++: if A names a type, it is a declaration, otherwise an expression. For dependent names in templates see Templates (type analogous to C++ typename, or ways to omit it).

graph BT
    typeName["TypeName
T
T<…>
(…)"]

    qualifiedType --> typeName
    qualifiedType["TypeQualifier
const T"]

    typeSuffix --> qualifiedType
    typeSuffix{"TypeSuffix
T*
T^
T+
T-
T&
T?
T[]
T[N]"}

The graph above covers the partial ordering of all contemplated Unicode/Cilia operators. Relations that most developers can be expected to know are drawn as edges, e.g.

This avoids the well-known C/C++ pitfall where x & mask == 0 parses as x & (mask == 0); here it parses as the intended (x & mask) == 0.

Pairs that nobody reliably ranks are left unordered on purpose and therefore require explicit parentheses, e.g.:

Logical xor (and ⊻) is deliberately non-associative, although xor is mathematically associative:

Bitwise ^ stays left-to-right-associative, as h ^ a ^ b (parity, hashing) is common and unambiguous there.

The node shapes encode each group’s

i.e. what it means to chain the same precedence group without parentheses.
Circles are helper nodes only (not a precedence group).

× is non-associative, as the cross product is not associative: (a × b) × c ≠ a × (b × c), so a × b × c requires parentheses.
⋅ / ∙ is non-associative, too: (a ⋅ b) ⋅ c (scalar times vector) differs from a ⋅ (b ⋅ c), so a ⋅ b ⋅ c requires parentheses.

Comparisons are chaining (as in Python and in math notation): a < b <= c means a < b and b <= c, with b evaluated only once.

Precedence only matters where an expression is actually ambiguous:

Whether an operator token is prefix, infix, or postfix is decided by whitespace, as in Swift. This matters, as many tokens can be both (-, +, ⊖, *, &, ++, --), and for custom operators in particular:

graph LR
    binary@{ shape: brace-r, label: "Binary" }

    nonAssociative["Non-Associative

a == b == c
needs parens"]

    leftToRightAssociative[/"Left-to-Right-Associative

a + b + c 
=
(a + b) + c"/]

    rightToLeftAssociative[\"Right-to-Left-Associative

a ** b ** c
=
a ** (b ** c)"\]

    chaining@{ shape: hex, label: "Chaining

a < b <= c
=
a < b and b <= c" }


    unary@{ shape: brace-r, label: "Unary" }

    nonRepeating["Non-Repeating"]

    repeating{"Repeating

 x.y.z
 *&x
 T**"}


    helper@{ shape: brace-r, label: "Helper Node" }

    circle((" "))


    binary ~~~ nonAssociative ~~~ leftToRightAssociative ~~~ rightToLeftAssociative ~~~ chaining
    unary ~~~ nonRepeating ~~~ repeating
    helper ~~~ circle

Custom Operators with Declared Precedence

Note
Admittedly, all of this is rather complex.

For custom operator symbols, fixity and precedence must be declared explicitly. Operator precedence is resolved based on a partial ordering (roughly as in Swift SE-0077).

If two neighbouring infix operators have precedence groups without a defined relation, the expression requires parentheses. Otherwise it is a compile error, e.g. 1 + 2 & 3 is illegal.

Prefix and infix forms of the same symbol (e.g. -) are distinct registrations, as in C++ and Swift.

Declaration is in two separate steps:

1. Precedence Groups & Their Ordering

Named groups replace numeric precedence levels.

precedence Composition {      // e.g. for function composition `f >=> g`
    associativity: left
    higherThan: Comparison
    lowerThan: Addition
}

Rules for the precedence graph (as in Swift):

2. Operator Registration & Implementation

Overload the registered symbol using the existing operator syntax.

operator (Set<T> a) ∖ (Set<T> b) -> Set<T> { ... }   // set difference: a without b
operator √(Float a) -> Float { ... }

Infix operators without a group belong to Default, prefix and postfix belong to the (high) precedence groups Prefix/Postfix. Default is non-associative and only tighter than not, the logical operators, and assignment (i.e. it is a logical operand, like Comparison); relative to all other groups it is unordered. So a ⊕⊕ b and c is (a ⊕⊕ b) and c, but a ⊕⊕ b + c and a ⊕⊕ b ⊕⊕ c require parentheses.

Operator precedence groups can be declared explicitly:

operator (Set<T> a) ∪ (Set<T> b) -> Set<T> precedence Union { ... }          // union
operator (Set<T> a) ∩ (Set<T> b) -> Set<T> precedence Intersection { ... }   // intersection
operator (Matrix a) ⊗ (Matrix b) -> Matrix precedence Tensor { ... }         // tensor / Kronecker product

Compound-assignment variants remain member operators inside classes (operator +=(…), etc.).

Allowed operator characters

Operator names follow Swift’s operator-head + operator-characters grammar:

Word operators (and, or, nand, nor, xor, not) are standard-library built-ins; custom operators use symbol tokens.

TODO: Should users be able to declare custom word operators?

Bracket / “Sandwich” Operator

Bracket / “sandwich” operators (like ‖x‖, ⟨a, b⟩, …) are paired delimiters (“enclosing operator”, “delimited form”, “bracketed expression”, informally “sandwich operator”).

operator ‖Vec v‖ -> Float  { return v.length() }  // norm
operator ⟨Vector<Float> a, b⟩ -> Float { ... }    // inner product

|x| for abs(x) is problematic, as | is also the bitwise or operator, but it should be parseable with a position-aware (Pratt) parser.

||x|| for norm(x) also needs a position-aware parser to distinguish from logical-or. Or use ‖x‖ (U+2016).

While symmetric delimiters that use the same character for open and close (‖…‖, |…|) can be parsed and nested via the position rule above (‖a + ‖b‖‖ = norm(a + norm(b))), the close-first rule is not obvious to human readers and editor bracket-matching is hard. Asymmetric pairs (e.g. ⟨…⟩) avoid all of this.

More bracket variants (asymmetric pairs only; some may be used in reversed order, e.g. ≫...≪; see also Unicode Math Brackets):

Pair Name / note
⟨...⟩ angle brackets (inner product)
⟪...⟫ double angle brackets
⦑...⦒ angle bracket with dot
⦅...⦆ double parenthesi
⟮...⟯ flattened parenthesi
⦃...⦄ white curly bracket
⟦...⟧ white / semantic (“Scott”) square brackets
⦋...⦌ square bracket with underbar
⦍...⦎ square bracket with ticks
⦏...⦐ square bracket with ticks (mirrored)
⁅...⁆ square bracket with quill
⌊...⌋ floor (round down)
⌈...⌉ ceiling (round up)
⦗...⦘ black tortoise-shell bracket
⟬...⟭ white tortoise-shell bracket
⦇...⦈ image bracket
⦉...⦊ binding bracket
⦓...⦔ arc less/greater-than bracket
⦕...⦖ double-line arc bracket
⟅...⟆ S-shaped bag delimiter
⌜...⌝ top corners (quine corners)
⌞...⌟ bottom corners
⸢...⸣ top half brackets
⸤...⸥ bottom half brackets
≪...≫ much-less/greater-than (relational operator, not a true bracket)
⋘...⋙ very-much-less/greater-than (operator)
‹...› single guillemets (quotation, not math)
«...» double guillemets (quotation, not math)
❨...❩ parenthesis ornament (decorative)
❪...❫ flattened parenthesis ornament
❬...❭ angle bracket ornament
❮...❯ heavy angle quotation ornament
❰...❱ heavy angle bracket ornament
❲...❳ tortoise-shell bracket ornament
❴...❵ curly bracket ornament

N-Ary Operators

N-ary operators need an index/binder (e.g. ∑_{i=1}^{n}) and are handled like functions or for-in-loops:

Later / Never

Many of the symbols seem more suitable for a computer algebra system (CAS) than for a general purpose programming language, so they stay unassigned for now.

Reserved for future use, as it could get complicated and confusing. Remaining candidate symbols, not yet assigned to one of the cases above (with their usual mathematical meaning):

OpenMP-like Parallel Programming

TODO
Syntactically this is not a good solution.

  • We avoid brackets in if and while, but then use it for reduce and schedule…
  • Syntax should be better, clearer, or more powerful than plain OpenMP, otherwise better use just that.