> For the complete documentation index, see [llms.txt](https://fluence.gitbook.io/aqua-book/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://fluence.gitbook.io/aqua-book/language/types.md). # Types ## Scalars Scalar types follow the Wasm IT notation. * Unsigned numbers: `u8`, `u16`, `u32`, `u64` * Signed numbers: `i8`, `i16`, `i32`, `i64` * Floats: `f32`, `f64` * Boolean: `bool` * String: `string` * Records (product type): see below * Arrays: see [Collection Types](/aqua-book/language/types.md#collection-types) below ## Literals You can pass booleans (true, false), numbers, double-quoted strings as literals. ## Products ```haskell data ProductName: field_name: string data OtherProduct: product: ProductName flag: bool ``` Fields are accessible with the dot operator `.` , e.g. `product.field`. ## Collection Types Aqua has three different types with variable length, denoted by quantifiers `[]`, `*`, and `?`. Immutable collection with 0..N values: `[]` Immutable collection with 0 or 1 value: `?` Appendable collection with 0..N values: `*` Any data type can be prepended with a quantifier, e.g. `*u32`, `[][]string`, `?ProductType` are all correct type specifications. You can access a distinct value of a collection with `!` operator, optionally followed by an index. It is possible to fill any collection with an empty one using `nil`. Examples: ```haskell strict_array: []u32 array_of_arrays: [][]u32 element_5 = strict_array!5 element_0 = strict_array!0 element_0_anotherway = strict_array! -- It could be an argument or any other collection maybe_value: ?string -- This ! operator will FAIL if maybe_value is backed by a read-only data structure -- And will WAIT if maybe_value is backed with a stream (*string) value = maybe_value! -- Consider a function that takes a collection as an argument func foo(a: ?string, b: []u32, c: *bool): ... -- To call that function with empty collection, use nil, [], ?[], or *[]: foo(nil, [], *[]) -- Nil fits into any collection ``` ## Arrow Types Every function has an arrow type that maps a list of input types to an optional output type. It can be denoted as: `Type1, Type2 -> Result` In the type definition, the absence of a result is denoted with `()`, e.g., `string -> ()` The absence of arguments is denoted `-> ()`.That is, this mapping takes no argument and has no return type. Note that there's no `Unit` type in Aqua: you cannot assign a non-existing result to a value. ```haskell -- Assume that arrow has type: -> () -- This is possible: arrow() -- This will lead to error: x <- arrow() ``` ## Type Alias For convenience, you can alias a type: ```haskell alias MyAlias : ?string ``` ## Type Variance Aqua is made for composing data on the open network. That means that you want to compose things if they do compose, even if you don't control its source code. Therefore Aqua follows the structural typing paradigm: if a type contains all the expected data, then it fits. For example, you can pass `u8` in place of `u16` or `i16`. Or `?bool` in place of `[]bool`. Or `*string` instead of `?string` or `[]string`. The same holds for products. For arrow types, Aqua checks the variance on arguments and contravariance on the return type. ```haskell -- We expect u32 xs: *u32 -- u16 is less then u32 foo1: -> u16 -- works xs <- foo1() -- i32 has sign, so cannot fit into u32 foo2: -> i32 -- will fail xs <- foo2() -- Function takes an arrow as an argument func bar(callback: u32 -> u32): ... foo3: u16 -> u16 -- Will not work bar(foo3) foo4: u64 -> u16 -- Works bar(foo4) ``` Arrow type `A: D -> C` is a subtype of `A1: D1 -> C1`, if `D1` is a subtype of `D` and `C` is a subtype of `C1`. ## Type Of A Service And A File A service type is a product of arrows. ```haskell service MyService: foo(arg: string) -> bool -- type of this service is: data MyServiceType: foo: string -> bool ``` The file is a product of all defined constants and functions (treated as arrows). Type definitions in the file do not go to the file type. ```haskell -- MyFile.aqua func foo(arg: string) -> bool: ... const FLAG ?= true -- type of MyFile.aqua data MyServiceType: foo: string -> bool flag: bool ``` See [Imports and Exports](/aqua-book/language/header.md#module) for module declarations. {% embed url="" %} See the types system implementation {% endembed %} --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://fluence.gitbook.io/aqua-book/language/types.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.