diff --git a/gitlab-pages/docs/reference/big_map.md b/gitlab-pages/docs/reference/big_map.md
index c122e0270..e20bdc48c 100644
--- a/gitlab-pages/docs/reference/big_map.md
+++ b/gitlab-pages/docs/reference/big_map.md
@@ -13,7 +13,7 @@ A lazily deserialized map that's intended to store large amounts of data.
The gast costs of deserialized maps are higher than standard maps as data is lazily deserialized.
-type big_map (key, value)
+type big_map ('key, 'value)
type ('key, 'value) big_map
@@ -45,6 +45,7 @@ type register = (address, move) big_map
+
The type of a big map from values of type `key` to
values of type `value` is `big_map (key, value)`.
@@ -56,7 +57,7 @@ type register = big_map (address, move);
-function empty : big_map (key, value)
+function empty : big_map ('key, 'value)
val empty : ('key, 'value) big_map
@@ -97,7 +98,7 @@ let empty : register = Big_map.empty
-function literal : list (key * value) -> big_map (key, value)
+function literal : list ('key * 'value) -> big_map ('key, 'value)
val literal : ('key * 'value) list -> ('key, 'value) big_map
@@ -149,7 +150,7 @@ let moves : register =
-function find_opt : key -> big_map (key, value) -> option value
+function find_opt : 'key -> big_map ('key, 'value) -> option 'value
val find_opt : 'key -> ('key, 'value) big_map -> 'value option
@@ -197,7 +198,7 @@ let my_balance : option (move) =
-function update : key -> option value -> big_map (key, value) -> big_map (key, value)
+function update : 'key -> option 'value -> big_map ('key, 'value) -> big_map ('key, 'value)
val update: 'key -> 'value option -> ('key, 'value) big_map -> ('key, 'value) big_map
@@ -262,7 +263,7 @@ let updated_map : register =
-function add : key -> value -> big_map (key, value) -> big_map (key, value)
+function add : 'key -> 'value -> big_map ('key, 'value) -> big_map ('key, 'value)
val add : 'key -> 'value -> ('key, 'value) big_map -> ('key, 'value) big_map
@@ -298,13 +299,13 @@ let add = (m: register): register =>
-function remove: key -> big_map (key, value) -> big_map (key, value)
+function remove: 'key -> big_map ('key, 'value) -> big_map ('key, 'value)
val remove: 'key -> ('key, 'value) big_map -> ('key, 'value) big_map
-let remove: (key, big_map ('key, 'value)) => big_map ('key, 'value)
+let remove: ('key, big_map ('key, 'value)) => big_map ('key, 'value)
diff --git a/gitlab-pages/docs/reference/bitwise.md b/gitlab-pages/docs/reference/bitwise.md
new file mode 100644
index 000000000..85d6bde86
--- /dev/null
+++ b/gitlab-pages/docs/reference/bitwise.md
@@ -0,0 +1,69 @@
+---
+id: bitwise-reference
+title: Bitwise
+description: Operations on bytes
+hide_table_of_contents: true
+---
+
+import Syntax from '@theme/Syntax';
+import SyntaxTitle from '@theme/SyntaxTitle';
+
+
+function and : nat -> nat -> nat
+
+
+val and : nat -> nat -> nat
+
+
+let and: (nat, nat) -> nat
+
+
+A bitwise `and` operation.
+
+
+function or : nat -> nat -> nat
+
+
+val or : nat -> nat -> nat
+
+
+let or: (nat, nat) -> nat
+
+
+A bitwise `or` operation.
+
+
+function xor : nat -> nat -> nat
+
+
+val xor : nat -> nat -> nat
+
+
+let xor: (nat, nat) -> nat
+
+
+A bitwise `xor` operation.
+
+
+function shift_left : nat -> nat -> nat
+
+
+val shift_left : nat -> nat -> nat
+
+
+let shift_left: (nat, nat) -> nat
+
+
+A bitwise shift left operation.
+
+
+function shift_right : nat -> nat -> nat
+
+
+val shift_right : nat -> nat -> nat
+
+
+let shift_right: (nat, nat) -> nat
+
+
+A bitwise shift right operation.
diff --git a/gitlab-pages/docs/reference/bytes.md b/gitlab-pages/docs/reference/bytes.md
index dc8dc1aec..68e61d8cd 100644
--- a/gitlab-pages/docs/reference/bytes.md
+++ b/gitlab-pages/docs/reference/bytes.md
@@ -1,21 +1,43 @@
---
id: bytes-reference
-title: Bytes — Manipulate bytes data
+title: Bytes
+description: Operations on bytes
+hide_table_of_contents: true
---
import Syntax from '@theme/Syntax';
+import SyntaxTitle from '@theme/SyntaxTitle';
-## Bytes.concat(b1: bytes, b2: bytes) : bytes
+
+type bytes
+
+
+type bytes
+
+
+type bytes
+
+
+
+function concat : bytes -> bytes -> bytes
+
+
+val concat : bytes -> bytes -> bytes
+
+
+let concat: (bytes, bytes) => bytes
+
Concatenate together two `bytes` arguments and return the result.
```pascaligo
-function concat_op (const s : bytes) : bytes is
- begin skip end with bytes_concat(s , 0x7070)
+function concat_op (const s : bytes) : bytes is Bytes.concat(s , 0x7070)
```
+> Note that `bytes_concat` is *deprecated*.
+
@@ -33,41 +55,58 @@ let concat_op = (s: bytes): bytes => Bytes.concat(s, 0x7070);
-## Bytes.slice(pos1: nat, pos2: nat, data: bytes) : bytes
+
+function sub : nat -> nat -> bytes -> bytes
+
+
+val sub : nat -> nat -> bytes -> bytes
+
+
+let sub : (nat, nat, bytes) => bytes
+
Extract the bytes between `pos1` and `pos2`. **Positions are zero indexed and
inclusive**. For example if you gave the input "ff7a7aff" to the following:
-
-
```pascaligo
-function slice_op (const s : bytes) : bytes is
- begin skip end with bytes_slice(1n , 2n , s)
+function slice_op (const s : bytes) : bytes is Bytes.sub(1n , 2n , s)
```
+> Note that `bytes_slice` is *deprecated*.
+
```cameligo
-let slice_op (s : bytes) : bytes =
- Bytes.slice 1n 2n s
+let slice_op (s : bytes) : bytes = Bytes.sub 1n 2n s
```
+> Note that `Bytes.slice` is *deprecated*.
+
```
-let slice_op = (s: bytes): bytes => Bytes.slice(1n, 2n, s);
+let slice_op = (s: bytes): bytes => Bytes.sub(1n, 2n, s);
```
+> Note that `Bytes.slice` is *deprecated*.
+
-
It would return "7a7a" rather than "ff7a" or "ff" or "7a".
-## Bytes.pack(data: a') : bytes
+
+function pack : 'a -> bytes
+
+
+val pack : 'a -> bytes
+
+
+let pack : 'a => bytes
+
Converts Michelson data structures to a binary format for serialization.
@@ -105,10 +144,19 @@ let id_string = (p: string) : option(string) => {
-## Bytes.unpack(packed: bytes) : a'
+
+function unpack : bytes -> option 'a
+
+
+val unpack : bytes -> 'a option
+
+
+let unpack: bytes => option('a)
+
-Reverses the result of using `unpack` on data, going from Michelson's binary
-serialization format to the `option` type annotated on the call.
+Reverses the result of using `pack` on data.
+
+As the conversion might fail an option type is returned.
> ⚠️ `PACK` and `UNPACK` are features of Michelson that are intended to be used by people that really know what they're doing. There are several failure cases (such as `UNPACK`ing a lambda from an untrusted source), most of which are beyond the scope of this document. Don't use these functions without doing your homework first.
@@ -143,3 +191,12 @@ let id_string = (p: string) : option(string) => {
+
+function length : bytes -> nat
+
+
+val length : bytes -> nat
+
+
+let length: bytes => nat
+
diff --git a/gitlab-pages/docs/reference/crypto.md b/gitlab-pages/docs/reference/crypto.md
index 49f5a9f02..ba8d146fd 100644
--- a/gitlab-pages/docs/reference/crypto.md
+++ b/gitlab-pages/docs/reference/crypto.md
@@ -1,11 +1,58 @@
---
id: crypto-reference
-title: Crypto — Cryptographic functions
+title: Crypto
+description: Cryptographic operations
+hide_table_of_contents: true
---
import Syntax from '@theme/Syntax';
+import SyntaxTitle from '@theme/SyntaxTitle';
-## Crypto.blake2b(data: bytes): bytes
+
+type key
+
+
+type key
+
+
+type key
+
+
+A public cryptographic key.
+
+
+type key_hash
+
+
+type key_hash
+
+
+type key_hash
+
+
+The hash of a public cryptographic key.
+
+
+type signature
+
+
+type signature
+
+
+type signature
+
+
+A cryptographic signature.
+
+
+function blake2b : bytes -> bytes
+
+
+val blake2b : bytes -> bytes
+
+
+let blake2b: bytes => bytes
+
Runs the [blake2b hash algorithm](https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE2)
over the given `bytes` data and returns a `bytes` representing the hash.
@@ -15,9 +62,11 @@ over the given `bytes` data and returns a `bytes` representing the hash.
```pascaligo
-function hasherman_blake (const s: bytes) : bytes is blake2b(s)
+function hasherman_blake (const s: bytes) : bytes is Crypto.blake2b(s)
```
+> Note that `blake2b` is *deprecated*. Please use `Crypto.blake2b`.
+
@@ -25,6 +74,8 @@ function hasherman_blake (const s: bytes) : bytes is blake2b(s)
let hasherman_blake (s: bytes) : bytes = Crypto.blake2b s
```
+
+
@@ -34,8 +85,15 @@ let hasherman_blake = (s: bytes) => Crypto.blake2b(s);
-
-## Crypto.sha256(data: bytes) : bytes
+
+function sha256 : bytes -> bytes
+
+
+val sha256 : bytes -> bytes
+
+
+let sha256: bytes => bytes
+
Runs the [sha256 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the given
`bytes` data and returns a `bytes` representing the hash.
@@ -45,10 +103,11 @@ Runs the [sha256 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the g
```pascaligo
-function hasherman (const s : bytes) : bytes is
- begin skip end with sha_256(s)
+function hasherman (const s : bytes) : bytes is Crypto.sha256(s)
```
+> Note that `sha_256` is *deprecated*. Please use `Crypto.sha256`.
+
@@ -66,8 +125,15 @@ let hasherman = (s: bytes): bytes => Crypto.sha256(s);
-
-## Crypto.sha512(data: bytes) : bytes
+
+function sha512 : bytes -> bytes
+
+
+val sha512 : bytes -> bytes
+
+
+let sha512: bytes => bytes
+
Runs the [sha512 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the given
`bytes` data and returns a `bytes` representing the hash.
@@ -77,9 +143,11 @@ Runs the [sha512 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the g
```pascaligo
-function hasherman512 (const s: bytes) : bytes is sha_512(s)
+function hasherman512 (const s: bytes) : bytes is Crypto.sha512(s)
```
+> Note that `sha_512` is *deprecated*. Please use `Crypto.sha512`.
+
@@ -96,8 +164,15 @@ let hasherman512 = (s: bytes) => Crypto.sha512(s);
-
-## Crypto.hash_key(k: key) : key_hash
+
+function hash_key : key -> key_hash
+
+
+val hash_key : key -> key_hash
+
+
+let hash_key: key => key_hash
+
Hashes a key for easy comparison and storage.
@@ -108,11 +183,13 @@ Hashes a key for easy comparison and storage.
```pascaligo
function check_hash_key (const kh1 : key_hash; const k2 : key) : bool * key_hash is block {
var ret : bool := False ;
- var kh2 : key_hash := crypto_hash_key(k2) ;
+ var kh2 : key_hash := Crypto.hash_key(k2) ;
if kh1 = kh2 then ret := True else skip;
} with (ret, kh2)
```
+> Note that `hash_key` is *deprecated*. Please use `Crypto.hash_key`.
+
@@ -141,8 +218,15 @@ let check_hash_key = ((kh1, k2): (key_hash, key)) : (bool, key_hash) => {
-
-## Crypto.check(pk: key, signed: signature, data: bytes) : bool
+
+function check : key -> signature -> bytes -> bool
+
+
+val check : key -> signature -> bytes -> bool
+
+
+let check: (key, signature, bytes) => bool
+
Check that a message has been signed by a particular key.
@@ -157,9 +241,11 @@ function check_signature
(const pk: key;
const signed: signature;
const msg: bytes) : bool
- is crypto_check(pk, signed, msg)
+ is Crypto.check(pk, signed, msg)
```
+> Note that `crypto_check` is *deprecated*. Please use `Crypto.check`.
+
diff --git a/gitlab-pages/docs/reference/current.md b/gitlab-pages/docs/reference/current.md
index 642bbb6fe..56c719630 100644
--- a/gitlab-pages/docs/reference/current.md
+++ b/gitlab-pages/docs/reference/current.md
@@ -1,11 +1,96 @@
---
id: current-reference
-title: Tezos - Things relating to the current execution context
+title: Tezos
+description: General operations for Tezos
+hide_table_of_contents: true
---
import Syntax from '@theme/Syntax';
+import SyntaxTitle from '@theme/SyntaxTitle';
-# Tezos.balance
+
+type timestamp
+
+
+type timestamp
+
+
+type timestamp
+
+
+A date in the real world.
+
+
+type mutez
+
+
+type mutez
+
+
+type mutez
+
+
+A specific type for tokens.
+
+
+type address
+
+
+type address
+
+
+type address
+
+
+An untyped address which can refer to a smart contract or account.
+
+
+type contract('parameter)
+
+
+type 'parameter contract
+
+
+type contract('parameter)
+
+
+A typed contract.
+
+Use `unit` as `parameter` to indicate an implicit account.
+
+
+type operation
+
+
+type operation
+
+
+type operation
+
+
+An operation emitted by the contract
+
+
+type chain_id
+
+
+type chain_id
+
+
+type chain_id
+
+
+The identifier of a chain, used to indicate test or main chains.
+
+
+function balance : mutez
+
+
+val balance : mutez
+
+
+let balance: mutez
+
Get the balance for the contract.
@@ -18,7 +103,7 @@ function main (const p : unit; const s: tez) : list (operation) * tez is
((nil : list (operation)), Tezos.balance)
```
-> Note that `balance` and `Current.balance` are *deprecated*.
+> Note that `balance` and `Current.balance` are *deprecated*.
@@ -42,7 +127,15 @@ let main = ((p,s) : (unit, tez)) =>
-## Tezos.now
+
+function now : timestamp
+
+
+val now : timestamp
+
+
+let now: timestamp
+
Returns the current time as a [unix timestamp](https://en.wikipedia.org/wiki/Unix_time).
@@ -64,7 +157,7 @@ const some_date: timestamp = ("2000-01-01T10:10:10Z" : timestamp);
const one_day_later: timestamp = some_date + one_day;
```
-> Note that `now` is *deprecated*.
+> Note that `now` is *deprecated*. Please use `Tezos.now`.
@@ -106,7 +199,7 @@ const one_day: int = 86_400;
const in_24_hrs: timestamp = today - one_day;
```
-> Note that `now` is *deprecated*.
+> Note that `now` is *deprecated*. Please use `Tezos.now`.
@@ -145,7 +238,7 @@ for numbers
const not_tommorow: bool = (Tezos.now = in_24_hrs)
```
-> Note that `now` is *deprecated*.
+> Note that `now` is *deprecated*. Please use `Tezos.now`.
@@ -169,7 +262,15 @@ let not_tomorrow: bool = (Tezos.now == in_24_hrs);
-## Amount
+
+function amount : mutez
+
+
+val amount : mutez
+
+
+let amount: mutez
+
Get the amount of tez provided by the sender to complete this
transaction.
@@ -207,7 +308,15 @@ let threshold = (p : unit) : int =>
-## Sender
+
+function sender : address
+
+
+val sender : address
+
+
+let sender: address
+
Get the address that initiated the current transaction.
@@ -219,7 +328,7 @@ Get the address that initiated the current transaction.
function main (const p : unit) : address is Tezos.sender
```
-> Note that `sender` is *deprecated*.
+> Note that `sender` is *deprecated*. Please use `Tezos.sender`.
@@ -243,7 +352,15 @@ let main = (p : unit) : address => Tezos.sender;
-## Address
+
+function address : contract 'a -> address
+
+
+val address : 'a contract -> address
+
+
+let address: contract('a) => address
+
Get the address associated with a value of type `contract`.
@@ -257,7 +374,7 @@ function main (const p : key_hash) : address is block {
} with Tezos.address(c)
```
-> Note that `implicit_account` and `address` are *deprecated*.
+> Note that `implicit_account` and `address` are *deprecated*. Please use `Tezos.implicit_account` and `Tezos.address` instead.
@@ -287,7 +404,15 @@ let main = (p : key_hash) : address => {
-## Self Address
+
+function self_address : address
+
+
+val self_address : address
+
+
+let self_address: address
+
Get the address of the currently running contract.
@@ -299,7 +424,7 @@ Get the address of the currently running contract.
function main (const p : unit) : address is Tezos.self_address
```
-> Note that `self_address` is *deprecated*.
+> Note that `self_address` is *deprecated*. Please use `Tezos.self_address`.
@@ -320,8 +445,15 @@ let main = (p : unit) : address => Tezos.self_address;
> Note that `Current.self_address` is *deprecated*.
-
-## Self
+
+function self : string -> contract 'a
+
+
+val self : string -> 'a contract
+
+
+let self: string => contract('a)
+
Typecast the currently running contract with an entrypoint annotation.
If your are using entrypoints: use "%bar" for constructor Bar
@@ -353,13 +485,21 @@ let main = (p: unit) : contract(unit) =>
-## Implicit Account
+
+function implicit_account : key_hash -> contract 'a
+
+
+val implicit_account : key_hash -> 'a contract
+
+
+let implicit_account: key_hash => contract('a)
+
Get the default contract associated with an on-chain key-pair. This
contract does not execute code, instead it exists to receive tokens on
behalf of a key's owner.
-
+See also: http://tezos.gitlab.io/user/glossary.html#implicit-account
@@ -368,7 +508,7 @@ function main (const kh: key_hash) : contract (unit) is
Tezos.implicit_account (kh)
```
-> Note that `implicit_account` is *deprecated*.
+> Note that `implicit_account` is *deprecated*. Please use `Tezos.implicit_account`.
@@ -392,7 +532,15 @@ let main = (kh : key_hash): contract (unit) =>
-## Source
+
+function source : address
+
+
+val source : address
+
+
+let source: address
+
Get the _originator_ (address) of the current transaction. That is, if
a chain of transactions led to the current execution get the address
@@ -426,7 +574,7 @@ current transaction.
function main (const p: unit) : address is Tezos.source
```
-> Note that `source` is *deprecated*.
+> Note that `source` is *deprecated*. Please use `Tezos.source`.
@@ -449,7 +597,15 @@ let main = (p : unit) : address => Tezos.source;
-## Failwith
+
+function failwith : string -> unit
+
+
+function failwith : string -> unit
+
+
+function failwith : string -> unit
+
Cause the contract to fail with an error message.
@@ -485,3 +641,125 @@ let main = ((p,s) : (int, unit)) =>
+
+function chain_id : chain_id
+
+
+val chain_id : chain_id
+
+
+let chain_id: chain_id
+
+
+Get the identifier of the chain to distinguish between main and test chains.
+
+This is mainly intended to avoid replay attacks between the chains, and can currently
+only be used together with `Bytes.pack` and `Bytes.unpack`.
+
+
+
+```pascaligo
+type storage is bytes
+
+function main (const ignore : unit; const storage: storage) :
+ (list(operation) * storage) is block {
+ const packed : bytes = Bytes.pack (Tezos.chain_id);
+ if (storage =/= packed) then {
+ failwith("wrong chain")
+ } else
+ skip;
+} with ((nil: list(operation)), packed)
+```
+
+
+
+
+```cameligo
+type storage = bytes
+
+let main ((ignore, storage): (unit * storage)) =
+ let packed = Bytes.pack Tezos.chain_id in
+ if (storage <> packed) then
+ (failwith "wrong chain" : (operation list * storage))
+ else
+ (([]: operation list), (packed: storage))
+```
+
+
+
+
+```reasonligo
+type storage = bytes;
+
+let main = ((ignore, storage): (unit, storage)) => {
+ let packed = Bytes.pack(Tezos.chain_id);
+ if (storage != packed) {
+ (failwith("wrong chain"): (list(operation), storage));
+ } else {
+ ([]: list(operation), packed);
+ }
+};
+```
+
+
+
+
+function transaction : 'parameter -> mutez -> contract('parameter) -> operation
+
+
+val transaction : 'parameter -> mutez -> 'parameter contract -> operation
+
+
+let transaction: 'parameter -> mutez -> contract('parameter) -> operation
+
+
+Create a transaction to a contract or account.
+
+To indicate an account, use `unit` as `parameter`.
+
+
+
+function set_delegate : option(key_hash) -> operation
+
+
+val set_delegate : key_hash option -> operation
+
+
+let set_delegate: option(key_hash) => operation
+
+
+Create a delegation.
+
+See also: http://tezos.gitlab.io/user/glossary.html?highlight=delegate#delegate
+
+
+function get_contract_opt : address -> option(contract('parameter))
+
+
+val get_contract_opt : address -> 'parameter contract option
+
+
+let get_contract_opt : address => option(contract('parameter))
+
+
+Get a contract from an address.
+
+When no contract is found or the contract doesn't match the type,
+`None` is returned.
+
+
+function get_entrypoint_opt : string -> address -> option(contract('parameter))
+
+
+function get_entrypoint_opt : string -> address -> 'parameter contract option
+
+
+function get_entrypoint_opt: (string, address) => option(contract('parameter))
+
+
+Get a contract from an address and entrypoint.
+
+Entrypoints are written in the form of: `%entrypoint`.
+
+When no contract is found or the contract doesn't match the type,
+`None` is returned.
diff --git a/gitlab-pages/docs/reference/list.md b/gitlab-pages/docs/reference/list.md
index cbded72e6..e85e5b543 100644
--- a/gitlab-pages/docs/reference/list.md
+++ b/gitlab-pages/docs/reference/list.md
@@ -1,96 +1,62 @@
---
id: list-reference
-title: Lists — Linear Collections
+title: List
+description: List operations
+hide_table_of_contents: true
---
import Syntax from '@theme/Syntax';
+import SyntaxTitle from '@theme/SyntaxTitle';
-Lists are linear collections of elements of the same type. Linear
-means that, in order to reach an element in a list, we must visit all
-the elements before (sequential access). Elements can be repeated, as
-only their order in the collection matters. The first element is
-called the *head*, and the sub-list after the head is called the
-*tail*. For those familiar with algorithmic data structure, you can
-think of a list a *stack*, where the top is written on the left.
+
+type list ('t)
+
+
+type 't list
+
+
+type list('t)
+
-# Defining Lists
+A sequence of elements of the same type.
+
+function length : nat
+
+
+val length : nat
+
+
+let length: nat
+
-
+Get the number of elements in a list.
-```pascaligo group=lists
-const empty_list : list (int) = nil // Or list []
-const my_list : list (int) = list [1; 2; 2] // The head is 1
-```
+
+function size : nat
+
+
+val size : nat
+
+
+let size: nat
+
-
-
+Get the number of elements in a list.
-```cameligo group=lists
-let empty_list : int list = []
-let my_list : int list = [1; 2; 2] // The head is 1
-```
-
-
-
-
-```reasonligo group=lists
-let empty_list : list (int) = [];
-let my_list : list (int) = [1, 2, 2]; // The head is 1
-```
-
-
-
-
-# Adding to Lists
-
-Lists can be augmented by adding an element before the head (or, in
-terms of stack, by *pushing an element on top*).
-
-
-
-
-
-```pascaligo group=lists
-const larger_list : list (int) = 5 # my_list // [5;1;2;2]
-```
-
-
-
-
-```cameligo group=lists
-let larger_list : int list = 5 :: my_list // [5;1;2;2]
-```
-
-
-
-
-```reasonligo group=lists
-let larger_list : list (int) = [5, ...my_list]; // [5,1,2,2]
-```
-
-
-
-
-
-# Functional Iteration over Lists
-
-A *functional iterator* is a function that traverses a data structure
-and calls in turn a given function over the elements of that structure
-to compute some value. Another approach is possible in PascaLIGO:
-*loops* (see the relevant section).
-
-There are three kinds of functional iterations over LIGO lists: the
-*iterated operation*, the *map operation* (not to be confused with the
-*map data structure*) and the *fold operation*.
-
-## Iterated Operation over Lists
-
-The first, the *iterated operation*, is an iteration over the list
-with a unit return value. It is useful to enforce certain invariants
-on the element of a list, or fail.
+Synonym for `List.length`.
+
+function iter : ('a -> unit) -> list('a) -> unit
+
+
+val iter : ('a -> unit) -> 'a list -> unit
+
+
+let iter: (('a => unit), list('a)) => unit
+
+Iterate over items in a list.
@@ -104,6 +70,8 @@ function iter_op (const l : list (int)) : unit is
> Note that `list_iter` is *deprecated*.
+Alternatively it's also possible to use [loops](../language-basics/loops.md).
+
@@ -126,17 +94,23 @@ let iter_op = (l : list (int)) : unit => {
-## Mapped Operation over Lists
-
-We may want to change all the elements of a given list by applying to
-them a function. This is called a *map operation*, not to be confused
-with the map data structure.
-
+
+function map : ('a -> 'b) -> list('a) -> list('b)
+
+
+val map : ('a -> 'b) -> 'a list -> 'b list
+
+
+let map: (('a => 'b), list('a)) => list('b)
+
+Apply a function to items of a list to create a new list.
```pascaligo group=lists
+const larger_list: list(int) = list [1; 2; 3]
+
function increment (const i : int): int is i + 1
// Creates a new list with all elements incremented by 1
@@ -149,6 +123,8 @@ const plus_one : list (int) = List.map (increment, larger_list)
```cameligo group=lists
+let larger_list: int list = [1; 2; 3]
+
let increment (i : int) : int = i + 1
// Creates a new list with all elements incremented by 1
@@ -159,6 +135,8 @@ let plus_one : int list = List.map increment larger_list
```reasonligo group=lists
+let larger_list: list(int) = [1, 2, 3];
+
let increment = (i : int) : int => i + 1;
// Creates a new list with all elements incremented by 1
@@ -167,22 +145,25 @@ let plus_one : list (int) = List.map (increment, larger_list);
+
+function fold : (('accumulator -> 'item -> 'accumulator) -> list('item) -> 'accumulator) -> 'accumulator
+
+
+val fold : ('accumulator -> 'item -> 'accumulator) -> 'item list -> 'accumulator -> 'accumulator
+
+
+let fold: ((('accumulator, 'item) => 'accumulator), list('item), 'accumulator) => 'accumulator
+
-
-## Folded Operation over Lists
-
-A *folded operation* is the most general of iterations. The folded
-function takes two arguments: an *accumulator* and the structure
-*element* at hand, with which it then produces a new accumulator. This
-enables having a partial result that becomes complete when the
-traversal of the data structure is over.
-
-
+[Fold over items in a list](../language-basics/sets-lists-tuples#folded-operation-over-lists);
```pascaligo group=lists
+const my_list: list(int) = list [1; 2; 3]
+
function sum (const acc : int; const i : int): int is acc + i
+
const sum_of_elements : int = List.fold (sum, my_list, 0)
```
@@ -192,7 +173,10 @@ const sum_of_elements : int = List.fold (sum, my_list, 0)
```cameligo group=lists
-let sum (acc, i: int * int) : int = acc + i
+let my_list : int list = [1; 2; 3]
+
+let sum (acc, i : int * int) : int = acc + i
+
let sum_of_elements : int = List.fold sum my_list 0
```
@@ -200,40 +184,11 @@ let sum_of_elements : int = List.fold sum my_list 0
```reasonligo group=lists
+let my_list : list(int) = [1, 2, 3];
+
let sum = ((result, i): (int, int)): int => result + i;
+
let sum_of_elements : int = List.fold (sum, my_list, 0);
```
-
-
-# List Length
-
-Get the number of elements in a list.
-
-
-
-
-
-```pascaligo
-function size_of (const l : list (int)) : nat is List.length (l)
-```
-
-> Note that `size` is *deprecated*.
-
-
-
-
-```cameligo
-let size_of (l : int list) : nat = List.length l
-```
-
-
-
-
-```reasonligo
-let size_of = (l : list (int)) : nat => List.length (l);
-```
-
-
-
diff --git a/gitlab-pages/docs/reference/map.md b/gitlab-pages/docs/reference/map.md
index b359380eb..bf26f6bcf 100644
--- a/gitlab-pages/docs/reference/map.md
+++ b/gitlab-pages/docs/reference/map.md
@@ -1,22 +1,28 @@
---
id: map-reference
-title: Maps
+title: Map
+description: Map operations
+hide_table_of_contents: true
---
import Syntax from '@theme/Syntax';
+import SyntaxTitle from '@theme/SyntaxTitle';
-*Maps* are a data structure which associate values of the same type to
-values of the same type. The former are called *key* and the latter
-*values*. Together they make up a *binding*. An additional requirement
-is that the type of the keys must be *comparable*, in the Michelson
-sense.
-
-# Declaring a Map
-
-
+
+type map ('key, 'value)
+
+
+type ('key, 'value) map
+
+
+type map ('key, 'value)
+
+The type of a map from values of type `key` to
+values of type `value` is `map (key, value)`.
+
```pascaligo group=maps
type move is int * int
type register is map (address, move)
@@ -25,6 +31,9 @@ type register is map (address, move)
+The type of a map from values of type `key` to values
+of type `value` is `(key, value) map`.
+
```cameligo group=maps
type move = int * int
type register = (address, move) map
@@ -33,6 +42,9 @@ type register = (address, move) map
+The type of a map from values of type `key` to
+values of type `value` is `map (key, value)`.
+
```reasonligo group=maps
type move = (int, int);
type register = map (address, move);
@@ -40,13 +52,26 @@ type register = map (address, move);
+
+function empty : map ('key, 'value)
+
+
+val empty : ('key, 'value) map
+
+
+let empty: map('key, 'value)
+
-# Creating an Empty Map
-
-
+Create an empty map.
+```pascaligo group=maps
+const empty : register = Map.empty
+```
+
+Or
+
```pascaligo group=maps
const empty : register = map []
```
@@ -68,16 +93,34 @@ let empty : register = Map.empty
-# Creating a Non-empty Map
+
+function literal : list ('key * 'value) -> map ('key, 'value)
+
+
+val literal : ('key * 'value) list -> ('key, 'value) map
+
+
+let literal: list(('key, 'value)) => map('key, 'value)
+
+Create a non-empty map.
```pascaligo group=maps
const moves : register =
+ Map.literal (list [
+ (("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address), (1,2));
+ (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (0,3))]);
+```
+
+Alternative way of creating an empty map:
+
+```pascaligo group=maps
+const moves_alternative : register =
map [
("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address) -> (1,2);
- ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) -> (0,3)]
+ ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) -> (0,3)];
```
@@ -103,14 +146,32 @@ let moves : register =
-# Accessing Map Bindings
+
+function find_opt : 'key -> map ('key, 'value) -> option 'value
+
+
+val find_opt : 'key -> ('key, 'value) map -> 'value option
+
+
+let find_opt : ('key, map ('key, 'value)) => option ('value)
+
+
+Retrieve a (option) value from a map with the given key. Returns `None` if the
+key is missing and the value otherwise.
```pascaligo group=maps
const my_balance : option (move) =
- moves [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address)]
+ Map.find_opt (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), moves)
+```
+
+Alternatively:
+
+```pascaligo group=maps
+const my_balance_alternative : option (move) =
+ moves [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address)];
```
@@ -126,67 +187,40 @@ let my_balance : move option =
```reasonligo group=maps
let my_balance : option (move) =
- Map.find_opt (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), moves);
+ Map.find_opt ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address, moves);
```
-Notice how the value we read is an optional value: this is to force
-the reader to account for a missing key in the map. This requires
-*pattern matching*.
-
+
+function update : 'key -> option 'value -> map ('key, 'value) -> map ('key, 'value)
+
+
+val update: 'key -> 'value option -> ('key, 'value) map -> ('key, 'value) map
+
+
+let update: ('key, option('value), map('key, 'value)) => map ('key, 'value)
+
+Note: when `None` is used as a value, the key and associated value is removed
+from the map.
```pascaligo group=maps
-function force_access (const key : address; const moves : register) : move is
- case moves[key] of
- Some (move) -> move
- | None -> (failwith ("No move.") : move)
- end
+ const updated_map : register = Map.update(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), Some (4,9), moves);
```
-
-
-
-```cameligo group=maps
-let force_access (key, moves : address * register) : move =
- match Map.find_opt key moves with
- Some move -> move
- | None -> (failwith "No move." : move)
-```
-
-
-
-
-```reasonligo group=maps
-let force_access = ((key, moves) : (address, register)) : move => {
- switch (Map.find_opt (key, moves)) {
- | Some (move) => move
- | None => failwith ("No move.") : move
- }
-};
-```
-
-
-
-
-# Updating a Map
-
-Given a map, we may want to add a new binding, remove one, or modify
-one by changing the value associated to an already existing key. All
-those operations are called *updates*.
-
-
-
+Alternatively:
```pascaligo group=maps
-function assign (var m : register) : register is
+
+function update (var m : register) : register is
block {
- m [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address)] := (4,9)
+ m [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address)] := (4,9);
} with m
+
```
If multiple bindings need to be updated, PascaLIGO offers a *patch
@@ -206,14 +240,40 @@ function assignments (var m : register) : register is
```cameligo group=maps
-let assign (m : register) : register =
+let updated_map : register =
Map.update
- ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) (Some (4,9)) m
+ ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) (Some (4,9)) moves
```
-Notice the optional value `Some (4,9)` instead of `(4,9)`. If we had
-use `None` instead, that would have meant that the binding is removed.
-As a particular case, we can only add a key and its associated value.
+
+
+
+```reasonligo group=maps
+let updated_map : register =
+ Map.update
+ (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), Some ((4,9)), moves);
+```
+
+
+
+
+
+function add : 'key -> 'value -> map ('key, 'value) -> map ('key, 'value)
+
+
+val add : 'key -> 'value -> ('key, 'value) map -> ('key, 'value) map
+
+
+let add: ('key, 'value, map('key, 'value)) => map('key, 'value)
+
+
+
+```pascaligo group=maps
+const added_item : register = Map.add (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (4, 9), moves)
+```
+
+
+
```cameligo group=maps
let add (m : register) : register =
@@ -225,18 +285,7 @@ let add (m : register) : register =
```reasonligo group=maps
-let assign = (m : register) : register =>
- Map.update
- (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), Some ((4,9)), m);
-```
-
-Notice the optional value `Some (4,9)` instead of `(4,9)`. If we had
-use `None` instead, that would have meant that the binding is removed.
-
-As a particular case, we can only add a key and its associated value.
-
-```reasonligo group=maps
-let add = (m : register) : register =>
+let add = (m: register): register =>
Map.add
(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (4,9), m);
```
@@ -244,57 +293,63 @@ let add = (m : register) : register =>
-To remove a binding from a map, we need its key.
-
-
+
+function remove : 'key -> map ('key, 'value) -> map ('key, 'value)
+
+
+val remove : 'key -> ('key, 'value) map -> ('key, 'value) map
+
+
+let remove: (key, map('key, 'value)) => map('key, 'value)
+
```pascaligo group=maps
-function delete (const key : address; var moves : register) : register is
+ const updated_map : register =
+ Map.remove (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), moves)
+```
+
+Alternatively, the instruction `remove key from map m` removes the key
+`key` from the map `m`.
+
+```pascaligo group=maps
+function rem (var m : register) : register is
block {
- remove key from map moves
- } with moves
+ remove ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) from map moves
+ } with m
+
+const updated_map : register = rem (moves)
```
```cameligo group=maps
-let delete (key, moves : address * register) : register =
- Map.remove key moves
+let updated_map : register =
+ Map.remove ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) moves
```
```reasonligo group=maps
-let delete = ((key, moves) : (address, register)) : register =>
- Map.remove (key, moves);
+let updated_map : register =
+ Map.remove (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), moves)
```
-
-# Functional Iteration over Maps
-
-A *functional iterator* is a function that traverses a data structure
-and calls in turn a given function over the elements of that structure
-to compute some value. Another approach is possible in PascaLIGO:
-*loops* (see the relevant section).
-
-There are three kinds of functional iterations over LIGO maps: the
-*iterated operation*, the *map operation* (not to be confused with the
-*map data structure*) and the *fold operation*.
-
-## Iterated Operation over Maps
-
-The first, the *iterated operation*, is an iteration over the map with
-no return value: its only use is to produce side-effects. This can be
-useful if for example you would like to check that each value inside
-of a map is within a certain range, and fail with an error otherwise.
-
+
+function iter : ((key, value) -> unit) -> map (key, value) -> unit
+
+
+val iter : (('key * 'value) -> unit) -> ('key, 'value) map -> unit
+
+
+let iter: ((('key, 'value)) => unit, map('key, 'value)) => unit
+
@@ -330,14 +385,15 @@ let iter_op = (m : register) : unit => {
-
-## Map Operations over Maps
-
-We may want to change all the bindings of a map by applying to them a
-function. This is called a *map operation*, not to be confused with
-the map data structure. The predefined functional iterator
-implementing the map operation over maps is called `Map.map`.
-
+
+function map : (('key, 'value) -> ('mapped_key, 'mapped_item)) -> map ('key, 'value) -> map ('mapped_key, 'mapped_value)
+
+
+val map : (('key * 'value) -> ('mapped_key * 'mapped_item)) -> (key, value) map -> (mapped_key, mapped_value) map
+
+
+let map: ((('key, 'value)) => ('mapped_key, 'mapped_item), map(key, value)) => map(mapped_key, mapped_value)
+
@@ -374,14 +430,15 @@ let map_op = (m : register) : register => {
-## Folded Operations over Maps
-
-A *folded operation* is the most general of iterations. The folded
-function takes two arguments: an *accumulator* and the structure
-*element* at hand, with which it then produces a new accumulator. This
-enables having a partial result that becomes complete when the
-traversal of the data structure is over.
-
+
+function fold : (('accumulator -> ('key, 'value) -> 'accumulator) -> map ('key, 'value) -> 'accumulator) -> 'accumulator
+
+
+val fold : ('accumulator -> ('key * 'value) -> 'accumulator) -> ('key, 'value) map -> 'accumulator -> 'accumulator
+
+
+let fold: ((('accumulator, ('key, 'value)) => 'accumulator), map('key, 'value), 'accumulator) => 'accumulator
+
@@ -417,3 +474,28 @@ let fold_op = (m : register) : int => {
+
+function size : map ('key, 'value) -> nat
+
+
+val size : ('key, 'value) map -> nat
+
+
+let size: map('key, 'value) => nat
+
+
+Returns the number of items in the map.
+
+
+
+function mem : key -> map (key, value) -> bool
+
+
+val mem : 'key -> ('key, 'value) map => bool
+
+
+let mem : ('key, map('key, 'value)) => bool
+
+
+Checks if a key exists in the map.
+
diff --git a/gitlab-pages/docs/reference/set.md b/gitlab-pages/docs/reference/set.md
index eca62a741..9478a2048 100644
--- a/gitlab-pages/docs/reference/set.md
+++ b/gitlab-pages/docs/reference/set.md
@@ -1,20 +1,45 @@
---
id: set-reference
-title: Sets — Unordered unique collection of a type
+title: Set
+description: Set operations
+hide_table_of_contents: true
---
import Syntax from '@theme/Syntax';
+import SyntaxTitle from '@theme/SyntaxTitle';
-Sets are unordered collections of values of the same type, like lists
-are ordered collections. Like the mathematical sets and lists, sets
-can be empty and, if not, elements of sets in LIGO are *unique*,
-whereas they can be repeated in a *list*.
+Sets are unordered collections of unique values of the same type.
-# Empty Sets
+
+type set ('value)
+
+
+type 'value set
+
+
+type set('value)
+
+
+function empty : set('value)
+
+
+val empty : 'value set
+
+
+let empty: set('value)
+
+
+Create an empty set.
+```pascaligo group=sets
+const my_set : set (int) = Set.empty
+```
+
+Alternative syntax:
+
```pascaligo group=sets
const my_set : set (int) = set []
```
@@ -35,12 +60,26 @@ let my_set : set (int) = Set.empty;
+
+function literal : list('value) -> set('value)
+
+
+val literal : 'value list -> 'value set
+
+
+let literal: list('value) => set('value)
+
-# Non-empty Sets
-
+Create a non-empty set.
+```pascaligo group=sets
+const my_set : set (int) = Set.literal (list [3; 2; 2; 1])
+```
+
+Or use the following syntax sugar:
+
```pascaligo group=sets
const my_set : set (int) = set [3; 2; 2; 1]
```
@@ -50,7 +89,7 @@ const my_set : set (int) = set [3; 2; 2; 1]
```cameligo group=sets
let my_set : int set =
- Set.add 3 (Set.add 2 (Set.add 2 (Set.add 1 (Set.empty : int set))))
+ Set.literal [3; 2; 2; 1]
```
@@ -58,19 +97,33 @@ let my_set : int set =
```reasonligo group=sets
let my_set : set (int) =
- Set.add (3, Set.add (2, Set.add (2, Set.add (1, Set.empty : set (int)))));
+ Set.literal ([3, 2, 2, 1]);
```
+
+function mem : 'value -> set('value) -> 'bool
+
+
+val mem : 'value -> 'value set -> bool
+
+
+let mem: ('value, set('value)) => bool
+
-# Set Membership
-
+Checks if a value exists in the set.
```pascaligo group=sets
-const contains_3 : bool = my_set contains 3
+const contains_3 : bool = Set.mem(3, my_set)
+```
+
+Or:
+
+```pascaligo group=sets
+const contains_3_alt : bool = my_set contains 3
```
@@ -89,12 +142,17 @@ let contains_3 : bool = Set.mem (3, my_set);
+
+function cardinal : set('value) -> nat
+
+
+val cardinal : 'value set -> nat
+
+
+let cardinal: set('value) => nat
+
-# Cardinal of Sets
-
-The predefined function `Set.size` returns the number of
-elements in a given set as follows.
-
+Number of elements in a set.
@@ -102,7 +160,7 @@ elements in a given set as follows.
const cardinal : nat = Set.size (my_set)
```
-> Note that `size` is *deprecated*.
+> Note that `size` is *deprecated*. Please use `Set.size`
@@ -120,72 +178,41 @@ let cardinal : nat = Set.size (my_set);
+
+function add : 'value -> set('value) -> set('value)
+
+
+val add : 'value -> 'value set -> 'value set
+
+
+let add: ('value, set('value)) => set('value)
+
-# Updating Sets
+Add a value to a set.
-There are two ways to update a set, that is to add or remove from it.
+
+function remove : 'value -> set('value) -> set('value)
+
+
+val remove : 'value -> 'value set -> 'value set
+
+
+let remove: ('value, set('value)) => set('value)
+
+Remove a value from a set.
-
+
+function iter : ('a -> unit) -> set('a) -> unit
+
+
+val iter : ('a -> unit) -> 'a set -> unit
+
+
+let iter: (('a => unit), set('a)) => unit
+
-In PascaLIGO, either we create a new set from the given one, or we
-modify it in-place. First, let us consider the former way:
-```pascaligo group=sets
-const larger_set : set (int) = Set.add (4, my_set)
-const smaller_set : set (int) = Set.remove (3, my_set)
-```
-
-> Note that `set_add` and `set_remove` are *deprecated*.
-
-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
-possible to add elements by means of a patch, not remove any: it is
-the union of two sets.
-
-```pascaligo group=sets
-function update (var s : set (int)) : set (int) is block {
- patch s with set [4; 7]
-} with s
-
-const new_set : set (int) = update (my_set)
-```
-
-
-
-
-```cameligo group=sets
-let larger_set : int set = Set.add 4 my_set
-let smaller_set : int set = Set.remove 3 my_set
-```
-
-
-
-
-```reasonligo group=sets
-let larger_set : set (int) = Set.add (4, my_set);
-let smaller_set : set (int) = Set.remove (3, my_set);
-```
-
-
-
-
-# Functional Iteration over Sets
-
-A *functional iterator* is a function that traverses a data structure
-and calls in turn a given function over the elements of that structure
-to compute some value. Another approach is possible in PascaLIGO:
-*loops* (see the relevant section).
-
-There are three kinds of functional iterations over LIGO maps: the
-*iterated operation*, the *mapped operation* (not to be confused with
-the *map data structure*) and the *folded operation*.
-
-## Iterated Operation
-
-The first, the *iterated operation*, is an iteration over the map with
-no return value: its only use is to produce side-effects. This can be
-useful if for example you would like to check that each value inside
-of a map is within a certain range, and fail with an error otherwise.
+Iterate over values in a set.
@@ -221,15 +248,17 @@ let iter_op = (s : set (int)) : unit => {
+
+function fold : (('accumulator -> 'item -> 'accumulator) -> set ('item) -> 'accumulator) -> 'accumulator
+
+
+val fold : ('accumulator -> 'item -> 'accumulator) -> 'set list -> 'accumulator -> 'accumulator
+
+
+let fold: ((('accumulator, 'item) => 'accumulator), set('item), 'accumulator) => 'accumulator
+
-## Folded Operation
-
-A *folded operation* is the most general of iterations. The folded
-function takes two arguments: an *accumulator* and the structure
-*element* at hand, with which it then produces a new accumulator. This
-enables having a partial result that becomes complete when the
-traversal of the data structure is over.
-
+[Fold over values in a set](../language-basics/sets-lists-tuples#folded-operation)
@@ -241,17 +270,6 @@ const sum_of_elements : int = Set.fold (sum, my_set, 0)
> Note that `set_fold` is *deprecated*.
-It is possible to use a *loop* over a set as well.
-
-```pascaligo group=sets
-function loop (const s : set (int)) : int is block {
- var sum : int := 0;
- for element in set s block {
- sum := sum + element
- }
-} with sum
-```
-
@@ -269,4 +287,3 @@ let sum_of_elements : int = Set.fold (sum, my_set, 0);
```
-
diff --git a/gitlab-pages/docs/reference/string.md b/gitlab-pages/docs/reference/string.md
index c75e850a4..b61453ec7 100644
--- a/gitlab-pages/docs/reference/string.md
+++ b/gitlab-pages/docs/reference/string.md
@@ -1,45 +1,77 @@
---
id: string-reference
-title: String — Manipulate string data
+title: String
+description: Operations for strings.
+hide_table_of_contents: true
---
import Syntax from '@theme/Syntax';
+import SyntaxTitle from '@theme/SyntaxTitle';
-## String.size(s: string) : nat
+
+type string
+
+
+type string
+
+
+type string
+
-Get the size of a string. [Michelson only supports ASCII strings](http://tezos.gitlab.io/whitedoc/michelson.html#constants)
+A sequence of characters.
+
+
+function length : string -> nat
+
+
+val length : string -> nat
+
+
+let length: string => nat
+
+
+Get the size of a string.
+
+[Michelson only supports ASCII strings](http://tezos.gitlab.io/whitedoc/michelson.html#constants)
so for now you can assume that each character takes one byte of storage.
-
-
```pascaligo
-function string_size (const s: string) : nat is size(s)
+function string_size (const s: string) : nat is String.length(s)
```
+> Note that `size` and `String.size` are *deprecated*.
+
```cameligo
-let size_op (s: string) : nat = String.size s
+let size_op (s: string) : nat = String.length s
```
+> Note that `String.size` is *deprecated*.
+
```reasonligo
-let size_op = (s: string): nat => String.size(s);
+let size_op = (s: string): nat => String.length(s);
```
+> Note that `String.size` is *deprecated*.
+
-
-## String.length(s: string) : nat
-
-Alias for `String.size`.
-
-## String.slice(pos1: nat, pos2: nat, s: string) : string
+
+function sub : nat -> nat -> string -> string
+
+
+val sub : nat -> nat -> string -> string
+
+
+let sub: (nat, nat, string) => string
+
Get the substring of `s` between `pos1` inclusive and `pos2` inclusive. For example
the string "tata" given to the function below would return "at".
@@ -48,31 +80,41 @@ the string "tata" given to the function below would return "at".
```pascaligo
-function slice_op (const s : string) : string is string_slice(1n , 2n , s)
+function slice_op (const s : string) : string is String.sub(1n , 2n , s)
```
+> Note that `string_slice` is *deprecated*.
+
```cameligo
-let slice_op (s: string) : string = String.slice 1n 2n s
+let slice_op (s: string) : string = String.sub 1n 2n s
```
+> Note that `String.slice` is *deprecated*.
+
```reasonligo
-let slice_op = (s: string): string => String.slice(1n, 2n, s);
+let slice_op = (s: string): string => String.sub(1n, 2n, s);
```
+> Note that `String.slice` is *deprecated*.
+
-## String.sub(pos1: nat, pos2: nat, s: string) : string
-
-Alias for `String.slice`.
-
-## String.concat(s1: string, s2: string) : string
+
+function concat : string -> string -> string
+
+
+val concat : string -> string -> string
+
+
+let concat: (string, string) => string
+
Concatenate two strings and return the result.
@@ -81,21 +123,40 @@ Concatenate two strings and return the result.
```pascaligo
-function concat_op (const s : string) : string is s ^ "toto"
+function concat_op (const s : string) : string is String.concat(s, "toto")
+```
+
+Alternatively:
+
+```pascaligo
+function concat_op_alt (const s : string) : string is s ^ "toto"
```
```cameligo
-let concat_syntax (s: string) = s ^ "test_literal"
+let concat_syntax (s: string) = String.concat s "test_literal"
```
+Alternatively:
+
+```cameligo
+let concat_syntax_alt (s: string) = s ^ "test_literal"
+```
+
+
```reasonligo
-let concat_syntax = (s: string) => s ++ "test_literal";
+let concat_syntax = (s: string) => String.concat(s, "test_literal");
+```
+
+Alternatively:
+
+```reasonligo
+let concat_syntax_alt = (s: string) => s ++ "test_literal";
```
diff --git a/gitlab-pages/website/sidebars.json b/gitlab-pages/website/sidebars.json
index bde7acba5..36cff21e1 100644
--- a/gitlab-pages/website/sidebars.json
+++ b/gitlab-pages/website/sidebars.json
@@ -21,17 +21,20 @@
"advanced/first-contract",
"advanced/michelson-and-ligo"
],
- "API & Reference": [
+ "Reference": [
"api/cli-commands",
- "api/cheat-sheet",
+ "api/cheat-sheet"
+ ],
+ "API":[
"reference/big-map-reference",
+ "reference/bitwise-reference",
"reference/bytes-reference",
- "reference/crypto-reference",
- "reference/current-reference",
+ "reference/crypto-reference",
"reference/list-reference",
"reference/map-reference",
"reference/set-reference",
- "reference/string-reference"
+ "reference/string-reference",
+ "reference/current-reference"
]
},
"contributors-docs": {
diff --git a/src/passes/operators/operators.ml b/src/passes/operators/operators.ml
index 7d2807b44..deb541216 100644
--- a/src/passes/operators/operators.ml
+++ b/src/passes/operators/operators.ml
@@ -151,8 +151,8 @@ module Simplify = struct
(* String module *)
| "String.length" -> ok C_SIZE
- | "String.size" -> ok C_SIZE
- | "String.slice" -> ok C_SLICE
+ | "String.size" -> ok C_SIZE (* Deprecated *)
+ | "String.slice" -> ok C_SLICE (* Deprecated *)
| "String.sub" -> ok C_SLICE
| "String.concat" -> ok C_CONCAT