# Built-in Procedures

Built-in procedures are predeclared. They are called like any other procedure but some of them accept a type rather than an expression as their first argument.

Built-in procedures do not have standard types and cannot be passed around like a normal procedure.

## Length and capacity

The built-in procedures `len`

and `cap`

take arguments of various types and return a result of type `int`

or untyped int (if the value is constant). It is guaranteed that the value will fit into `int`

.

Both of these procedures allow a point to the argument type too.

```
Call Argument type Result
len(s) string type string length in bytes
[N]T array length (== N)
[vector N]T vector length (== N)
[]T slice length
[dynamic]T dynamic array length
map[K]T number of defined keys
cap(s) [N]T array length (== N)
[]T slice capacity
[dynamic]T dynamic array capacity
map[K]T capacity of values
```

The capacity of a slice and dynamic array is the number of elements for which there is space allocated for the underlying array. At any time, the following relation holds:

```
0 <= len(s) <= cap(s)
```

The length or capacity of a `nil`

slice, dynamic array or map is `0`

.

If the expression is constant, the length and/or capacity will be a constant untyped integer.

## Allocations

`new`

and `free`

and `make`

```
len, cap
make
size_of, align_of, offset_of
type_of, type_info_of
compile_assert
swizzle,
complex, quaternion
real, imag, jmag, kmag
conj
expand_to_tuple
min, max, abs, clamp
transmute
```