operators.txt

To do :
-------
- reg ex (~ ?)
- dot product (** ?)
- like type: maybe redundant with traits

Whitespace
----------
 //  end-of line comment
 /*  multi-line comment
 ;   definition separator (or parameter separator)
 .   end of statement (or member access)

Identifiers
-----------
 _   private identifier (inside identifier)
 /   multiple identifiers (or division)
 --  namespace
 .   member access (or end of statement)
 =   definition (or equality)

Comparisons
-----------
 =   equality (definition)
 !=  not equal
 <   less than
 <=  less than or equal
 >   greater than
 >=  greater than or equal

Arithmetic
----------
 %    modulo
 /    division (multiple identifiers)
 ^    exponentiation
 +    addition, unary positive
 *    multiplication
 -    subtraction, unary negative
 ??   default value if void
 ?    ternary expression (OR voidable type)
 ( )  brackets for priority (OR tuple)
 \    pipe function call

Logic
-----
 !    not
 &    and
 or   inclusive or
 xor  exclusive or

Scalar types
------------
 .    floating part (inside number)
 "    string with formatting
 '
 { }  formatting of a value (inside string)
 ()   void (without spacing)

Composite
---------
 ,      element separator (inside composite)
 ( )    tuples (or brackets for priority)
 [ ]    list, indexing
 ::     linked list
 <>     empty linked list
 { }    set, dictionary (after appropriate keyword)
 ->     dictionary key, function type (OR if pattern match)
 {| |}  record
 :      record member type (after member name)
 <|     modify record
 ++     inheritance, concatenation
 #      tag
 ?      voidable type (OR ternary expression)
 |      union type (OR case)
 ...    splat operator of enumerable (OR match any number of elements)
 -      generic parameter

Ranges
------
 ..=   inclusive range
 ..>=  inclusive range descending
 ..<   exclusive range
 ..>   exclusive range descending
 +..   range by length
 -..   range by length descending

Functions
---------
 $    lambda param
 =>   function return
 { }  inline code block
 ;    parameter separator (definition separator)
 :    explicit param lambda, function result type
 >>   composition

Pattern matching
----------------
 |    case (OR union type)
 @    match capture (inside match branch)
 ...  match any number of elements (OR splat operator of enumerable)
 _    match any
 ,    pattern separator (inside match branch)
 ->   if pattern match (OR dictionary key, function type)

Set operations
--------------
 {-}  set difference
 {+}  set union
 {&}  set intersection
 {*}  cartesian product
 {^}  cartesian power

Set comparisons
---------------
 {=}       set equality
 {!=}      set inequality
 {<} {<=}  is subset of
 {>} {>=}  is superset of

Unassigned symbols
------------------
 ~
 ><
 `
 **
 <<
 |>
 [<
 <]
 +>
 *>
 !>
 ?>
 %>
 \>
 :>
 >/