# Fift types (https://docs-i0yym09dy-ton-core-docs.vercel.app/llms/languages/fift/types/content.md)



<Callout type="note">
  The official smart contract language of TON Blockchain is [Tolk](/llms/tolk/overview/content.md). Fift is now a **legacy** language, with its compiler no longer maintained.
</Callout>

The Fift stack can contain values of the following types:

| Type           | Description                                                                                                                                                                                                                                             |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `Integer`      | A TVM signed 257-bit integer.                                                                                                                                                                                                                           |
| `Cell`         | A [TVM cell](/llms/foundations/serialization/cells/content.md) for persistent data storage on TON Blockchain. A cell consists of up to `1023` data bits and up to `4` references to other cells.                                                                        |
| `Slice`        | A TVM slice is a read-only view of a TVM cell that allows sequential access to the cell's data and references. A cell can be converted into a slice, extracting stored bits and references without modifying the original cell.                         |
| `Builder`      | A TVM builder is used to construct a cell by adding data and cell references.                                                                                                                                                                           |
| `Null`         | The TVM Null type has exactly one value `null`. In Fift, `null` is mostly used to initialize `Box`'es, hashmaps and lists. Usually denoted by `⊥`.                                                                                                      |
| `Tuple`        | A tuple is an ordered collection of values of any of the Fift types in this list, where each value is not necessarily of the same type.                                                                                                                 |
| `Continuation` | A [TVM continuation](/llms/tvm/continuations/content.md) employed for execution of [TVM code](/llms/tvm/instructions/content.md).                                                                                                                                                       |
| `String`       | A UTF-8 string.                                                                                                                                                                                                                                         |
| `Bytes`        | An arbitrary sequence of 8-bit bytes, typically used to represent binary data.                                                                                                                                                                          |
| `Box`          | A container occupying one stack slot, that can be used to store one value of any type. Usually used to represent variables and mutable data structures.                                                                                                 |
| `Atom`         | A simple entity uniquely identified by its name. Can be used to represent identifiers, labels, operation names, tags, and stack markers.                                                                                                                |
| `Object`       | An arbitrary C++ object. Entities like word lists, execution tokens and Fift hashmaps are represented as having the type `Object`. This type may also be used by Fift extensions to manipulate other data types and interface with other C++ libraries. |

The first seven types listed above are shared with TVM. Others are Fift-specific.

## No boolean type [#no-boolean-type]

There is no 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 execution of blocks and loops with exit conditions, any nonzero integer in the conditions is regarded as "true".

## Tuples [#tuples]

Tuples can be used to represent values of arbitrary algebraic data types and Lisp-style lists. Refer to the Tuples section in the [basic values page](/llms/languages/fift/basic-values/content.md).

## `Object` type [#object-type]

Many entities in Fift do not have a dedicated type, but they are assigned type `Object`. Fift provides words for creating and manipulating these entities.

Examples of entities of type `Object`:

* Word list: A partially created list of word references, used for creating an execution token. See section for blocks in the [control flow page](/llms/languages/fift/control/content.md). See also [Section 4.7](/llms/languages/fift/whitepaper/content.md) in the whitepaper for a list of words that create and manipulate word lists.
* Execution token: Fift code that can be executed and manipulated on the Fift stack. See section for blocks in the [control flow page](/llms/languages/fift/control/content.md) for more details.
* Fift hashmap: A hashmap specific for Fift. These hashmaps are not represented as cells, contrary to TVM hashmaps. As a comparison with TVM hashmaps, refer to [Section 6.3](/llms/languages/fift/whitepaper/content.md) in the whitepaper for a list of words that create and manipulate TVM hashmaps.