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

Merge branch 'more-api-docs-syntax-headers' into 'dev'

Browse Source 
Add remaining API docs

See merge request ligolang/ligo!503
This commit is contained in:
Sander 2020-03-17 15:38:41 +00:00
commit 78faa138da
11 changed files with 1056 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
gitlab-pages/docs/reference/big_map.md
View File

@ -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. The gast costs of deserialized maps are higher than standard maps as data is lazily deserialized.
<SyntaxTitle syntax="pascaligo"> <SyntaxTitle syntax="pascaligo">
type big_map (key, value) type big_map ('key, 'value)
</SyntaxTitle> </SyntaxTitle>
<SyntaxTitle syntax="cameligo"> <SyntaxTitle syntax="cameligo">
type ('key, 'value) big_map type ('key, 'value) big_map
@ -45,6 +45,7 @@ type register = (address, move) big_map
</Syntax> </Syntax>
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
The type of a big map from values of type `key` to The type of a big map from values of type `key` to
values of type `value` is `big_map (key, value)`. values of type `value` is `big_map (key, value)`.
@ -56,7 +57,7 @@ type register = big_map (address, move);
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo"> <SyntaxTitle syntax="pascaligo">
function empty : big_map (key, value) function empty : big_map ('key, 'value)
</SyntaxTitle> </SyntaxTitle>
<SyntaxTitle syntax="cameligo"> <SyntaxTitle syntax="cameligo">
val empty : ('key, 'value) big_map val empty : ('key, 'value) big_map
@ -97,7 +98,7 @@ let empty : register = Big_map.empty
<SyntaxTitle syntax="pascaligo"> <SyntaxTitle syntax="pascaligo">
function literal : list (key * value) -> big_map (key, value) function literal : list ('key * 'value) -> big_map ('key, 'value)
</SyntaxTitle> </SyntaxTitle>
<SyntaxTitle syntax="cameligo"> <SyntaxTitle syntax="cameligo">
val literal : ('key * 'value) list -> ('key, 'value) big_map val literal : ('key * 'value) list -> ('key, 'value) big_map
@ -149,7 +150,7 @@ let moves : register =
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo"> <SyntaxTitle syntax="pascaligo">
function find_opt : key -> big_map (key, value) -> option value function find_opt : 'key -> big_map ('key, 'value) -> option 'value
</SyntaxTitle> </SyntaxTitle>
<SyntaxTitle syntax="cameligo"> <SyntaxTitle syntax="cameligo">
val find_opt : 'key -> ('key, 'value) big_map -> 'value option val find_opt : 'key -> ('key, 'value) big_map -> 'value option
@ -197,7 +198,7 @@ let my_balance : option (move) =
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo"> <SyntaxTitle syntax="pascaligo">
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)
</SyntaxTitle> </SyntaxTitle>
<SyntaxTitle syntax="cameligo"> <SyntaxTitle syntax="cameligo">
val update: 'key -> 'value option -> ('key, 'value) big_map -> ('key, 'value) big_map val update: 'key -> 'value option -> ('key, 'value) big_map -> ('key, 'value) big_map
@ -262,7 +263,7 @@ let updated_map : register =
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo"> <SyntaxTitle syntax="pascaligo">
function add : key -> value -> big_map (key, value) -> big_map (key, value) function add : 'key -> 'value -> big_map ('key, 'value) -> big_map ('key, 'value)
</SyntaxTitle> </SyntaxTitle>
<SyntaxTitle syntax="cameligo"> <SyntaxTitle syntax="cameligo">
val add : 'key -> 'value -> ('key, 'value) big_map -> ('key, 'value) big_map val add : 'key -> 'value -> ('key, 'value) big_map -> ('key, 'value) big_map
@ -298,13 +299,13 @@ let add = (m: register): register =>
<SyntaxTitle syntax="pascaligo"> <SyntaxTitle syntax="pascaligo">
function remove: key -> big_map (key, value) -> big_map (key, value) function remove: 'key -> big_map ('key, 'value) -> big_map ('key, 'value)
</SyntaxTitle> </SyntaxTitle>
<SyntaxTitle syntax="cameligo"> <SyntaxTitle syntax="cameligo">
val remove: 'key -> ('key, 'value) big_map -> ('key, 'value) big_map val remove: 'key -> ('key, 'value) big_map -> ('key, 'value) big_map
</SyntaxTitle> </SyntaxTitle>
<SyntaxTitle syntax="reasonligo"> <SyntaxTitle syntax="reasonligo">
let remove: (key, big_map ('key, 'value)) => big_map ('key, 'value) let remove: ('key, big_map ('key, 'value)) => big_map ('key, 'value)
</SyntaxTitle> </SyntaxTitle>
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">

69
gitlab-pages/docs/reference/bitwise.md Normal file
View File

@ -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';
<SyntaxTitle syntax="pascaligo">
function and : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val and : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let and: (nat, nat) -> nat
</SyntaxTitle>
A bitwise `and` operation.
<SyntaxTitle syntax="pascaligo">
function or : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val or : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let or: (nat, nat) -> nat
</SyntaxTitle>
A bitwise `or` operation.
<SyntaxTitle syntax="pascaligo">
function xor : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val xor : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let xor: (nat, nat) -> nat
</SyntaxTitle>
A bitwise `xor` operation.
<SyntaxTitle syntax="pascaligo">
function shift_left : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val shift_left : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let shift_left: (nat, nat) -> nat
</SyntaxTitle>
A bitwise shift left operation.
<SyntaxTitle syntax="pascaligo">
function shift_right : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val shift_right : nat -> nat -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let shift_right: (nat, nat) -> nat
</SyntaxTitle>
A bitwise shift right operation.

91
gitlab-pages/docs/reference/bytes.md
View File

@ -1,21 +1,43 @@
--- ---
id: bytes-reference 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 Syntax from '@theme/Syntax';
import SyntaxTitle from '@theme/SyntaxTitle';
## Bytes.concat(b1: bytes, b2: bytes) : bytes <SyntaxTitle syntax="pascaligo">
type bytes
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type bytes
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type bytes
</SyntaxTitle>
<SyntaxTitle syntax="pascaligo">
function concat : bytes -> bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val concat : bytes -> bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let concat: (bytes, bytes) => bytes
</SyntaxTitle>
Concatenate together two `bytes` arguments and return the result. Concatenate together two `bytes` arguments and return the result.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo ```pascaligo
function concat_op (const s : bytes) : bytes is function concat_op (const s : bytes) : bytes is Bytes.concat(s , 0x7070)
begin skip end with bytes_concat(s , 0x7070)
``` ```
> Note that `bytes_concat` is *deprecated*.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -33,41 +55,58 @@ let concat_op = (s: bytes): bytes => Bytes.concat(s, 0x7070);
</Syntax> </Syntax>
## Bytes.slice(pos1: nat, pos2: nat, data: bytes) : bytes <SyntaxTitle syntax="pascaligo">
function sub : nat -> nat -> bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val sub : nat -> nat -> bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let sub : (nat, nat, bytes) => bytes
</SyntaxTitle>
Extract the bytes between `pos1` and `pos2`. **Positions are zero indexed and Extract the bytes between `pos1` and `pos2`. **Positions are zero indexed and
inclusive**. For example if you gave the input "ff7a7aff" to the following: inclusive**. For example if you gave the input "ff7a7aff" to the following:
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo ```pascaligo
function slice_op (const s : bytes) : bytes is function slice_op (const s : bytes) : bytes is Bytes.sub(1n , 2n , s)
begin skip end with bytes_slice(1n , 2n , s)
``` ```
> Note that `bytes_slice` is *deprecated*.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
```cameligo ```cameligo
let slice_op (s : bytes) : bytes = let slice_op (s : bytes) : bytes = Bytes.sub 1n 2n s
Bytes.slice 1n 2n s
``` ```
> Note that `Bytes.slice` is *deprecated*.
</Syntax> </Syntax>
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
``` ```
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*.
</Syntax> </Syntax>
It would return "7a7a" rather than "ff7a" or "ff" or "7a". It would return "7a7a" rather than "ff7a" or "ff" or "7a".
## Bytes.pack(data: a') : bytes <SyntaxTitle syntax="pascaligo">
function pack : 'a -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val pack : 'a -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let pack : 'a => bytes
</SyntaxTitle>
Converts Michelson data structures to a binary format for serialization. Converts Michelson data structures to a binary format for serialization.
@ -105,10 +144,19 @@ let id_string = (p: string) : option(string) => {
</Syntax> </Syntax>
## Bytes.unpack(packed: bytes) : a' <SyntaxTitle syntax="pascaligo">
function unpack : bytes -> option 'a
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val unpack : bytes -> 'a option
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let unpack: bytes => option('a)
</SyntaxTitle>
Reverses the result of using `unpack` on data, going from Michelson's binary Reverses the result of using `pack` on data.
serialization format to the `option` type annotated on the call.
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. > ⚠️ `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) => {
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function length : bytes -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val length : bytes -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let length: bytes => nat
</SyntaxTitle>

118
gitlab-pages/docs/reference/crypto.md
View File

@ -1,11 +1,58 @@
--- ---
id: crypto-reference id: crypto-reference
title: Crypto — Cryptographic functions title: Crypto
description: Cryptographic operations
hide_table_of_contents: true
--- ---
import Syntax from '@theme/Syntax'; import Syntax from '@theme/Syntax';
import SyntaxTitle from '@theme/SyntaxTitle';
## Crypto.blake2b(data: bytes): bytes <SyntaxTitle syntax="pascaligo">
type key
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type key
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type key
</SyntaxTitle>
A public cryptographic key.
<SyntaxTitle syntax="pascaligo">
type key_hash
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type key_hash
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type key_hash
</SyntaxTitle>
The hash of a public cryptographic key.
<SyntaxTitle syntax="pascaligo">
type signature
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type signature
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type signature
</SyntaxTitle>
A cryptographic signature.
<SyntaxTitle syntax="pascaligo">
function blake2b : bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val blake2b : bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let blake2b: bytes => bytes
</SyntaxTitle>
Runs the [blake2b hash algorithm](https://en.wikipedia.org/wiki/BLAKE_(hash_function)#BLAKE2) 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. 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.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo ```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`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -25,6 +74,8 @@ function hasherman_blake (const s: bytes) : bytes is blake2b(s)
let hasherman_blake (s: bytes) : bytes = Crypto.blake2b s let hasherman_blake (s: bytes) : bytes = Crypto.blake2b s
``` ```
</Syntax> </Syntax>
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
@ -34,8 +85,15 @@ let hasherman_blake = (s: bytes) => Crypto.blake2b(s);
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
## Crypto.sha256(data: bytes) : bytes function sha256 : bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val sha256 : bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let sha256: bytes => bytes
</SyntaxTitle>
Runs the [sha256 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the given Runs the [sha256 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the given
`bytes` data and returns a `bytes` representing the hash. `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
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo ```pascaligo
function hasherman (const s : bytes) : bytes is function hasherman (const s : bytes) : bytes is Crypto.sha256(s)
begin skip end with sha_256(s)
``` ```
> Note that `sha_256` is *deprecated*. Please use `Crypto.sha256`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -66,8 +125,15 @@ let hasherman = (s: bytes): bytes => Crypto.sha256(s);
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
## Crypto.sha512(data: bytes) : bytes function sha512 : bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val sha512 : bytes -> bytes
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let sha512: bytes => bytes
</SyntaxTitle>
Runs the [sha512 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the given Runs the [sha512 hash algorithm](https://en.wikipedia.org/wiki/SHA-2) over the given
`bytes` data and returns a `bytes` representing the hash. `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
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo ```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`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -96,8 +164,15 @@ let hasherman512 = (s: bytes) => Crypto.sha512(s);
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
## Crypto.hash_key(k: key) : key_hash function hash_key : key -> key_hash
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val hash_key : key -> key_hash
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let hash_key: key => key_hash
</SyntaxTitle>
Hashes a key for easy comparison and storage. Hashes a key for easy comparison and storage.
@ -108,11 +183,13 @@ Hashes a key for easy comparison and storage.
```pascaligo ```pascaligo
function check_hash_key (const kh1 : key_hash; const k2 : key) : bool * key_hash is block { function check_hash_key (const kh1 : key_hash; const k2 : key) : bool * key_hash is block {
var ret : bool := False ; 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; if kh1 = kh2 then ret := True else skip;
} with (ret, kh2) } with (ret, kh2)
``` ```
> Note that `hash_key` is *deprecated*. Please use `Crypto.hash_key`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -141,8 +218,15 @@ let check_hash_key = ((kh1, k2): (key_hash, key)) : (bool, key_hash) => {
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
## Crypto.check(pk: key, signed: signature, data: bytes) : bool function check : key -> signature -> bytes -> bool
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val check : key -> signature -> bytes -> bool
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let check: (key, signature, bytes) => bool
</SyntaxTitle>
Check that a message has been signed by a particular key. Check that a message has been signed by a particular key.
@ -157,9 +241,11 @@ function check_signature
(const pk: key; (const pk: key;
const signed: signature; const signed: signature;
const msg: bytes) : bool 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`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">

322
gitlab-pages/docs/reference/current.md
View File

@ -1,11 +1,96 @@
--- ---
id: current-reference 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 Syntax from '@theme/Syntax';
import SyntaxTitle from '@theme/SyntaxTitle';
# Tezos.balance <SyntaxTitle syntax="pascaligo">
type timestamp
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type timestamp
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type timestamp
</SyntaxTitle>
A date in the real world.
<SyntaxTitle syntax="pascaligo">
type mutez
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type mutez
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type mutez
</SyntaxTitle>
A specific type for tokens.
<SyntaxTitle syntax="pascaligo">
type address
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type address
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type address
</SyntaxTitle>
An untyped address which can refer to a smart contract or account.
<SyntaxTitle syntax="pascaligo">
type contract('parameter)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type 'parameter contract
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type contract('parameter)
</SyntaxTitle>
A typed contract.
Use `unit` as `parameter` to indicate an implicit account.
<SyntaxTitle syntax="pascaligo">
type operation
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type operation
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type operation
</SyntaxTitle>
An operation emitted by the contract
<SyntaxTitle syntax="pascaligo">
type chain_id
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type chain_id
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type chain_id
</SyntaxTitle>
The identifier of a chain, used to indicate test or main chains.
<SyntaxTitle syntax="pascaligo">
function balance : mutez
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val balance : mutez
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let balance: mutez
</SyntaxTitle>
Get the balance for the contract. 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) ((nil : list (operation)), Tezos.balance)
``` ```
> Note that `balance` and `Current.balance` are *deprecated*. > Note that `balance` and `Current.balance` are *deprecated*.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -42,7 +127,15 @@ let main = ((p,s) : (unit, tez)) =>
</Syntax> </Syntax>
## Tezos.now <SyntaxTitle syntax="pascaligo">
function now : timestamp
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val now : timestamp
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let now: timestamp
</SyntaxTitle>
Returns the current time as a [unix timestamp](https://en.wikipedia.org/wiki/Unix_time). 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; const one_day_later: timestamp = some_date + one_day;
``` ```
> Note that `now` is *deprecated*. > Note that `now` is *deprecated*. Please use `Tezos.now`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -106,7 +199,7 @@ const one_day: int = 86_400;
const in_24_hrs: timestamp = today - one_day; const in_24_hrs: timestamp = today - one_day;
``` ```
> Note that `now` is *deprecated*. > Note that `now` is *deprecated*. Please use `Tezos.now`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -145,7 +238,7 @@ for numbers
const not_tommorow: bool = (Tezos.now = in_24_hrs) const not_tommorow: bool = (Tezos.now = in_24_hrs)
``` ```
> Note that `now` is *deprecated*. > Note that `now` is *deprecated*. Please use `Tezos.now`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -169,7 +262,15 @@ let not_tomorrow: bool = (Tezos.now == in_24_hrs);
## Amount <SyntaxTitle syntax="pascaligo">
function amount : mutez
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val amount : mutez
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let amount: mutez
</SyntaxTitle>
Get the amount of tez provided by the sender to complete this Get the amount of tez provided by the sender to complete this
transaction. transaction.
@ -207,7 +308,15 @@ let threshold = (p : unit) : int =>
</Syntax> </Syntax>
## Sender <SyntaxTitle syntax="pascaligo">
function sender : address
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val sender : address
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let sender: address
</SyntaxTitle>
Get the address that initiated the current transaction. 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 function main (const p : unit) : address is Tezos.sender
``` ```
> Note that `sender` is *deprecated*. > Note that `sender` is *deprecated*. Please use `Tezos.sender`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -243,7 +352,15 @@ let main = (p : unit) : address => Tezos.sender;
## Address <SyntaxTitle syntax="pascaligo">
function address : contract 'a -> address
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val address : 'a contract -> address
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let address: contract('a) => address
</SyntaxTitle>
Get the address associated with a value of type `contract`. 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) } 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.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -287,7 +404,15 @@ let main = (p : key_hash) : address => {
</Syntax> </Syntax>
## Self Address <SyntaxTitle syntax="pascaligo">
function self_address : address
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val self_address : address
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let self_address: address
</SyntaxTitle>
Get the address of the currently running contract. 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 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`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -320,8 +445,15 @@ let main = (p : unit) : address => Tezos.self_address;
> Note that `Current.self_address` is *deprecated*. > Note that `Current.self_address` is *deprecated*.
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
## Self function self : string -> contract 'a
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val self : string -> 'a contract
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let self: string => contract('a)
</SyntaxTitle>
Typecast the currently running contract with an entrypoint annotation. Typecast the currently running contract with an entrypoint annotation.
If your are using entrypoints: use "%bar" for constructor Bar If your are using entrypoints: use "%bar" for constructor Bar
@ -353,13 +485,21 @@ let main = (p: unit) : contract(unit) =>
</Syntax> </Syntax>
## Implicit Account <SyntaxTitle syntax="pascaligo">
function implicit_account : key_hash -> contract 'a
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val implicit_account : key_hash -> 'a contract
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let implicit_account: key_hash => contract('a)
</SyntaxTitle>
Get the default contract associated with an on-chain key-pair. This Get the default contract associated with an on-chain key-pair. This
contract does not execute code, instead it exists to receive tokens on contract does not execute code, instead it exists to receive tokens on
behalf of a key's owner. behalf of a key's owner.
See also: http://tezos.gitlab.io/user/glossary.html#implicit-account
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
@ -368,7 +508,7 @@ function main (const kh: key_hash) : contract (unit) is
Tezos.implicit_account (kh) Tezos.implicit_account (kh)
``` ```
> Note that `implicit_account` is *deprecated*. > Note that `implicit_account` is *deprecated*. Please use `Tezos.implicit_account`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -392,7 +532,15 @@ let main = (kh : key_hash): contract (unit) =>
</Syntax> </Syntax>
## Source <SyntaxTitle syntax="pascaligo">
function source : address
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val source : address
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let source: address
</SyntaxTitle>
Get the _originator_ (address) of the current transaction. That is, if Get the _originator_ (address) of the current transaction. That is, if
a chain of transactions led to the current execution get the address 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 function main (const p: unit) : address is Tezos.source
``` ```
> Note that `source` is *deprecated*. > Note that `source` is *deprecated*. Please use `Tezos.source`.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -449,7 +597,15 @@ let main = (p : unit) : address => Tezos.source;
</Syntax> </Syntax>
## Failwith <SyntaxTitle syntax="pascaligo">
function failwith : string -> unit
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
function failwith : string -> unit
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
function failwith : string -> unit
</SyntaxTitle>
Cause the contract to fail with an error message. Cause the contract to fail with an error message.
@ -485,3 +641,125 @@ let main = ((p,s) : (int, unit)) =>
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function chain_id : chain_id
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val chain_id : chain_id
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let chain_id: chain_id
</SyntaxTitle>
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`.
<Syntax syntax="pascaligo">
```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)
```
</Syntax>
<Syntax syntax="cameligo">
```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))
```
</Syntax>
<Syntax syntax="reasonligo">
```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);
}
};
```
</Syntax>
<SyntaxTitle syntax="pascaligo">
function transaction : 'parameter -> mutez -> contract('parameter) -> operation
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val transaction : 'parameter -> mutez -> 'parameter contract -> operation
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let transaction: 'parameter -> mutez -> contract('parameter) -> operation
</SyntaxTitle>
Create a transaction to a contract or account.
To indicate an account, use `unit` as `parameter`.
<SyntaxTitle syntax="pascaligo">
function set_delegate : option(key_hash) -> operation
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val set_delegate : key_hash option -> operation
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let set_delegate: option(key_hash) => operation
</SyntaxTitle>
Create a delegation.
See also: http://tezos.gitlab.io/user/glossary.html?highlight=delegate#delegate
<SyntaxTitle syntax="pascaligo">
function get_contract_opt : address -> option(contract('parameter))
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val get_contract_opt : address -> 'parameter contract option
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let get_contract_opt : address => option(contract('parameter))
</SyntaxTitle>
Get a contract from an address.
When no contract is found or the contract doesn't match the type,
`None` is returned.
<SyntaxTitle syntax="pascaligo">
function get_entrypoint_opt : string -> address -> option(contract('parameter))
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
function get_entrypoint_opt : string -> address -> 'parameter contract option
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
function get_entrypoint_opt: (string, address) => option(contract('parameter))
</SyntaxTitle>
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.

211
gitlab-pages/docs/reference/list.md
View File

@ -1,96 +1,62 @@
--- ---
id: list-reference id: list-reference
title: Lists — Linear Collections title: List
description: List operations
hide_table_of_contents: true
--- ---
import Syntax from '@theme/Syntax'; import Syntax from '@theme/Syntax';
import SyntaxTitle from '@theme/SyntaxTitle';
Lists are linear collections of elements of the same type. Linear <SyntaxTitle syntax="pascaligo">
means that, in order to reach an element in a list, we must visit all type list ('t)
the elements before (sequential access). Elements can be repeated, as </SyntaxTitle>
only their order in the collection matters. The first element is <SyntaxTitle syntax="cameligo">
called the *head*, and the sub-list after the head is called the type 't list
*tail*. For those familiar with algorithmic data structure, you can </SyntaxTitle>
think of a list a *stack*, where the top is written on the left. <SyntaxTitle syntax="reasonligo">
type list('t)
</SyntaxTitle>
# Defining Lists A sequence of elements of the same type.
<SyntaxTitle syntax="pascaligo">
function length : nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val length : nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let length: nat
</SyntaxTitle>
<Syntax syntax="pascaligo"> Get the number of elements in a list.
```pascaligo group=lists <SyntaxTitle syntax="pascaligo">
const empty_list : list (int) = nil // Or list [] function size : nat
const my_list : list (int) = list [1; 2; 2] // The head is 1 </SyntaxTitle>
``` <SyntaxTitle syntax="cameligo">
val size : nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let size: nat
</SyntaxTitle>
</Syntax> Get the number of elements in a list.
<Syntax syntax="cameligo">
```cameligo group=lists Synonym for `List.length`.
let empty_list : int list = []
let my_list : int list = [1; 2; 2] // The head is 1
```
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=lists
let empty_list : list (int) = [];
let my_list : list (int) = [1, 2, 2]; // The head is 1
```
</Syntax>
# 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*).
<Syntax syntax="pascaligo">
```pascaligo group=lists
const larger_list : list (int) = 5 # my_list // [5;1;2;2]
```
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=lists
let larger_list : int list = 5 :: my_list // [5;1;2;2]
```
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=lists
let larger_list : list (int) = [5, ...my_list]; // [5,1,2,2]
```
</Syntax>
# 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.
<SyntaxTitle syntax="pascaligo">
function iter : ('a -> unit) -> list('a) -> unit
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val iter : ('a -> unit) -> 'a list -> unit
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let iter: (('a => unit), list('a)) => unit
</SyntaxTitle>
Iterate over items in a list.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
@ -104,6 +70,8 @@ function iter_op (const l : list (int)) : unit is
> Note that `list_iter` is *deprecated*. > Note that `list_iter` is *deprecated*.
Alternatively it's also possible to use [loops](../language-basics/loops.md).
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -126,17 +94,23 @@ let iter_op = (l : list (int)) : unit => {
</Syntax> </Syntax>
## Mapped Operation over Lists <SyntaxTitle syntax="pascaligo">
function map : ('a -> 'b) -> list('a) -> list('b)
We may want to change all the elements of a given list by applying to </SyntaxTitle>
them a function. This is called a *map operation*, not to be confused <SyntaxTitle syntax="cameligo">
with the map data structure. val map : ('a -> 'b) -> 'a list -> 'b list
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let map: (('a => 'b), list('a)) => list('b)
</SyntaxTitle>
Apply a function to items of a list to create a new list.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=lists ```pascaligo group=lists
const larger_list: list(int) = list [1; 2; 3]
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
@ -149,6 +123,8 @@ const plus_one : list (int) = List.map (increment, larger_list)
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
```cameligo group=lists ```cameligo group=lists
let larger_list: int list = [1; 2; 3]
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
@ -159,6 +135,8 @@ let plus_one : int list = List.map increment larger_list
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
```reasonligo group=lists ```reasonligo group=lists
let larger_list: list(int) = [1, 2, 3];
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
@ -167,22 +145,25 @@ let plus_one : list (int) = List.map (increment, larger_list);
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function fold : (('accumulator -> 'item -> 'accumulator) -> list('item) -> 'accumulator) -> 'accumulator
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val fold : ('accumulator -> 'item -> 'accumulator) -> 'item list -> 'accumulator -> 'accumulator
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let fold: ((('accumulator, 'item) => 'accumulator), list('item), 'accumulator) => 'accumulator
</SyntaxTitle>
[Fold over items in a list](../language-basics/sets-lists-tuples#folded-operation-over-lists);
## 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.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=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 function sum (const acc : int; const i : int): int is acc + i
const sum_of_elements : int = List.fold (sum, my_list, 0) 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)
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
```cameligo group=lists ```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 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
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
```reasonligo group=lists ```reasonligo group=lists
let my_list : list(int) = [1, 2, 3];
let sum = ((result, i): (int, int)): int => result + i; let sum = ((result, i): (int, int)): int => result + i;
let sum_of_elements : int = List.fold (sum, my_list, 0); let sum_of_elements : int = List.fold (sum, my_list, 0);
``` ```
</Syntax> </Syntax>
# List Length
Get the number of elements in a list.
<Syntax syntax="pascaligo">
```pascaligo
function size_of (const l : list (int)) : nat is List.length (l)
```
> Note that `size` is *deprecated*.
</Syntax>
<Syntax syntax="cameligo">
```cameligo
let size_of (l : int list) : nat = List.length l
```
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo
let size_of = (l : list (int)) : nat => List.length (l);
```
</Syntax>

330
gitlab-pages/docs/reference/map.md
View File

@ -1,22 +1,28 @@
--- ---
id: map-reference id: map-reference
title: Maps title: Map
description: Map operations
hide_table_of_contents: true
--- ---
import Syntax from '@theme/Syntax'; import Syntax from '@theme/Syntax';
import SyntaxTitle from '@theme/SyntaxTitle';
*Maps* are a data structure which associate values of the same type to <SyntaxTitle syntax="pascaligo">
values of the same type. The former are called *key* and the latter type map ('key, 'value)
*values*. Together they make up a *binding*. An additional requirement </SyntaxTitle>
is that the type of the keys must be *comparable*, in the Michelson <SyntaxTitle syntax="cameligo">
sense. type ('key, 'value) map
</SyntaxTitle>
# Declaring a Map <SyntaxTitle syntax="reasonligo">
type map ('key, 'value)
</SyntaxTitle>
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
The type of a map from values of type `key` to
values of type `value` is `map (key, value)`.
```pascaligo group=maps ```pascaligo group=maps
type move is int * int type move is int * int
type register is map (address, move) type register is map (address, move)
@ -25,6 +31,9 @@ type register is map (address, move)
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
The type of a map from values of type `key` to values
of type `value` is `(key, value) map`.
```cameligo group=maps ```cameligo group=maps
type move = int * int type move = int * int
type register = (address, move) map type register = (address, move) map
@ -33,6 +42,9 @@ type register = (address, move) map
</Syntax> </Syntax>
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
The type of a map from values of type `key` to
values of type `value` is `map (key, value)`.
```reasonligo group=maps ```reasonligo group=maps
type move = (int, int); type move = (int, int);
type register = map (address, move); type register = map (address, move);
@ -40,13 +52,26 @@ type register = map (address, move);
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function empty : map ('key, 'value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val empty : ('key, 'value) map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let empty: map('key, 'value)
</SyntaxTitle>
# Creating an Empty Map Create an empty map.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=maps
const empty : register = Map.empty
```
Or
```pascaligo group=maps ```pascaligo group=maps
const empty : register = map [] const empty : register = map []
``` ```
@ -68,16 +93,34 @@ let empty : register = Map.empty
</Syntax> </Syntax>
# Creating a Non-empty Map <SyntaxTitle syntax="pascaligo">
function literal : list ('key * 'value) -> map ('key, 'value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val literal : ('key * 'value) list -> ('key, 'value) map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let literal: list(('key, 'value)) => map('key, 'value)
</SyntaxTitle>
Create a non-empty map.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=maps ```pascaligo group=maps
const moves : register = 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 [ map [
("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address) -> (1,2); ("tz1KqTpEZ7Yob7QbPE4Hy4Wo8fHG8LhKxZSx" : address) -> (1,2);
("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) -> (0,3)] ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address) -> (0,3)];
``` ```
</Syntax> </Syntax>
@ -103,14 +146,32 @@ let moves : register =
</Syntax> </Syntax>
# Accessing Map Bindings <SyntaxTitle syntax="pascaligo">
function find_opt : 'key -> map ('key, 'value) -> option 'value
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val find_opt : 'key -> ('key, 'value) map -> 'value option
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let find_opt : ('key, map ('key, 'value)) => option ('value)
</SyntaxTitle>
Retrieve a (option) value from a map with the given key. Returns `None` if the
key is missing and the value otherwise.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=maps ```pascaligo group=maps
const my_balance : option (move) = 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)];
``` ```
</Syntax> </Syntax>
@ -126,67 +187,40 @@ let my_balance : move option =
```reasonligo group=maps ```reasonligo group=maps
let my_balance : option (move) = let my_balance : option (move) =
Map.find_opt (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), moves); Map.find_opt ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address, moves);
``` ```
</Syntax> </Syntax>
Notice how the value we read is an optional value: this is to force <SyntaxTitle syntax="pascaligo">
the reader to account for a missing key in the map. This requires function update : 'key -> option 'value -> map ('key, 'value) -> map ('key, 'value)
*pattern matching*. </SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val update: 'key -> 'value option -> ('key, 'value) map -> ('key, 'value) map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let update: ('key, option('value), map('key, 'value)) => map ('key, 'value)
</SyntaxTitle>
Note: when `None` is used as a value, the key and associated value is removed
from the map.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=maps ```pascaligo group=maps
function force_access (const key : address; const moves : register) : move is const updated_map : register = Map.update(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), Some (4,9), moves);
case moves[key] of
Some (move) -> move
| None -> (failwith ("No move.") : move)
end
``` ```
</Syntax> Alternatively:
<Syntax syntax="cameligo">
```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)
```
</Syntax>
<Syntax syntax="reasonligo">
```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
}
};
```
</Syntax>
# 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*.
<Syntax syntax="pascaligo">
```pascaligo group=maps ```pascaligo group=maps
function assign (var m : register) : register is
function update (var m : register) : register is
block { block {
m [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address)] := (4,9) m [("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address)] := (4,9);
} with m } with m
``` ```
If multiple bindings need to be updated, PascaLIGO offers a *patch If multiple bindings need to be updated, PascaLIGO offers a *patch
@ -206,14 +240,40 @@ function assignments (var m : register) : register is
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
```cameligo group=maps ```cameligo group=maps
let assign (m : register) : register = let updated_map : register =
Map.update 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. </Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=maps
let updated_map : register =
Map.update
(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), Some ((4,9)), moves);
```
</Syntax>
<SyntaxTitle syntax="pascaligo">
function add : 'key -> 'value -> map ('key, 'value) -> map ('key, 'value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val add : 'key -> 'value -> ('key, 'value) map -> ('key, 'value) map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let add: ('key, 'value, map('key, 'value)) => map('key, 'value)
</SyntaxTitle>
<Syntax syntax="pascaligo">
```pascaligo group=maps
const added_item : register = Map.add (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (4, 9), moves)
```
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=maps ```cameligo group=maps
let add (m : register) : register = let add (m : register) : register =
@ -225,18 +285,7 @@ let add (m : register) : register =
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
```reasonligo group=maps ```reasonligo group=maps
let assign = (m : register) : register => let add = (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 =>
Map.add Map.add
(("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (4,9), m); (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN" : address), (4,9), m);
``` ```
@ -244,57 +293,63 @@ let add = (m : register) : register =>
</Syntax> </Syntax>
To remove a binding from a map, we need its key. <SyntaxTitle syntax="pascaligo">
function remove : 'key -> map ('key, 'value) -> map ('key, 'value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val remove : 'key -> ('key, 'value) map -> ('key, 'value) map
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let remove: (key, map('key, 'value)) => map('key, 'value)
</SyntaxTitle>
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=maps ```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 { block {
remove key from map moves remove ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) from map moves
} with moves } with m
const updated_map : register = rem (moves)
``` ```
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
```cameligo group=maps ```cameligo group=maps
let delete (key, moves : address * register) : register = let updated_map : register =
Map.remove key moves Map.remove ("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address) moves
``` ```
</Syntax> </Syntax>
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
```reasonligo group=maps ```reasonligo group=maps
let delete = ((key, moves) : (address, register)) : register => let updated_map : register =
Map.remove (key, moves); Map.remove (("tz1gjaF81ZRRvdzjobyfVNsAeSC6PScjfQwN": address), moves)
``` ```
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
# Functional Iteration over Maps function iter : ((key, value) -> unit) -> map (key, value) -> unit
</SyntaxTitle>
A *functional iterator* is a function that traverses a data structure <SyntaxTitle syntax="cameligo">
and calls in turn a given function over the elements of that structure val iter : (('key * 'value) -> unit) -> ('key, 'value) map -> unit
to compute some value. Another approach is possible in PascaLIGO: </SyntaxTitle>
*loops* (see the relevant section). <SyntaxTitle syntax="reasonligo">
let iter: ((('key, 'value)) => unit, map('key, 'value)) => unit
There are three kinds of functional iterations over LIGO maps: the </SyntaxTitle>
*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.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
@ -330,14 +385,15 @@ let iter_op = (m : register) : unit => {
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
## Map Operations over Maps function map : (('key, 'value) -> ('mapped_key, 'mapped_item)) -> map ('key, 'value) -> map ('mapped_key, 'mapped_value)
</SyntaxTitle>
We may want to change all the bindings of a map by applying to them a <SyntaxTitle syntax="cameligo">
function. This is called a *map operation*, not to be confused with val map : (('key * 'value) -> ('mapped_key * 'mapped_item)) -> (key, value) map -> (mapped_key, mapped_value) map
the map data structure. The predefined functional iterator </SyntaxTitle>
implementing the map operation over maps is called `Map.map`. <SyntaxTitle syntax="reasonligo">
let map: ((('key, 'value)) => ('mapped_key, 'mapped_item), map(key, value)) => map(mapped_key, mapped_value)
</SyntaxTitle>
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
@ -374,14 +430,15 @@ let map_op = (m : register) : register => {
</Syntax> </Syntax>
## Folded Operations over Maps <SyntaxTitle syntax="pascaligo">
function fold : (('accumulator -> ('key, 'value) -> 'accumulator) -> map ('key, 'value) -> 'accumulator) -> 'accumulator
A *folded operation* is the most general of iterations. The folded </SyntaxTitle>
function takes two arguments: an *accumulator* and the structure <SyntaxTitle syntax="cameligo">
*element* at hand, with which it then produces a new accumulator. This val fold : ('accumulator -> ('key * 'value) -> 'accumulator) -> ('key, 'value) map -> 'accumulator -> 'accumulator
enables having a partial result that becomes complete when the </SyntaxTitle>
traversal of the data structure is over. <SyntaxTitle syntax="reasonligo">
let fold: ((('accumulator, ('key, 'value)) => 'accumulator), map('key, 'value), 'accumulator) => 'accumulator
</SyntaxTitle>
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
@ -417,3 +474,28 @@ let fold_op = (m : register) : int => {
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function size : map ('key, 'value) -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val size : ('key, 'value) map -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let size: map('key, 'value) => nat
</SyntaxTitle>
Returns the number of items in the map.
<SyntaxTitle syntax="pascaligo">
function mem : key -> map (key, value) -> bool
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val mem : 'key -> ('key, 'value) map => bool
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let mem : ('key, map('key, 'value)) => bool
</SyntaxTitle>
Checks if a key exists in the map.

217
gitlab-pages/docs/reference/set.md
View File

@ -1,20 +1,45 @@
--- ---
id: set-reference 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 Syntax from '@theme/Syntax';
import SyntaxTitle from '@theme/SyntaxTitle';
Sets are unordered collections of values of the same type, like lists Sets are unordered collections of unique values of the same type.
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*.
# Empty Sets <SyntaxTitle syntax="pascaligo">
type set ('value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type 'value set
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type set('value)
</SyntaxTitle>
<SyntaxTitle syntax="pascaligo">
function empty : set('value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val empty : 'value set
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let empty: set('value)
</SyntaxTitle>
Create an empty set.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=sets
const my_set : set (int) = Set.empty
```
Alternative syntax:
```pascaligo group=sets ```pascaligo group=sets
const my_set : set (int) = set [] const my_set : set (int) = set []
``` ```
@ -35,12 +60,26 @@ let my_set : set (int) = Set.empty;
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function literal : list('value) -> set('value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val literal : 'value list -> 'value set
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let literal: list('value) => set('value)
</SyntaxTitle>
# Non-empty Sets Create a non-empty set.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=sets
const my_set : set (int) = Set.literal (list [3; 2; 2; 1])
```
Or use the following syntax sugar:
```pascaligo group=sets ```pascaligo group=sets
const my_set : set (int) = set [3; 2; 2; 1] 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 ```cameligo group=sets
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.literal [3; 2; 2; 1]
``` ```
</Syntax> </Syntax>
@ -58,19 +97,33 @@ let my_set : int set =
```reasonligo group=sets ```reasonligo group=sets
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.literal ([3, 2, 2, 1]);
``` ```
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function mem : 'value -> set('value) -> 'bool
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val mem : 'value -> 'value set -> bool
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let mem: ('value, set('value)) => bool
</SyntaxTitle>
# Set Membership Checks if a value exists in the set.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo group=sets ```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
``` ```
</Syntax> </Syntax>
@ -89,12 +142,17 @@ let contains_3 : bool = Set.mem (3, my_set);
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function cardinal : set('value) -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val cardinal : 'value set -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let cardinal: set('value) => nat
</SyntaxTitle>
# Cardinal of Sets Number of elements in a set.
The predefined function `Set.size` returns the number of
elements in a given set as follows.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
@ -102,7 +160,7 @@ elements in a given set as follows.
const cardinal : nat = Set.size (my_set) const cardinal : nat = Set.size (my_set)
``` ```
> Note that `size` is *deprecated*. > Note that `size` is *deprecated*. Please use `Set.size`
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -120,72 +178,41 @@ let cardinal : nat = Set.size (my_set);
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function add : 'value -> set('value) -> set('value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val add : 'value -> 'value set -> 'value set
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let add: ('value, set('value)) => set('value)
</SyntaxTitle>
# Updating Sets Add a value to a set.
There are two ways to update a set, that is to add or remove from it. <SyntaxTitle syntax="pascaligo">
function remove : 'value -> set('value) -> set('value)
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val remove : 'value -> 'value set -> 'value set
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let remove: ('value, set('value)) => set('value)
</SyntaxTitle>
Remove a value from a set.
<Syntax syntax="pascaligo"> <SyntaxTitle syntax="pascaligo">
function iter : ('a -> unit) -> set('a) -> unit
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val iter : ('a -> unit) -> 'a set -> unit
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let iter: (('a => unit), set('a)) => unit
</SyntaxTitle>
In PascaLIGO, either we create a new set from the given one, or we Iterate over values in a set.
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)
```
</Syntax>
<Syntax syntax="cameligo">
```cameligo group=sets
let larger_set : int set = Set.add 4 my_set
let smaller_set : int set = Set.remove 3 my_set
```
</Syntax>
<Syntax syntax="reasonligo">
```reasonligo group=sets
let larger_set : set (int) = Set.add (4, my_set);
let smaller_set : set (int) = Set.remove (3, my_set);
```
</Syntax>
# 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.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
@ -221,15 +248,17 @@ let iter_op = (s : set (int)) : unit => {
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
function fold : (('accumulator -> 'item -> 'accumulator) -> set ('item) -> 'accumulator) -> 'accumulator
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val fold : ('accumulator -> 'item -> 'accumulator) -> 'set list -> 'accumulator -> 'accumulator
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let fold: ((('accumulator, 'item) => 'accumulator), set('item), 'accumulator) => 'accumulator
</SyntaxTitle>
## Folded Operation [Fold over values in a set](../language-basics/sets-lists-tuples#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.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
@ -241,17 +270,6 @@ const sum_of_elements : int = Set.fold (sum, my_set, 0)
> Note that `set_fold` is *deprecated*. > 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
```
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
@ -269,4 +287,3 @@ let sum_of_elements : int = Set.fold (sum, my_set, 0);
``` ```
</Syntax> </Syntax>

111
gitlab-pages/docs/reference/string.md
View File

@ -1,45 +1,77 @@
--- ---
id: string-reference 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 Syntax from '@theme/Syntax';
import SyntaxTitle from '@theme/SyntaxTitle';
## String.size(s: string) : nat <SyntaxTitle syntax="pascaligo">
type string
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
type string
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
type string
</SyntaxTitle>
Get the size of a string. [Michelson only supports ASCII strings](http://tezos.gitlab.io/whitedoc/michelson.html#constants) A sequence of characters.
<SyntaxTitle syntax="pascaligo">
function length : string -> nat
</SyntaxTitle>
<SyntaxTitle syntax="cameligo">
val length : string -> nat
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let length: string => nat
</SyntaxTitle>
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. so for now you can assume that each character takes one byte of storage.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo ```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*.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
```cameligo ```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*.
</Syntax> </Syntax>
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
```reasonligo ```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*.
</Syntax> </Syntax>
<SyntaxTitle syntax="pascaligo">
## String.length(s: string) : nat function sub : nat -> nat -> string -> string
</SyntaxTitle>
Alias for `String.size`. <SyntaxTitle syntax="cameligo">
val sub : nat -> nat -> string -> string
## String.slice(pos1: nat, pos2: nat, s: string) : string </SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let sub: (nat, nat, string) => string
</SyntaxTitle>
Get the substring of `s` between `pos1` inclusive and `pos2` inclusive. For example Get the substring of `s` between `pos1` inclusive and `pos2` inclusive. For example
the string "tata" given to the function below would return "at". 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".
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo ```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*.
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
```cameligo ```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*.
</Syntax> </Syntax>
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
```reasonligo ```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*.
</Syntax> </Syntax>
## String.sub(pos1: nat, pos2: nat, s: string) : string <SyntaxTitle syntax="pascaligo">
function concat : string -> string -> string
Alias for `String.slice`. </SyntaxTitle>
<SyntaxTitle syntax="cameligo">
## String.concat(s1: string, s2: string) : string val concat : string -> string -> string
</SyntaxTitle>
<SyntaxTitle syntax="reasonligo">
let concat: (string, string) => string
</SyntaxTitle>
Concatenate two strings and return the result. Concatenate two strings and return the result.
@ -81,21 +123,40 @@ Concatenate two strings and return the result.
<Syntax syntax="pascaligo"> <Syntax syntax="pascaligo">
```pascaligo ```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"
``` ```
</Syntax> </Syntax>
<Syntax syntax="cameligo"> <Syntax syntax="cameligo">
```cameligo ```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"
```
</Syntax> </Syntax>
<Syntax syntax="reasonligo"> <Syntax syntax="reasonligo">
```reasonligo ```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";
``` ```
</Syntax> </Syntax>

13
gitlab-pages/website/sidebars.json
View File

@ -21,17 +21,20 @@
"advanced/first-contract", "advanced/first-contract",
"advanced/michelson-and-ligo" "advanced/michelson-and-ligo"
], ],
"API & Reference": [ "Reference": [
"api/cli-commands", "api/cli-commands",
"api/cheat-sheet", "api/cheat-sheet"
],
"API":[
"reference/big-map-reference", "reference/big-map-reference",
"reference/bitwise-reference",
"reference/bytes-reference", "reference/bytes-reference",
"reference/crypto-reference", "reference/crypto-reference",
"reference/current-reference",
"reference/list-reference", "reference/list-reference",
"reference/map-reference", "reference/map-reference",
"reference/set-reference", "reference/set-reference",
"reference/string-reference" "reference/string-reference",
"reference/current-reference"
] ]
}, },
"contributors-docs": { "contributors-docs": {

4
src/passes/operators/operators.ml
View File

@ -151,8 +151,8 @@ module Simplify = struct
(* String module *) (* String module *)
| "String.length" -> ok C_SIZE | "String.length" -> ok C_SIZE
| "String.size" -> ok C_SIZE | "String.size" -> ok C_SIZE (* Deprecated *)
| "String.slice" -> ok C_SLICE | "String.slice" -> ok C_SLICE (* Deprecated *)
| "String.sub" -> ok C_SLICE | "String.sub" -> ok C_SLICE
| "String.concat" -> ok C_CONCAT | "String.concat" -> ok C_CONCAT