balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

fix broken .md file (sets-lists-tuples)

Browse Source
This commit is contained in:
Lesenechal Remi 2020-02-06 13:32:51 +01:00
parent 9f9f5c82ae
commit c82ae6359a
1 changed files with 51 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

111
gitlab-pages/docs/language-basics/sets-lists-tuples.md
View File

@ -128,43 +128,39 @@ let my_list : list (int) = [1, 2, 2]; // The head is 1
### Adding to a List ### Adding to a List
<!--DOCUSAURUS_CODE_TABS-->
Lists can be augmented by adding an element before the head (or, in Lists can be augmented by adding an element before the head (or, in
terms of stack, by *pushing an element on top*). This operation is terms of stack, by *pushing an element on top*). This operation is
usually called *consing* in functional languages. usually called *consing* in functional languages.
<!--Pascaligo-->
In PascaLIGO, the *cons operator* is infix and noted `#`. It is not In PascaLIGO, the *cons operator* is infix and noted `#`. It is not
symmetric: on the left lies the element to cons, and, on the right, a symmetric: on the left lies the element to cons, and, on the right, a
list on which to cons. (The symbol is helpfully asymmetric to remind list on which to cons. (The symbol is helpfully asymmetric to remind
you of that.) you of that.)
```pascaligo group=b
const larger_list : list (int) = 5 # my_list
```
<!--CameLIGO-->
In CameLIGO, the *cons operator* is infix and noted `::`. It is not In CameLIGO, the *cons operator* is infix and noted `::`. It is not
symmetric: on the left lies the element to cons, and, on the right, a symmetric: on the left lies the element to cons, and, on the right, a
list on which to cons. list on which to cons.
```cameligo group=b
let larger_list : int list = 5 :: my_list
```
<!--ReasonLIGO-->
In ReasonLIGO, the *cons operator* is infix and noted `, ...`. It is In ReasonLIGO, the *cons operator* is infix and noted `, ...`. It is
not symmetric: on the left lies the element to cons, and, on the not symmetric: on the left lies the element to cons, and, on the
right, a list on which to cons. right, a list on which to cons.
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
```pascaligo group=b
const larger_list : list (int) = 5 # my_list
```
<!--CameLIGO-->
```cameligo group=b
let larger_list : int list = 5 :: my_list
```
<!--ReasonLIGO-->
```reasonligo group=b ```reasonligo group=b
let larger_list : list (int) = [5, ...my_list]; let larger_list : list (int) = [5, ...my_list];
``` ```
<!--END_DOCUSAURUS_CODE_TABS--> <!--END_DOCUSAURUS_CODE_TABS-->
<br/> <br/>
@ -187,41 +183,32 @@ functions in LIGO. They take as a parameter the function to apply to
all the elements. Of course, that function must return a value of the all the elements. Of course, that function must return a value of the
same type as the element. same type as the element.
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
In PascaLIGO, the map function is called `list_map`. In PascaLIGO, the map function is called `list_map`.
In CameLIGO and ReasonLIGO, the map function is called `List.map`.
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
```pascaligo group=b ```pascaligo group=b
function increment (const i : int): int is i + 1 function increment (const i : int): int is i + 1
// Creates a new list with all elements incremented by 1 // Creates a new list with all elements incremented by 1
const plus_one : list (int) = list_map (increment, larger_list) const plus_one : list (int) = list_map (increment, larger_list)
``` ```
<!--CameLIGO--> <!--CameLIGO-->
In CameLIGO, the map function is called `List.map`.
```cameligo group=b ```cameligo group=b
let increment (i : int) : int = i + 1 let increment (i : int) : int = i + 1
// Creates a new list with all elements incremented by 1 // Creates a new list with all elements incremented by 1
let plus_one : int list = List.map increment larger_list let plus_one : int list = List.map increment larger_list
``` ```
<!--ReasonLIGO--> <!--ReasonLIGO-->
In CameLIGO, the map function is called `List.map`.
```reasonligo group=b ```reasonligo group=b
let increment = (i : int) : int => i + 1; let increment = (i : int) : int => i + 1;
// Creates a new list with all elements incremented by 1 // Creates a new list with all elements incremented by 1
let plus_one : list (int) = List.map (increment, larger_list); let plus_one : list (int) = List.map (increment, larger_list);
``` ```
<!--END_DOCUSAURUS_CODE_TABS--> <!--END_DOCUSAURUS_CODE_TABS-->
@ -278,16 +265,17 @@ let my_set : set (int) = (Set.empty : set (int));
### Non-empty Sets ### Non-empty Sets
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
In PascaLIGO, the notation for sets is similar to that for lists, In PascaLIGO, the notation for sets is similar to that for lists,
except the keyword `set` is used before: except the keyword `set` is used before:
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
```pascaligo group=a ```pascaligo group=a
const my_set : set (int) = set [3; 2; 2; 1] const my_set : set (int) = set [3; 2; 2; 1]
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
You can check that `2` is not repeated in `my_set` by using the LIGO You can check that `2` is not repeated in `my_set` by using the LIGO
compiler like this (the output will sort the elements of the set, but compiler like this (the output will sort the elements of the set, but
@ -299,16 +287,17 @@ gitlab-pages/docs/language-basics/src/sets-lists-tuples/sets.ligo my_set
# Outputs: { 3 ; 2 ; 1 } # Outputs: { 3 ; 2 ; 1 }
``` ```
<!--CameLIGO-->
In CameLIGO, there is no predefined syntactic construct for sets: you In CameLIGO, there is no predefined syntactic construct for sets: you
must build your set by adding to the empty set. (This is the way in must build your set by adding to the empty set. (This is the way in
OCaml.) OCaml.)
<!--DOCUSAURUS_CODE_TABS-->
<!--CameLIGO-->
```cameligo group=a ```cameligo group=a
let my_set : int set = let my_set : int set =
Set.add 3 (Set.add 2 (Set.add 2 (Set.add 1 (Set.empty : int set)))) Set.add 3 (Set.add 2 (Set.add 2 (Set.add 1 (Set.empty : int set))))
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
You can check that `2` is not repeated in `my_set` by using the LIGO You can check that `2` is not repeated in `my_set` by using the LIGO
compiler like this (the output will sort the elements of the set, but compiler like this (the output will sort the elements of the set, but
@ -320,16 +309,17 @@ gitlab-pages/docs/language-basics/src/sets-lists-tuples/sets.mligo my_set
# Outputs: { 3 ; 2 ; 1 } # Outputs: { 3 ; 2 ; 1 }
``` ```
<!--ReasonLIGO-->
In ReasonLIGO, there is no predefined syntactic construct for sets: In ReasonLIGO, there is no predefined syntactic construct for sets:
you must build your set by adding to the empty set. (This is the way you must build your set by adding to the empty set. (This is the way
in OCaml.) in OCaml.)
<!--DOCUSAURUS_CODE_TABS-->
<!--ReasonLIGO-->
```reasonligo group=a ```reasonligo group=a
let my_set : set (int) = let my_set : set (int) =
Set.add (3, Set.add (2, Set.add (2, Set.add (1, Set.empty : set (int))))); Set.add (3, Set.add (2, Set.add (2, Set.add (1, Set.empty : set (int)))));
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
You can check that `2` is not repeated in `my_set` by using the LIGO You can check that `2` is not repeated in `my_set` by using the LIGO
compiler like this (the output will sort the elements of the set, but compiler like this (the output will sort the elements of the set, but
@ -341,71 +331,63 @@ gitlab-pages/docs/language-basics/src/sets-lists-tuples/sets.religo my_set
# Outputs: { 3 ; 2 ; 1 } # Outputs: { 3 ; 2 ; 1 }
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
### Set Membership ### Set Membership
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
PascaLIGO features a special keyword `constains` that operates like an PascaLIGO features a special keyword `constains` that operates like an
infix operator checking membership in a set. infix operator checking membership in a set.
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
```pascaligo group=a ```pascaligo group=a
const contains_3 : bool = my_set contains 3 const contains_3 : bool = my_set contains 3
``` ```
<!--CameLIGO--> <!--CameLIGO-->
```cameligo group=a ```cameligo group=a
let contains_3 : bool = Set.mem 3 my_set let contains_3 : bool = Set.mem 3 my_set
``` ```
<!--ReasonLIGO--> <!--ReasonLIGO-->
```reasonligo group=a ```reasonligo group=a
let contains_3 : bool = Set.mem (3, my_set); let contains_3 : bool = Set.mem (3, my_set);
``` ```
<!--END_DOCUSAURUS_CODE_TABS--> <!--END_DOCUSAURUS_CODE_TABS-->
### Cardinal ### Cardinal
<!--DOCUSAURUS_CODE_TABS--> <!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo--> <!--Pascaligo-->
```pascaligo group=a ```pascaligo group=a
const set_size : nat = size (my_set) const set_size : nat = size (my_set)
``` ```
<!--CameLIGO--> <!--CameLIGO-->
```cameligo group=a ```cameligo group=a
let set_size : nat = Set.size my_set let set_size : nat = Set.size my_set
``` ```
<!--ReasonLIGO--> <!--ReasonLIGO-->
```reasonligo group=a ```reasonligo group=a
let set_size : nat = Set.size (my_set); let set_size : nat = Set.size (my_set);
``` ```
<!--END_DOCUSAURUS_CODE_TABS--> <!--END_DOCUSAURUS_CODE_TABS-->
### Adding or Removing from a Set ### Adding or Removing from a Set
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
In PascaLIGO, there are two ways to update a set. Either we create a In PascaLIGO, there are two ways to update a set. Either we create a
new set from the given one, or we modify it in-place. First, let us new set from the given one, or we modify it in-place. First, let us
consider the former: consider the former:
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
```pascaligo group=a ```pascaligo group=a
const larger_set : set (int) = set_add (4, my_set) const larger_set : set (int) = set_add (4, my_set)
const smaller_set : set (int) = set_remove (3, my_set) const smaller_set : set (int) = set_remove (3, my_set)
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
If we are in a block, we can use an instruction to modify the set If we are in a block, we can use an instruction to modify the set
bound to a given variable. This is called a *patch*. It is only bound to a given variable. This is called a *patch*. It is only
@ -418,61 +400,69 @@ this instruction is equivalent to perform the union of two sets, one
that is modified in-place, and the other given as a literal that is modified in-place, and the other given as a literal
(extensional definition). (extensional definition).
``pascaligo group=a <!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
```pascaligo group=a
function update (var s : set (int)) : set (int) is block { function update (var s : set (int)) : set (int) is block {
patch s with set [4; 7] patch s with set [4; 7]
} with s } with s
const new_set : set (int) = update (my_set) const new_set : set (int) = update (my_set)
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
<!--CameLIGO-->
In CameLIGO, we update a given set by creating another one, with or In CameLIGO, we update a given set by creating another one, with or
without some elements. without some elements.
<!--DOCUSAURUS_CODE_TABS-->
<!--CameLIGO-->
```cameligo group=a ```cameligo group=a
let larger_set : int set = Set.add 4 my_set let larger_set : int set = Set.add 4 my_set
let smaller_set : int set = Set.remove 3 my_set let smaller_set : int set = Set.remove 3 my_set
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
<!--ReasonLIGO-->
In ReasonLIGO, we update a given set by creating another one, with or In ReasonLIGO, we update a given set by creating another one, with or
without some elements. without some elements.
<!--DOCUSAURUS_CODE_TABS-->
<!--ReasonLIGO-->
```reasonligo group=a ```reasonligo group=a
let larger_set : set (int) = Set.add (4, my_set); let larger_set : set (int) = Set.add (4, my_set);
let smaller_set : set (int) = Set.remove (3, my_set); let smaller_set : set (int) = Set.remove (3, my_set);
``` ```
<!--END_DOCUSAURUS_CODE_TABS--> <!--END_DOCUSAURUS_CODE_TABS-->
### Folding over a Set ### Folding over a Set
<!--DOCUSAURUS_CODE_TABS-->
Given a set, we may want to apply a function in turn to all the Given a set, we may want to apply a function in turn to all the
elements it contains, while accumulating some value which is returned elements it contains, while accumulating some value which is returned
at the end. This is a *fold operation*. In the following example, we at the end. This is a *fold operation*. In the following example, we
sum up all the elements of the set `my_set` defined above. sum up all the elements of the set `my_set` defined above.
<!--Pascaligo-->
In PascaLIGO, the folded function takes the accumulator first and the In PascaLIGO, the folded function takes the accumulator first and the
(current) set element second. The predefined fold is called `set_fold`. (current) set element second. The predefined fold is called `set_fold`.
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
```pascaligo group=a ```pascaligo group=a
function sum (const acc : int; const i : int): int is acc + i function sum (const acc : int; const i : int): int is acc + i
const sum_of_elements : int = set_fold (sum, my_set, 0) const sum_of_elements : int = set_fold (sum, my_set, 0)
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
It is possible to use a *loop* over a set as well. It is possible to use a *loop* over a set as well.
<!--DOCUSAURUS_CODE_TABS-->
<!--Pascaligo-->
```pascaligo group=a ```pascaligo group=a
function loop (const s : set (int)) : int is block { function loop (const s : set (int)) : int is block {
var sum : int := 0; var sum : int := 0;
@ -481,26 +471,27 @@ function loop (const s : set (int)) : int is block {
} }
} with sum } with sum
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
<!--CameLIGO-->
In CameLIGO, the predefined fold over sets is called `Set.fold`. In CameLIGO, the predefined fold over sets is called `Set.fold`.
<!--DOCUSAURUS_CODE_TABS-->
<!--CameLIGO-->
```cameligo group=a ```cameligo group=a
let sum (acc, i : int * int) : int = acc + i let sum (acc, i : int * int) : int = acc + i
let sum_of_elements : int = Set.fold sum my_set 0 let sum_of_elements : int = Set.fold sum my_set 0
``` ```
<!--END_DOCUSAURUS_CODE_TABS-->
<!--ReasonLIGO-->
`
In ReasonLIGO, the predefined fold over sets is called `Set.fold`. In ReasonLIGO, the predefined fold over sets is called `Set.fold`.
``reasonligo group=a <!--DOCUSAURUS_CODE_TABS-->
<!--ReasonLIGO-->
```reasonligo group=a
let sum = ((acc, i) : (int, int)) : int => acc + i; let sum = ((acc, i) : (int, int)) : int => acc + i;
let sum_of_elements : int = Set.fold (sum, my_set, 0); let sum_of_elements : int = Set.fold (sum, my_set, 0);
``` ```
<!--END_DOCUSAURUS_CODE_TABS--> <!--END_DOCUSAURUS_CODE_TABS-->
<!--END_DOCUSAURUS_CODE_TABS-->