# Types¶

Gufo has a strict type system and do not allow implicit conversion. For exemple we cannot add a string to an integer.

Gufo’s types are implicitely infered.

## basic types:¶

- int
- string
- bool : standard true/false boolean
- float
- cmd: this is a special types representing the application of an external program. This is a basic type but owning field attributes.

## Aggregation types:¶

- list
- set : no order, no duplicated value.
- map : a map is a set of key values binded to values.
- tuple: a tuple is a sequence of value with potentially different types.

List, set and maps can only contains element of same type.

## How to use a list¶

A list is a structure where the new elements are added at the end of the elements already present.

List creation:

```
% let $myList = [ 1 , 2 ]
```

This create a list of 2 elements: 1 and then 2.

Access an element:

```
% $myList.[0] #Acess the first element
```

Concatenate a list with another one:

```
% let $myList = $myList with [ 3, 4 ]
```

So if you want to add only a single element:

```
% let $myList = $myList with [ 3 ]
```

You can use the list module for a deeper uses (length, iterator, map…):

```
% $List.length $myList
5
```

## How to use a set¶

A set contains elements without order. For a set of type T, a value T is present or absent from it. It cannot be present several times.

Similarly to a list:

```
% let $mySet = -< 1 , 2 >-
```

Check if an element is in a set:

```
% $Set.is_in $mySet 1
True
```

Concatenate a set with another one:

```
% let $mySet = $Set.union $mySet -< 3, 4 >-
```

So if you want to add only a single element:

```
% let $mySet = $mySet with [ 5 ]
```

You can use the set module for a deeper uses (length, iterator …):

```
% $Set.length $mySet
5
```

## How to use a map¶

A map is a set of key, with each key element beiing mapped to a given value. Each key have same type, and each value have same type.

Similarly to a list:

```
% let $myMap = -< 1: "Toto" , 2 : "Tata" >-
```

Check if an element has a key in the map:

```
% $Map.is_in $myMap 1
True
```

Concatenate a list with another one:

```
% let $myMap = $myMap with -< 3: "Titi", 4 : "Tutu">-
```

So if you want to add only a single element:

```
% let $myMap = $myMap with -< 3: "Tyty" >-
```

You can use the list module for a deeper uses (length, iterator, map…):

```
% $Map.length $myMap
5
```

## How to use a tuple¶

A tuple is a sequence of value with potentially different types. The separation character for a tuple is “–”. This is mainly used as a shortcut to variable declaration:

```
% let $a -- $b = 3 -- "Hello"
```

Allows to declare in a single line two variables, $a with value 3 and $b with value “Hello”.

## Struct type¶

Gufo has ‘struct’ composite types: a struct defines a type with determined and statically typed fields. Operators

## Operators¶

Gufo has predefined operators: every operator takes two arguments, here denoted by ‘a’ and ‘b’:

- a + b : with a and b as int (float) represents the addition of two integers(floats).
- a + b : with a and b as string represents the string concatenation operation.
- a – b : with a and b as int (float) represents the soustraction of two int (float)
- a * b : with a and b as int (float) represents the multiplication of two int (float)
- a / b : with a and b as int (float) represents the division of two int (float)
- a with b : with a and b a list of elements A represent the list concatenation.
- a with b : with a and b a set of elements A represent the set union.
- a with b : with a and b a of elements A as key and B as values represent a map merge (a union of the key set). if a key is present in both, the binded value becomes the one from b.
- a with b : with a a list of elements A and b an element of type A, return the list a with b added at the head of the list.
- a with b : with a a set of elements A and b an element of type A, return the set a union the singleton set containing b.
- a wout b : with a and b a set of elements A, return the set a without the elements from b.
- a wout b : with a and b a map of elements A as key and B as values, return the map a without the elements from b.

The types also contains standard libraries functions accessible though system modules: for exemple $Int.toStr is the function taking an integer argument and returning the corresding value as a string.