Any TeX name defined as class ORD in TeX can be used in Felix as an identifier. This includes all the usual Greek letters.

  var \(\alpha\) = 1;
  fun \(\Gamma\) (x:int)=> x * x;
  println$ \(\Gamma\)\(\alpha\);

Pair \lceil,\rceil and \lfloor,\rfloor, mapped by the parser to the functions ceil and floor, defined for real floating types. The result is a floating type, not an integer!

  println$ \(\lceil x + 2.3 \rceil + \lfloor 2.3 \rfloor + 0.1\);
  

Using \lvert,\rvert pair or \left\lvert,\right\rvert, or \left|,\right| mapping to function abs, defined for integers, reals, and complex numbers. Using \lVert,\rVert pair or \left\lVert,\right\rVert mapping to function len, defined for container and array class data structures and strings.

  println$ \( \lvert -2.3 \rvert \);
  println$ \( \lvert "{\mathtt{\text{Hello}}}" \rvert \);
  println$ \( \lVert 1,2,3 \rVert \);
  

The square root is only available in math mode. Unless it's argument is a single symbol, grouping operators are required to get the overline in the right place.

  var x = 4.0;
  println$ \( \sqrt {(x + 2.0 )}\);
  

The parser recognises the \over binary operator with a low precedence and maps it to the division function /. Correct display requires math mode.

  println$ \(x + 1.0 \over 2.0\);
  

The two bracket forms \brace and \brack have the same precedence as \over and map to arbitrary binary functions of two arguments. They require mathmode to display correctly.

  fun \(\brace\) (x:int, y:int) => x + 2 * y;
  fun \(\brack\) (x:int, y:int) => x + 2 * y;
  println$ \( 2 \brace 3 \) + \( 2 \brack 3 \);
  

Felix provides syntax to negate infix predicate symbols including comparison operators. Both not and \not can be used and are semantically equivalent, however the \not only displays correctly in math mode preceding an operator without a strikethrough.

  println$ (1,2,3) \(\subset\) (1,2);
  println$ (1,2,3) \(\nsubseteq\) (1,2);
  println$ \( {(1,2,3)} \not \subseteq {(1,2)} \); 
  println$ (1,2,3) not \(\subseteq\) (1,2);
  println$ not \( {(1,2,3)} \subseteq {(1,2)} \); 
  println$ \( {(1,2,3)} \not \supset {(1,2)} \);
  println$ not \(\subset\) ((1,2,3),(1,2));
  println$  2 \(\not\)< 1;
  
  

Available for all class Set, which includes all Container. Defined for arrays, and most container types including list, varray, darray, bsarray. Defined for strings and regular expressions too. [TODO: ralist, sarray]

  
  println$ mem (2, (1,2,34));      
  println$ 2 in (1,2,3,4);         
  println$ 2 \(\in\) (1,2,3,4);       
  println$ (1,2,3,4) \(\ni\) 2;      
  println$ (1,2,3,4) \(\owns\) 2;   
  println$ 5 \(\notin\) (1,2,3,4);  
  println$ 2 \(\in\) varray (1,2,3,4);
  println$ 2 \(\in\) darray (1,2,3,4);
  println$ 2 \(\in\) list (1,2,3,4);
  println$ char "2" \(\in\) "1234";
  println$ "abaa" \(\in\) RE2 "(a|b)*a";
  

Felix provides a construction known as a set form which defines a set like object based on a predicate. The syntax is { pattern : type | boolexpr } where you can also use \{\} brackets and \| or \mid for the vertical bar.

Technically a set form is a value of type set_form[T] which is an object with a method has_elt : T -> bool. We then provide the membership operator for set forms so you can write code like this:

  var oddints = { x : int | x % 2 == 1 };
  println$ 1 \(\in\) oddints;
  println$ \( {(3,9)} \in  {\{ x,y : {\mathtt{\text{int}}} * {\mathtt{\text{int}}} \mid x * x == y \}} \);
  

