141 lines
3.5 KiB
Markdown
141 lines
3.5 KiB
Markdown
---
|
|
id: list-reference
|
|
title: List
|
|
---
|
|
|
|
## List.size(lst: a' list) : nat
|
|
|
|
Get the number of elements in a list.
|
|
|
|
<!--DOCUSAURUS_CODE_TABS-->
|
|
|
|
<!--PascaLIGO-->
|
|
```pascaligo
|
|
function size_ (const m : list(int)) : nat is size(m)
|
|
```
|
|
|
|
<!--CameLIGO-->
|
|
```cameligo
|
|
let size_ (s: int list) : nat = List.size s
|
|
```
|
|
|
|
<!--ReasonLIGO-->
|
|
```reasonligo
|
|
let size_ = (s: list(int)): nat => List.size(s);
|
|
```
|
|
|
|
<!--END_DOCUSAURUS_CODE_TABS-->
|
|
|
|
## List.length(lst: a' list) : nat
|
|
|
|
Alias of `List.size`.
|
|
|
|
## List.map(map_function: a' -> b', lst: a' list) : 'b list
|
|
|
|
Apply an operation defined by `map_function` to each element of a list and return
|
|
a list of the modified elements.
|
|
|
|
<!--DOCUSAURUS_CODE_TABS-->
|
|
<!--Pascaligo-->
|
|
```pascaligo group=b
|
|
function increment(const i: int): int is i + 1;
|
|
// Creates a new list with elements incremented by 1
|
|
const incremented_list: list(int) = list_map(increment, list 1; 2; 3; end );
|
|
```
|
|
|
|
<!--CameLIGO-->
|
|
|
|
```cameligo group=b
|
|
let increment (i: int) : int = i + 1
|
|
(* Creates a new list with elements incremented by 1 *)
|
|
let incremented_list: int list = List.map increment [1; 2; 3]
|
|
```
|
|
|
|
|
|
<!--ReasonLIGO-->
|
|
|
|
```reasonligo group=b
|
|
let increment = (i: int): int => i + 1;
|
|
(* Creates a new list with elements incremented by 1 *)
|
|
let incremented_list: list(int) = List.map(increment, [1, 2, 3]);
|
|
```
|
|
|
|
<!--END_DOCUSAURUS_CODE_TABS-->
|
|
|
|
## List.iter(iter_function: a' -> unit, lst: a' list) : unit
|
|
|
|
Apply a side effecting function `iter_function` to each element of a list with no
|
|
return value. This is useful for asserting that each element of a list satisfies
|
|
a particular property.
|
|
|
|
<!--DOCUSAURUS_CODE_TABS-->
|
|
|
|
<!--PascaLIGO-->
|
|
```pascaligo
|
|
function iter_op (const s : list(int)) : int is
|
|
begin
|
|
var r : int := 0 ;
|
|
function aggregate (const i : int) : unit is
|
|
begin
|
|
r := r + i ;
|
|
end with unit ;
|
|
list_iter(aggregate, s) ;
|
|
end with r
|
|
```
|
|
|
|
<!--CameLIGO-->
|
|
```cameligo
|
|
let iter_op (s : int list) : unit =
|
|
let do_nothing = fun (_: int) -> unit
|
|
in List.iter do_nothing s
|
|
```
|
|
|
|
<!--ReasonLIGO-->
|
|
```reasonligo
|
|
let iter_op = (s: list(int)): unit => {
|
|
let do_nothing = (z: int) => unit;
|
|
List.iter(do_nothing, s);
|
|
};
|
|
```
|
|
|
|
<!--END_DOCUSAURUS_CODE_TABS-->
|
|
|
|
## List.fold(fold_function: (a' * a') -> a', lst: a' list, acc: a') : 'a
|
|
|
|
Combine the elements of a list into one value using the operation defined by
|
|
`fold_function'. For example, you could define summation by folding a list of
|
|
integers. Starting with some initial accumulator value `acc`, the fold:
|
|
|
|
1. Consumes an element of the list.
|
|
2. Passes the accumulator value to `fold_function` along with the element to produce
|
|
a new accumulated value.
|
|
3. The new accumulated value replaces the previous one.
|
|
4. IF there are still elements in the list go back to 1, ELSE return the accumulator
|
|
|
|
Summation would be defined then by using a `fold_function` that takes two integers and
|
|
adds them together. Each step of the fold would consume an element from the list
|
|
and add it to the total until you've summed over the list.
|
|
|
|
<!--DOCUSAURUS_CODE_TABS-->
|
|
<!--Pascaligo-->
|
|
```pascaligo group=b
|
|
function sum(const result: int; const i: int): int is result + i;
|
|
const sum_of_a_list: int = list_fold(sum, list 1; 2; 3; end, 0);
|
|
```
|
|
|
|
<!--CameLIGO-->
|
|
|
|
```cameligo group=b
|
|
let sum (result, i: int * int) : int = result + i
|
|
let sum_of_a_list: int = List.fold sum [1; 2; 3] 0
|
|
```
|
|
|
|
<!--ReasonLIGO-->
|
|
|
|
```reasonligo group=b
|
|
let sum = ((result, i): (int, int)): int => result + i;
|
|
let sum_of_a_list: int = List.fold(sum, [1, 2, 3], 0);
|
|
```
|
|
|
|
<!--END_DOCUSAURUS_CODE_TABS-->
|