FunC types

FunC includes several built-in types that serve as the foundation of the language.

Atomic types

• int is a 257-bit signed integer type. Overflow checks are enabled by default and trigger an exception if exceeded.

• cell is a TVM cell type used to store persistent data in the TON Blockchain. Data is organized in trees of cells, with each cell containing up to 1023 bits of arbitrary data and up to four references to other cells. Cells function as memory units in stack-based TVMs.

• slice is a read-only view of a cell that allows sequential access to its data and references. A cell can be converted into a slice, extracting stored bits and references without modifying the original cell.

• builder is a mutable structure used to construct cells by adding data and references before finalizing them into a new cell.

• tuple is an ordered collection of up to 255 elements, each capable of holding a value of any type.

• cont is a TVM continuation used to manage execution flow in TVM programs. Although a low-level construct, it provides flexible execution control.

Each of these types occupies a single slot in the TVM stack.

No boolean type

FunC does not have a dedicated boolean type. Instead, booleans are represented as integers:

• false is 0, true is -1 (a 257-bit integer with all bits set to 1).
• Logical operations are performed using bitwise operations.
• In conditional checks, any nonzero integer is treated as true.

Null values

In FunC, the null value of the TVM type Null represents the absence of a value for a given atomic type. Any atomic type variable can have null to indicate absence of a value.

Since any atomic type allows null, it is important to be aware of the following regarding functions:

• Functions that return an atomic type may return null in some instances.
• Functions that expect an atomic type as input could also accept null.
• For library functions, the cases in which the function accepts null as valid input or output are explicitly described in the function specification.

As an illustration, function cell_depth(cell c) receives a cell as input, and its specification states that if the input cell is null, the function returns 0.

Hole type

FunC supports type inference. The hole types _ and var serve as placeholders that are resolved during type checking. For example, in the declaration:

var x = 2;

The type checker determines that x is of type int since 2 is an int, and both sides of the assignment must have matching types.

As another example, in the following function declaration (see Function declarations for more details):

_ someFunction(int a) {
  return a + 1;
}

the type checker is able to infer that _ must have type int, since the type of the returned expression a + 1 is int.

Composite types

Types can be combined to form more complex structures.

Functional type

A functional type is written in the form A -> B, where:

• A is the input type, which is called domain.
• B is the output type, which is called codomain.

Example: The type int -> cell represents a function that:

• Takes an integer as input.
• Returns a TVM cell as output.

Like in functional programming, it is possible to declare functional types which have in their domain and codomain other functional types. For example, (int -> int) -> int is a function with domain int -> int and codomain int. Similarly, int -> (int -> int) is a function with domain int and codomain int -> int.

Tensor types

Tensor types represent ordered collections of values and are written in the form (A, B, ...). These types occupy multiple TVM stack entries, unlike atomic types, which use a single entry.

Example: If a function foo has the type int -> (int, int), it takes one integer as input and returns a pair of integers as output. A call to this function may look like: (int a, int b) = foo(42);. Internally, the function consumes one stack entry and produces two.

Type representation: Although the values (2, (3, 9)) of type (int, (int, int)) and (2, 3, 9) of type (int, int, int) are stored identically as three stack entries (2, 3, and 9), FunC treats them as distinct types. For instance, the following code will not compile:

(int a, int b, int c) = (2, (3, 9));

since FunC strictly enforces type consistency, these structures cannot be mixed.

A type of the form (A) is considered by the type checker as the same type as A.

Special case: unit type() The unit type () is used to indicate that:

• A function does not return a value or
• A function takes no arguments

The unit type () has a single value, also written as (), occupying zero stack entries.

Examples

• print_int has the type int -> (), meaning it takes an integer but returns nothing.
• random has the type () -> int, meaning it takes no arguments but returns an integer.

Tuple types

Tuple types in FunC are written in the form [A, B, ...] and represent TVM tuples with a fixed length and known component types at compile time.

For example, [int, cell] defines a tuple with exactly two elements:

• The first element is an integer.
• The second element is a cell.

The type [] represents an empty tuple with a unique value—the empty tuple itself.

Note: Unlike the unit type (), an empty tuple [] occupies one stack entry.

Polymorphism with type variables

FunC features a custom type system with support for polymorphic functions. For example, consider the following function:

forall X -> (X, X) duplicate(X value) {
  return (value, value);
}

Here, X is a type variable that allows the function to operate on values of any type. Type variables are declared after forall and before of ->. The function receives a value of type X, and duplicates this value to return a value of type (X, X).

For example,

• Calling duplicate(6) produces (6, 6).
• Calling duplicate([]) produces two copies of an empty tuple: ([], []).

At the moment, type variables in polymorphic functions cannot be instantiated with tensor types. There is only one exception: the tensor type (a), where a is not a tensor type itself, since the compiler treats (a) as if it was a.

For more details, see the Polymorphism with forall section.

User-defined types

Currently, FunC does not support defining custom types beyond the type constructions described above.

Type width

Every value in FunC occupies a certain number of stack entries. If this number is consistent for all values of a given type, it is called the type width.

For example, all atomic types have a type width of 1, because all their values occupy a single stack entry. The tensor type (int, int) has type width 2, because all its values occupy 2 stack entries.