Felix defines setlike relations for where the arguments are in both Streamable and Set.

In some cases such as the subset or equal, we only require the left operand to be in Streamable and the right operand to be in Set.

The default implementation of subset or equal streams all values of the LHS container and checks if that value is in the RHS argument. This implementation is inefficient, but it does allow the RHS to be infinite, for example a regular expression.

These relations construe containers as sets and so ignore duplicates. We use the congruence operator to mean equal as sets. Two arrays, for example, may be equal as sets because they contain the same set of elements, even though the ordering is different and different elements may be duplicated, so that the arrays are not equal as arrays.

Furthermore note that the operands may be completely different data structures and thus different types, however they must support the same value type.

  println$ (varray (1,2)) \(\cong\) (varray (1,2,3));
  println$ (varray (1,2)) \(\cong\) (darray (1,2,2));
  println$ ("aba","ababba") \(\subseteq\) RE2 "(a|b)*a";
  
  println$ (1,2) \(\subset\) (1,2,3);
  println$ (1,2) \(\subseteq\) (varray (1,2,3));
  println$ (1,2) \(\subseteqq\) (varray (1,2,3));
  println$ (1,2) \(\subsetneq\) (varray (1,2,3));
  println$ (1,2) \(\subsetneqq\) (varray (1,2,3));
  
  println$ (1,2,3) \(\supset\) (1,2);
  println$ (1,2,3) \(\supseteq\) (1,2);
  println$ (1,2,3) \(\supseteqq\) (1,2);
  println$ (1,2,3) \(\supsetneq\) (1,2);
  println$ (1,2,3) \(\supsetneqq\) (1,2);
  
  println$ (1,2,3) \(\nsubseteq\) (1,2);
  println$ (1,2,3) \(\nsubseteqq\) (1,2);
  
  println$ (1,2) \(\nsupseteq\) (1,2,3);
  println$ (1,2) \(\nsupseteqq\) (1,2,3);
  

Felix currently provides set operators. They can be used with sets of type in the type language as well as with set forms. Set operators can also be used with data structures of kind Set[C,V], however the result is a set form, not a similar data structure. For example the union of two arrays is a set form that tests if an element is a member of one array or the other, not an array.

  typedef sregints = typesetof (int, long);
  typedef uregints = typesetof (uint, ulong);
  typedef regints = sregints \(\cup\) uregints;
  fun f[T:regints] : T -> T = "$1+1";
  println$ f 1, f 1u, f 1uL;
  println$ 10 \(\in\) { x : int | 2 <= x } \(\cap\) { x : int | x < 20 };
  println$  10 \(\in\) (1,2,3) \(\cup\) (9,10,11);
  

Sums and products of values of data structures.

  
  println$ \( \sum {(1,2,3,4)} \) ;
  println$ \(\prod\) (1,2,3,4);
  
  
  println$ \(\sum\) (1,2,3,4).darray;
  println$ \(\prod\) (1,2,3,4).darray;
  
  
  println$ \(\sum\) (1,2,3,4).list;
  println$ \(\prod\) (1,2,3,4).list;
  
  gen odds (x:int, y:int) () = {
    for var i:int in x upto y do
      if y % 2 == 1 do yield Some i; done
    done
    return None[int];
  }
  
  println$ \(\sum\) (odds (1,7));
  

Forms the categorical (parallel) product or sum of a tuple of functions.

  fun f (x:int) : int => x + 1;
  fun g (x:int): string  => x.str+"!";
  fun h (x:double) :string => x.str+"!";
  
  var fgx = \(\prod\) (f,g,h);
  println$ fgx (1,2,3.1);
  
  
  var fgs = \(\sum\) (f,g,h);
  var d1 = (case 1 of (int + int + double)) 42;
  var c1 : int + string + string = fgs d1;
  match c1 with
  | case 0 i => println$ "Case 0 " + i.str;
  | case 1 s => println$ "Case 1 " + s;
  | case 2 s => println$ "Case 2 " + s;
  endmatch;