Skip to main content

Flex Standard Library

The Flex Standard Library Overview​

This page of documentation is intended to provide an overview of functionality built into the Flex specification language. Included in this page is documentation on Flex's primitive types, any functionality a user needs to use these types, and an overview of included syntax.

Primitive Types​

Flex has a collection of primitive types that are automatically available without any imports. These are as follows:

  • bit -- either true or false
  • intN -- a value from -2^(N-1) to 2^(N-1) - 1 inclusive, where N is a positive integer

    Transpiler supported widths: int8, int16, int32, int64

  • uintN -- a value from 0 to 2^N - 1 inclusive, where N is a positive integer

    Transpiler supported widths: uint8, uint16, uint32, uint64

  • float32 -- a single precision floating point number as defined by the IEEE 754 standard
  • float64 -- a double precision floating point number as defined by the IEEE 754 standard
  • string -- a sequence of characters (e.g., "foo")

Flex also has several primitive type constructors with special syntax. If T, T0, T1, ..., Tn are arbitrary types, then the following are also types:

  • T[] -- an array of values of type T
  • Optional<T> -- either none or some(t) where t: T
  • (T0, T1, ..., Tn) -- a tuple

For more details see the expressions section.

Built-in Functions​

length​

flex
function length<T>(x : T[]) -> int32

Returns the length (number of elements) of the array argument.

last​

flex
function last<T>(x : T[]) -> T

Returns the last element of the array argument.

Note: fails if the argument array is empty.

floor​

flex
function floor(x : float64) -> Optional<int64>

Returns the largest possible 64 bit integer value which is less than or equal to the argument.

float64to32​

flex
function float64to32(x : float64) -> float32

Returns the 32 bit version of the argument .

Note: since float64 is has two times the precision of float32 this conversion is an approximation of the original argument.

sin​

flex
function sin(x : float64) -> float64

Returns the sine of the argument.

Note: the argument is expected to be in radians.

cos​

flex
function cos(x : float64) -> float64

Returns the cosine of the argument.

Note: the argument is expected to be in radians.

tan​

flex
function tan(x : float64) -> float64

Returns the tangent of the argument.

Note: the argument is expected to be in radians.

atan2​

flex
function atan2(y : float64, x: float64) -> float64

Returns the theta component of the point (r, theta) in polar coordinates that corresponds to the point (x, y) in Cartesian coordinates.

Parameters

y: the abscissa coordinate

x: the ordinate coordinate

asin​

flex
function asin(x : float64) -> float64

Returns the arc sine of the argument.

Note: the argument is expected to be in radians.

sqrt​

flex
function sqrt(x : float64) -> float64

Returns the square root of the argument.

Note: If sqrt is given a negative argument a failure occurs.

The transpiler is responsible for determining what a failure means in the output language.

pow​

flex
function pow(x : float64, y : float64) -> float64

pow(x,y) Returns x raised to the power of y.

getOrElse​

flex
function getOrElse<T>(x : Optional<T>, y: T) -> T

Returns the v if x is some(v), or a default value y when x is none. Used with optional data types, and value casting. For more details see Value Casting.

some​

Constructor for an the Optional type taking a single argument. For more details see Pattern Matching > Some and None

Written some(x) for an x of any type.

none​

Constructor for an optional value taking no arguments. For more details see Pattern Matching > Some and None

Written: none constructing a type Optional<T>

const x : Optional<float64> = none;

Syntax Overview​

Further Information

Keywords​

const​

Declare an immutable global value

Type ascription is required

flex
const x : int32 = 0;

struct​

Declare a structured type composed of fields that each have an explicitly declared type

flex
struct Position {
    x : float32;
    y : float32;
};

message​

Declare a message type that can be used as a Message in Tangram ProTM, and used as input or output for a transform

Applies to struct declaration

Creates an ontologically significant term to be used in a Transform

flex
message struct Position {
    x : float32; 
    y : float32; 
};

newtype​

Declare a new struct like type containing a single field

Allows a user to get compile time guarantees about normally non distinct values

Has ontological significance in Flex and can be used as input or output for a transform

flex
newtype Altitude {
    value: int32;
};

variant​

Declare a a type that can be one of several "variants"

flex
variant Angle {
    DMS(int32, int32, int32);
    Radians(float64);
};

enum​

Declare an enumerated type consisting of constants of some declared type

If the type is integral this will be equivalent to enums in C++

flex
enum SimulationStatus int32 {
  Stopped = 0;
  Running = 1;
  Paused = 2;
  Reset = 3;
};

function​

Declare a function

flex
function square(x : float64) -> float64 {
    x * x;
};

transform​

Declare a transform function that can be used as a Transform in Tangram ProTM over terms which are ontologically significant. 

flex
transform Celsius2Fahrenheit(c : Celsius) -> Fahrenheit =
  Fahrenheit {
    temp = c.temp * 9.0 / 5.0 + 32.0;
  };

let​

  • let Bind a value to an identifier

    Values bound like this are immutable Type is optional when it can be inferred can be inferred

flex
let x = 1.0 : float32; 
x + 1.0; 
let x : float32 = 1.0; 
x + 1.0;

match​

  • Pattern matching control flow
flex
match(optional_value) {
    some(value) => value; 
    none => default; 
}

assert​

  • Refinement of data and specification of correctness properties 
flex
message struct Position {
    x : float32; 
    y : float32; 
    assert x > 0.0 and x < 10.0; 
    assert y > 0.0; 
};
let x : int32 = {
  assert x > 0; 
  x + 1;
};

for​

  • Used in the list comprehension syntax

    Used to construct a new list using each value of a pre-existing list. 

flex
const xs: uint8[] = [2,4,6,20];
const xsPlusOne: = [x + 1 for x in xs]
//              ~> [3, 5, 7, 21]: uint8[]
flex
const ys: uint8[] = [2,4,6,20,21];
const evens = [y + 1 for x in ys if y % 2 == 0]
//         ~> [2,4,6,20]

scan​

  • Used to define operations over a collection

    An accumulation value is defined to the right of the scan keyword and it's initial value is set Returns a list of intermediate and final values of the accumulator

flex
const sums: uint8[] = [cumulSum for x in [2,4,6,8] scan cumulSum: uint8 = 0 in cumulSum + x]
//                 ~> [2, 6, 12, 20]: uint8[]

Operators​

  • Arithmetic: +, -, /, *, % Defined for numeric types
  • Comparison: <, >, <=, >= Defined for numeric types
  • Equality: ==, != Defined for primitive types that are not type constructors
  • Boolean: &&, ||, ! Defined for bit
  • Bitwise: &, |, ~, ^ (Xor) Defined for bit, intN, uintN

Literals​

  • Bit literals are true and false
  • String literals are delimited by double quotes. "This is a string"
  • Floating literals contain a decimal point. 1.618 and 0.05 are valid, whereas 1, 1. and .05 are invalid
  • Type ascription is allowed for any flex expression. x : T for some type T and value x
  • Array literals are delimited with square brackets. [1,2,3] : int32[]
  • Tuple literals are delimited with parentheses. (1,false,"foo") : (int32,bit,string)
  • Hexadecimal literals begin with 0x
  • Binary literals begin with 0b
  • Integers can be represented as 0 in intN and uintN

    Types must be able to be inferred for integer literals or explicitly ascribed

  • Underscores _ can be used in numeric literals as digit separators. 1_000_000 is equivalent to 1000000