diff --git a/documentation/leo/03_language.md b/documentation/leo/03_language.md index a9458a967..c9ed35f02 100644 --- a/documentation/leo/03_language.md +++ b/documentation/leo/03_language.md @@ -288,9 +288,9 @@ record token { ### Array -Leo supports static arrays. Arrays are declared as `[type; length]` and can be nested. Arrays cannot be empty nor modified. +Leo supports static arrays. Array types are declared as `[type; length]` and can be nested. Arrays cannot be empty nor modified. -Arrays only support constant accesses (the index must be a constant value). The accessor value must be a constant integer. +Arrays only support constant accesses. The accessor expression must be a constant integer. Arrays can contain primitive data types, structs, or arrays. Structs and records can also contain arrays. @@ -300,14 +300,14 @@ Arrays can be iterated over using a for loop. // Initalize a boolean array of length 4 let arr: [bool; 4] = [true, false, true, false]; -// Nested Array +// Nested array let nested: [[bool; 2]; 2] = [[true, false], [true, false]]; -// Array of Structs struct bar { data: u8, } +// Array of structs let arr_of_structs: [bar; 2] = [bar { data: 1u8 }, bar { data: 2u8 }]; // Access the field of a struct within an array @@ -326,7 +326,7 @@ record floo { data: [u8; 8], } -// Declare a mapping that contains an array value +// Declare a mapping that contains array values mapping data: address => [bool; 8]; // Iterate over an array using a for loop and sum the values within @@ -341,7 +341,7 @@ transition sum_with_loop(a: [u64; 4]) -> u64 { ### Tuple -Leo supports tuples. Tuples are declared as `(type1, type2, ...)` and can be nested. Tuples cannot be empty nor modified. +Leo supports tuples. Tuple types are declared as `(type1, type2, ...)` and can be nested. Tuples cannot be empty or modified. Tuples only support constant access with a dot `.` and a constant integer. @@ -378,7 +378,7 @@ program hello.aleo { #### Function Inputs -A function input is declared as `{visibility} {name}: {type},` +A function input is declared as `{visibility} {name}: {type}`. Function inputs must be declared just after the function name declaration, in parentheses. ```leo showLineNumbers @@ -401,11 +401,11 @@ transition foo(public a: field) -> field { ### Helper Function -A helper function is declared as `function {name}() {}`. +A helper function is declared as `function {name}({arguments}) {}`. Helper functions contain expressions and statements that can compute values, however helper functions cannot produce `records`. -Helper functions cannot be called directly from the outside. Instead, they must be called by other functions. +Helper functions cannot be called directly. Instead, they must be called by other functions. Inputs of helper functions cannot have `{visibility}` modifiers like transition functions, since they are used only internally, not as part of a program's external interface. @@ -439,11 +439,11 @@ inline foo( The rules for functions (in the traditional sense) are as follows: -- There are three variants of functions: transition, function, inline. -- transitions can only call functions and inlines. -- functions can only call inlines. -- inlines can only call inlines. -- Direct/indirect recursive calls are not allowed +- There are three variants of functions: `transition`, `function`, `inline`. +- A `transition` can only call a `function`, `inline`, or external `transition`. +- A `function` can only call an `inline`. +- An `inline` can only call another `inline`. +- Direct/indirect recursive calls are not allowed. ### Async Function @@ -463,9 +463,9 @@ program transfer.aleo { // from `account` into a token record for the specified receiver. // // This function preserves privacy for the receiver's record, however - // it publicly reveals the caller and the specified token amount. + // it publicly reveals the sender and the specified token amount. async transition transfer_public_to_private( - public receiver: address, + receiver: address, public amount: u64 ) -> (token, Future) { // Produce a token record for the token receiver. @@ -493,7 +493,7 @@ program transfer.aleo { If there is no need to create or alter the public on-chain state, async functions are not required. -### Mapping +### Mappings A mapping is declared as `mapping {name}: {key-type} => {value-type}`. Mappings contain key-value pairs. @@ -508,8 +508,39 @@ mapping account: address => u64; #### Mapping Operations -The mapping struct allows the programmer to apply updates to a program mapping data structure by calling one of the -following functions. +Mappings can be read from and modified by calling one of the following functions. + + + +#### get + +A get command, e.g. `current_value = Mapping::get(counter, addr);` +Gets the value stored at `addr` in `counter` and stores the result in `current_value` +If the value at `addr` does not exist, then the program will fail to execute. + +#### get_or_use + +A get command that uses the provided default if the key is not present in the mapping, +e.g. `let current_value: u64 = Mapping::get_or_use(counter, addr, 0u64);` +Gets the value stored at `addr` in `counter` and stores the result in `current_value`. +If the key is not present, `0u64` is stored in `counter` (associated to the key) and in `current_value`. + +#### set + +A set command, e.g. `Mapping::set(counter, addr, current_value + 1u64);` +Sets the `addr` entry as `current_value + 1u64` in `counter`. + +#### contains + +A contains command, e.g. `let contains: bool = Mapping::contains(counter, addr);` +Returns `true` if `addr` is present in `counter`, `false` otherwise. + +#### remove + +A remove command, e.g. `Mapping::remove(counter, addr);` +Removes the entry at `addr` in `counter`. + +#### Usage :::info Mapping operations are only allowed in an [async function](#async-function). @@ -532,42 +563,47 @@ program test.aleo { } ``` +## Control Structures -#### get - -A get command, e.g. `current_value = Mapping::get(counter, addr);` -Gets the value stored at `addr` in `counter` and stores the result in `current_value` -If the value at `addr` does not exist, then the program will fail to execute. - -#### get_or_use +### If Statements -A get command that uses the provided default in case of failure, -e.g. `let current_value: u64 = Mapping::get_or_use(counter, addr, 0u64);` -Gets the value stored at `addr` in `counter` and stores the result in `current_value`. -If the key is not present, `0u64` is stored in `counter` and stored in `current_value`. +If statements are declared as `if {condition} { ... } else if {condition} { ... } else { ... }`. +If statements can be nested. -#### set - -A set command, e.g. `Mapping::set(counter, addr, current_value + 1u64);` -Sets the `addr` entry as `current_value + 1u64` in `counter`. +```leo + let a: u8 = 1u8; + + if a == 1u8 { + a += 1u8; + } else if a == 2u8 { + a += 2u8; + } else { + a += 3u8; + } +``` -#### contains +### Return Statements -A contains command, e.g. `let contains: bool = Mapping::contains(counter, addr);` -Returns `true` if `addr` is present in `counter`, `false` otherwise. +Return statements are declared as `return {expression};`. -#### remove +```leo + let a: u8 = 1u8; + + if a == 1u8 { + return a + 1u8; + } else if a == 2u8 { + return a + 2u8; + } else { + return a + 3u8; + } +``` -A remove command, e.g. `Mapping::remove(counter, addr);` -Removes the entry at `addr` in `counter`. -## For Loops +### For Loops -For Loops are declared as `for {variable: type} in {lower bound}..{upper bound}`. Unsigned integer -types `u8`, `u16`, and `u32` are recommended for loop variable types. The lower bound must be +For loops are declared as `for {variable: type} in {lower bound}..{upper bound}`. The loop bounds must be integer types and constant. Furthermore, the lower bound must be less than the upper bound. Nested loops are supported. -### Example ```leo let count: u32 = 0u32; @@ -582,13 +618,11 @@ less than the upper bound. Nested loops are supported. ## Operators Operators in Leo compute a value based off of one or more expressions. -Leo will try to detect arithmetic operation errors as soon as possible. -If an integer overflow or division by zero can be identified at compile time, Leo will quickly tell the programmer. -Otherwise, the error will be caught at proving time when transition function inputs are processed. +Leo defaults to checked arithmetic, which means that it will throw an error if an overflow or division by zero is detected. For instance, addition adds `first` with `second`, storing the outcome in `destination`. For integer types, a constraint is added to check for overflow. -For cases where wrapping semantics are needed for integer types, see the `Add Wrapped` operator. +For cases where wrapping semantics are needed for integer types, see the wrapped variants of the operators. ```leo let a: u8 = 1u8 + 1u8; @@ -601,59 +635,7 @@ a = a.add(1u8); // a is now equal to 4 ``` -### Arithmetic Operators - -| Operation | Operands | Supported Types | -| :--------------------------------------------------------------------------: | :-----------------: | :----------------------------------------------------------------------------------: | -| addition | `+` `+=` `.add()` | `field` `group` `scalar` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| wrapping addition | `.add_wrapped()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| negation(unary) | `-` `.neg()` | `field` `group` `i8` `i16` `i32` `i64` `i128` | -| subtraction(binary) | `-` `-=` `.sub()` | `field` `group` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| wrapping subtraction(binary) | `.sub_wrapped()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| multiplication | `*` `*=` `.mul()` | `field` `group` `scalar` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| wrapping multiplication | `.mul_wrapped()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| division | `/` `/=` `.div()` | `field` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| wrapping division | `.div_wrapped()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| remainder | `%` `%=` `.rem()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| wrapping remainder | `.rem_wrapped()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| exponentiation | `**` `**=` `.pow()` | `field` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| wrapping exponentiation | `.pow_wrapped()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| [left shift](https://developer.aleo.org/leo/operators#shl) | `<<` `<<=` `.shl()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| [wrapping left shift](https://developer.aleo.org/leo/operators#shl_wrapped) | `.shl_wrapped()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| [right shift](https://developer.aleo.org/leo/operators#shr) | `>>` `>>=` `.shr()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| [wrapping right shift](https://developer.aleo.org/leo/operators#shr_wrapped) | `.shr_wrapped()` | `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| absolute value | `.abs()` | `i8` `i16` `i32` `i64` `i128` | -| wrapping absolute value | `.abs_wrapped()` | `i8` `i16` `i32` `i64` `i128` | -| doubling | `.double()` | `field` `group` | -| squaring | `.square()` | `field` | -| square root | `.square_root()` | `field` | -| inverse | `.square_root()` | `field` | - -### Logical Operators - -| Operation | Operands | Supported Types | -| :-------------: | :----------------------------------------------: | :----------------------------------------------------------------: | -| NOT | `!` `.not()` | `bool` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| AND | `&` `&=` `.and()` | `bool` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| OR | | |= `.or()` | `bool` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| XOR | `^` `^=` `.xor()` | `bool` `i8` `i16` `i32` `i64` `i128` `u8` `u16` `u32` `u64` `u128` | -| NAND | `.nand()` | `bool` | -| NOR | `.nor()` | `bool` | -| conditional AND | `&&` | `bool` | -| conditional OR | || | `bool` | - -### Relational Operators - -Relational operators will always resolve to a boolean `bool` value. - -| Operation | Operands | Supported Types | -| :-------------------: | :-----------: | :-------------------------------------------------------------: | -| equal | `==` `.eq()` | `bool`, `group`, `field`, integers, addresses, structs, records | -| not-equal | `!=` `.neq()` | `bool`, `group`, `field`, integers, addresses, structs, records | -| less than | `<` `.lt()` | `field`, `scalar`, integers | -| less than or equal | `<=` `.lte()` | `field`, `scalar`, integers | -| greater than | `>` `.gt()` | `field`, `scalar`, integers | -| greater than or equal | `>=` `.gte()` | `field`, `scalar`, integers | +See the [Operator Reference](./04_operators.md) for a complete list of operators. ### Operator Precedence @@ -685,17 +667,13 @@ let result = (a + 1u8) * 2u8; `(a + 1u8)` will be evaluated before multiplying by two `* 2u8`. -## Commands +## Context-dependent Expressions -Leo supports several commands that can be used to reference information about the Aleo blockchain and the current transaction. +Leo supports several expressions that can be used to reference information about the Aleo blockchain and the current transaction. ### self.caller -:::note -`self.caller` is currently implemented as `self.signer` within Aleo instructions. This will be fixed in a upcoming release. -::: - -Returns the address of the account that is calling the program function. +Returns the address of the account/program that invoked the current `transition`. ```leo showLineNumbers program test.aleo { @@ -705,6 +683,18 @@ program test.aleo { } ``` +### self.signer + +Returns the address of the account that invoked that top-level `transition`. This is the account that signed the transaction. + +```leo showLineNumbers +program test.aleo { + transition matches(addr: address) -> bool { + return self.signer == addr; + } +} +``` + ### block.height Returns the height of the current block. @@ -728,7 +718,7 @@ program test.aleo { ## Core Functions Core functions are functions that are built into the Leo language. -They are used to perform cryptographic operations such as hashing, commitment, and random number generation. +They are used to check assertions and perform cryptographic operations such as hashing, commitment, and random number generation. ### Assert and AssertEq @@ -747,7 +737,7 @@ program test.aleo { ### Hash Leo supports the following hashing algorithms: `BHP256`, `BHP512`, `BHP768`, `BHP1024`, `Pedersen64`, `Pedersen128`, `Poseidon2`, `Poseidon4`, `Poseidon8`, `Keccak256`, `Keccak384`, `Keccak512`, `SHA3_256`, `SHA3_384`, `SHA3_512`. -The output type of a commitment function is specified in the function name. e.g. `hash_to_group` will return a `group` type. +The output type of a hash function is specified in the function name. e.g. `hash_to_group` will return a `group` type. Hash functions take any type as an argument. ```leo showLineNumbers diff --git a/documentation/leo/04_operators.md b/documentation/leo/04_operators.md index 290e343ce..8aba2936f 100644 --- a/documentation/leo/04_operators.md +++ b/documentation/leo/04_operators.md @@ -10,47 +10,47 @@ The Leo operators compile down to [Aleo instructions opcodes](../aleo/04_opcodes ## Table of Standard Operators | Name | Description | |-----------------------------|:------------------------------------| -| [abs](#abs) | Absolute value operation | -| [abs_wrapped](#abs_wrapped) | Wrapping absolute value operation | -| [add](#add) | Addition operation | -| [add_wrapped](#add_wrapped) | Wrapping addition operation | -| [and](#and) | AND operation | +| [abs](#abs) | Absolute value | +| [abs_wrapped](#abs_wrapped) | Wrapping absolute value | +| [add](#add) | Addition | +| [add_wrapped](#add_wrapped) | Wrapping addition | +| [and](#and) | Conjunction | | [assert](#assert) | Assert boolean true | | [assert_eq](#assert_eq) | Assert equality | | [assert_neq](#assert_neq) | Assert non-equality | -| [div](#div) | Division operation | +| [div](#div) | Division | | [div_wrapped](#div_wrapped) | Wrapping division operation | -| [double](#double) | Double operation | -| [group::GEN](#groupgen) | Group generator | +| [double](#double) | Double | +| [group::GEN](#groupgen) | group generator | | [gt](#gt) | Greater than comparison | | [gte](#gte) | Greater than or equal to comparison | -| [inv](#inv) | Multiplicative inverse operation | +| [inv](#inv) | Multiplicative inverse | | [eq](#eq) | Equality comparison | -| [neq](#neq) | Not equal comparison | +| [neq](#neq) | Non-equality comparison | | [lt](#lt) | Less than comparison | | [lte](#lte) | Less than or equal to comparison | -| [mod](#mod) | Arithmetic modulo operation | -| [mul](#mul) | Multiplication operation | -| [mul_wrapped](#mul_wrapped) | Wrapping multiplication operation | -| [nand](#nand) | `Boolean` NAND operation | -| [neg](#neg) | Additive inverse operation | -| [nor](#nor) | `Boolean` NOR operation | -| [not](#not) | NOT operation | -| [or](#or) | OR Operation | -| [pow](#pow) | Exponentiation operation | -| [pow_wrapped](#pow_wrapped) | Wrapping exponentiation operation | -| [rem](#rem) | Remainder operation | -| [rem_wrapped](#rem_wrapped) | Wrapping remainder operation | -| [shl](#shl) | Shift left operation | -| [shl_wrapped](#shl_wrapped) | Wrapping shift left operation | -| [shr](#shr) | Shift right operation | -| [shr_wrapped](#shr_wrapped) | Wrapping shift right operation | -| [square_root](#square_root) | Square root operation | -| [square](#square) | Square operation | -| [sub](#sub) | Subtraction operation | -| [sub_wrapped](#sub_wrapped) | Wrapping subtraction operation | -| [ternary](#ternary) | Ternary select operation | -| [xor](#xor) | XOR operation | +| [mod](#mod) | Modulo | +| [mul](#mul) | Multiplication | +| [mul_wrapped](#mul_wrapped) | Wrapping multiplication | +| [nand](#nand) | Negated conjunction | +| [neg](#neg) | Additive inverse | +| [nor](#nor) | Negated disjunction | +| [not](#not) | Logical negation | +| [or](#or) | (Inclusive) disjunction | +| [pow](#pow) | Exponentiation | +| [pow_wrapped](#pow_wrapped) | Wrapping exponentiation | +| [rem](#rem) | Remainder | +| [rem_wrapped](#rem_wrapped) | Wrapping remainder | +| [shl](#shl) | Shift left | +| [shl_wrapped](#shl_wrapped) | Wrapping shift left | +| [shr](#shr) | Shift right | +| [shr_wrapped](#shr_wrapped) | Wrapping shift right | +| [square_root](#square_root) | Square root | +| [square](#square) | Square | +| [sub](#sub) | Subtraction | +| [sub_wrapped](#sub_wrapped) | Wrapping subtraction | +| [ternary](#ternary) | Ternary select | +| [xor](#xor) | Exclusive conjunction | ## Table of Cryptographic Operators | Name | Description | @@ -94,17 +94,17 @@ let b: i8 = a.abs(); // 1i8 Computes the absolute value of the input, checking for overflow, storing the result in the destination. -For integer types, a constraint is added to check for underflow. For cases where wrapping semantics are needed, see the [abs_wrapped](#abs_wrapped) instruction. This underflow happens when the input is the minimum value of a signed integer type. For example, `abs -128i8` would result in underflow, since `128` cannot be represented as an `i8`. +Note that execution will halt if the operation overflows/underflows. For cases where wrapping semantics are needed, see the [abs_wrapped](#abs_wrapped) instruction. This underflow happens when the input is the minimum value of a signed integer type. For example, `abs -128i8` would result in underflow, since `128` cannot be represented as an `i8`. #### Supported Types | Input | Destination | |--------|:------------| -| `I8` | `I8` | -| `I16` | `I16` | -| `I32` | `I32` | -| `I64` | `I64` | -| `I128` | `I128` | +| `i8` | `i8` | +| `i16` | `i16` | +| `i32` | `i32` | +| `i64` | `i64` | +| `i128` | `i128` | [Back to Top](#table-of-standard-operators) *** @@ -124,11 +124,11 @@ Compute the absolute value of the input, wrapping around at the boundary of the | Input | Destination | |--------|:------------| -| `I8` | `I8` | -| `I16` | `I16` | -| `I32` | `I32` | -| `I64` | `I64` | -| `I128` | `I128` | +| `i8` | `i8` | +| `i16` | `i16` | +| `i32` | `i32` | +| `i64` | `i64` | +| `i128` | `i128` | [Back to Top](#table-of-standard-operators) *** @@ -143,27 +143,27 @@ let c: u8 = b.add(1u8); // 3u8 #### Description -Adds `first` with `second`, storing the outcome in `destination`. +Adds `first` with `second`, storing the result in `destination`. -For integer types, a constraint is added to check for overflow. For cases where wrapping semantics are needed for integer types, see the [add_wrapped](#add_wrapped) instruction. +Note that execution will halt if the operation overflows. For cases where wrapping semantics are needed for integer types, see the [add_wrapped](#add_wrapped) instruction. #### Supported Types | First | Second | Destination | |----------|----------|-------------| -| `Field` | `Field` | `Field` | -| `Group` | `Group` | `Group` | -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | -| `Scalar` | `Scalar` | `Scalar` | +| `field` | `field` | `field` | +| `group` | `group` | `group` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | +| `scalar` | `scalar` | `scalar` | [Back to Top](#table-of-standard-operators) *** @@ -177,22 +177,22 @@ let b: u8 = a.add_wrapped(1u8); // 0u8 #### Description -Adds `first` with `second`, wrapping around at the boundary of the type, and storing the outcome in `destination`. +Adds `first` with `second`, wrapping around at the boundary of the type, and storing the result in `destination`. #### Supported Types | First | Second | Destination | |--------|--------|:------------| -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -208,23 +208,23 @@ let b: i8 = 1i8.and(2i8); // 0i8 #### Description Performs an AND operation on integer (bitwise) or boolean `first` and `second`, -storing the outcome in `destination`. +storing the result in `destination`. #### Supported Types -| First | Second | Destination | -|-----------|-----------|:------------| -| `Boolean` | `Boolean` | `Boolean` | -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| First | Second | Destination | +|-----------|----------|:------------| +| `bool` | `bool` | `bool` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -247,7 +247,7 @@ Checks whether the expression evaluates to a `true` boolean value, halting if ev | Expression | |------------| -| `Boolean` | +| `bool` | [Back to Top](#table-of-standard-operators) *** @@ -270,23 +270,23 @@ Checks whether `first` and `second` are equal, halting if they are not equal. | First | Second | |-------------|-------------| -| `Address` | `Address` | -| `Boolean` | `Boolean` | -| `Field` | `Field` | -| `Group` | `Group` | -| `I8` | `I8` | -| `I16` | `I16` | -| `I32` | `I32` | -| `I64` | `I64` | -| `I128` | `I128` | -| `U8` | `U8` | -| `U16` | `U16` | -| `U32` | `U32` | -| `U64` | `U64` | -| `U128` | `U128` | -| `Scalar` | `Scalar` | +| `address` | `address` | +| `bool` | `bool` | +| `field` | `field` | +| `group` | `group` | +| `i8` | `i8` | +| `i16` | `i16` | +| `i32` | `i32` | +| `i64` | `i64` | +| `i128` | `i128` | +| `u8` | `u8` | +| `u16` | `u16` | +| `u32` | `u32` | +| `u64` | `u64` | +| `u128` | `u128` | +| `scalar` | `scalar` | | `Signature` | `Signature` | -| `Struct` | `Struct` | +| `struct` | `struct` | | `Record` | `Record` | [Back to Top](#table-of-standard-operators) @@ -310,23 +310,23 @@ Checks whether `first` and `second` are not equal, halting if they are equal. | First | Second | |-------------|-------------| -| `Address` | `Address` | -| `Boolean` | `Boolean` | -| `Field` | `Field` | -| `Group` | `Group` | -| `I8` | `I8` | -| `I16` | `I16` | -| `I32` | `I32` | -| `I64` | `I64` | -| `I128` | `I128` | -| `U8` | `U8` | -| `U16` | `U16` | -| `U32` | `U32` | -| `U64` | `U64` | -| `U128` | `U128` | -| `Scalar` | `Scalar` | +| `address` | `address` | +| `bool` | `bool` | +| `field` | `field` | +| `group` | `group` | +| `i8` | `i8` | +| `i16` | `i16` | +| `i32` | `i32` | +| `i64` | `i64` | +| `i128` | `i128` | +| `u8` | `u8` | +| `u16` | `u16` | +| `u32` | `u32` | +| `u64` | `u64` | +| `u128` | `u128` | +| `scalar` | `scalar` | | `Signature` | `Signature` | -| `Struct` | `Struct` | +| `struct` | `struct` | | `Record` | `Record` | [Back to Top](#table-of-standard-operators) @@ -368,12 +368,12 @@ let c: u8 = b.div(2u8); // 1u8 Performs division of the first operand by the second, storing the result in the destination. The operation halts if division by zero is attempted. -For integer types, this operation performs truncated division. Truncated division rounds towards zero, regardless of the sign of the operands. This means it cuts off any digits after the decimal, leaving the largest whole number less than or equal to the result. +For integer types, this operation performs truncated division. Truncated division rounds towards zero, regardless of the sign of the operands. This means it cuts off any digits after the decimal, leaving the whole number whose absolute value is less than or equal to the result. For example: -1. `7 / 3` yields `2`, not `2.3333`. -2. `-7 / 3` yields `-2`, not `-2.3333`. +- `7 / 3` yields `2`, not `2.3333`. +- `-7 / 3` yields `-2`, not `-2.3333`. The operation halts if there is an underflow. Underflow occurs when dividing the minimum value of a signed integer type by -1. For example, `-128i8 / -1i8` would result in underflow, since 128 cannot be represented as an `i8`. @@ -385,17 +385,17 @@ For cases where wrapping semantics are needed for integer types, see the [div_wr | First | Second | Destination | |---------|---------|:------------| -| `Field` | `Field` | `Field` | -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `field` | `field` | `field` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -409,22 +409,22 @@ let b: i8 = a.div_wrapped(-1i8); // -128i8 #### Description -Divides `first` by `second`, wrapping around at the boundary of the type, and storing the outcome in `destination`. +Divides `first` by `second`, wrapping around at the boundary of the type, and storing the result in `destination`. #### Supported Types | First | Second | Destination | |--------|--------|:------------| -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -438,15 +438,15 @@ let b: group = a.double(); #### Description -Doubles the input, storing the outcome in `destination`. +Doubles the input, storing the result in `destination`. #### Supported Types | Input | Destination | |---------|-------------| -| `Field` | `Field` | -| `Group` | `Group` | +| `field` | `field` | +| `group` | `group` | [Back to Top](#table-of-standard-operators) *** @@ -466,18 +466,18 @@ Checks if `first` is greater than `second`, storing the result in `destination`. | First | Second | Destination | |----------|----------|-------------| -| `Field` | `Field` | `Boolean` | -| `I8` | `I8` | `Boolean` | -| `I16` | `I16` | `Boolean` | -| `I32` | `I32` | `Boolean` | -| `I64` | `I64` | `Boolean` | -| `I128` | `I128` | `Boolean` | -| `U8` | `U8` | `Boolean` | -| `U16` | `U16` | `Boolean` | -| `U32` | `U32` | `Boolean` | -| `U64` | `U64` | `Boolean` | -| `U128` | `U128` | `Boolean` | -| `Scalar` | `Scalar` | `Boolean` | +| `field` | `field` | `bool` | +| `i8` | `i8` | `bool` | +| `i16` | `i16` | `bool` | +| `i32` | `i32` | `bool` | +| `i64` | `i64` | `bool` | +| `i128` | `i128` | `bool` | +| `u8` | `u8` | `bool` | +| `u16` | `u16` | `bool` | +| `u32` | `u32` | `bool` | +| `u64` | `u64` | `bool` | +| `u128` | `u128` | `bool` | +| `scalar` | `scalar` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -497,18 +497,18 @@ Checks if `first` is greater than or equal to `second`, storing the result in `d | First | Second | Destination | |----------|----------|-------------| -| `Field` | `Field` | `Boolean` | -| `I8` | `I8` | `Boolean` | -| `I16` | `I16` | `Boolean` | -| `I32` | `I32` | `Boolean` | -| `I64` | `I64` | `Boolean` | -| `I128` | `I128` | `Boolean` | -| `U8` | `U8` | `Boolean` | -| `U16` | `U16` | `Boolean` | -| `U32` | `U32` | `Boolean` | -| `U64` | `U64` | `Boolean` | -| `U128` | `U128` | `Boolean` | -| `Scalar` | `Scalar` | `Boolean` | +| `field` | `field` | `bool` | +| `i8` | `i8` | `bool` | +| `i16` | `i16` | `bool` | +| `i32` | `i32` | `bool` | +| `i64` | `i64` | `bool` | +| `i128` | `i128` | `bool` | +| `u8` | `u8` | `bool` | +| `u16` | `u16` | `bool` | +| `u32` | `u32` | `bool` | +| `u64` | `u64` | `bool` | +| `u128` | `u128` | `bool` | +| `scalar` | `scalar` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -521,13 +521,13 @@ let a: field = 1field.inv(); #### Description -Computes the multiplicative inverse of the input, storing the outcome in `destination`. +Computes the multiplicative inverse of the input, storing the result in `destination`. #### Supported Types | Input | Destination | |---------|-------------| -| `Field` | `Field` | +| `field` | `field` | [Back to Top](#table-of-standard-operators) *** @@ -541,30 +541,30 @@ let b: bool = 1u8.eq(2u8); // false #### Description -Compares `first` and `second`, storing the result in `destination`. +Compares `first` and `second` for equality, storing the result in `destination`. #### Supported Types | First | Second | Destination | |-------------|-------------|-------------| -| `Address` | `Address` | `Boolean` | -| `Boolean` | `Boolean` | `Boolean` | -| `Field` | `Field` | `Boolean` | -| `Group` | `Group` | `Boolean` | -| `I8` | `I8` | `Boolean` | -| `I16` | `I16` | `Boolean` | -| `I32` | `I32` | `Boolean` | -| `I64` | `I64` | `Boolean` | -| `I128` | `I128` | `Boolean` | -| `U8` | `U8` | `Boolean` | -| `U16` | `U16` | `Boolean` | -| `U32` | `U32` | `Boolean` | -| `U64` | `U64` | `Boolean` | -| `U128` | `U128` | `Boolean` | -| `Scalar` | `Scalar` | `Boolean` | -| `Signature` | `Signature` | `Boolean` | -| `Struct` | `Struct` | `Boolean` | -| `Record` | `Record` | `Boolean` | +| `address` | `address` | `bool` | +| `bool` | `bool` | `bool` | +| `field` | `field` | `bool` | +| `group` | `group` | `bool` | +| `i8` | `i8` | `bool` | +| `i16` | `i16` | `bool` | +| `i32` | `i32` | `bool` | +| `i64` | `i64` | `bool` | +| `i128` | `i128` | `bool` | +| `u8` | `u8` | `bool` | +| `u16` | `u16` | `bool` | +| `u32` | `u32` | `bool` | +| `u64` | `u64` | `bool` | +| `u128` | `u128` | `bool` | +| `scalar` | `scalar` | `bool` | +| `Signature` | `Signature` | `bool` | +| `struct` | `struct` | `bool` | +| `Record` | `Record` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -578,30 +578,30 @@ let b: bool = 1u8.neq(2u8); // true #### Description -Returns true if `first` is not equal to `second`, storing the result in `destination`. +Compares `first` and `second` for non-equality, storing the result in `destination`. #### Supported Types | First | Second | Destination | |-------------|-------------|-------------| -| `Address` | `Address` | `Boolean` | -| `Boolean` | `Boolean` | `Boolean` | -| `Field` | `Field` | `Boolean` | -| `Group` | `Group` | `Boolean` | -| `I8` | `I8` | `Boolean` | -| `I16` | `I16` | `Boolean` | -| `I32` | `I32` | `Boolean` | -| `I64` | `I64` | `Boolean` | -| `I128` | `I128` | `Boolean` | -| `U8` | `U8` | `Boolean` | -| `U16` | `U16` | `Boolean` | -| `U32` | `U32` | `Boolean` | -| `U64` | `U64` | `Boolean` | -| `U128` | `U128` | `Boolean` | -| `Scalar` | `Scalar` | `Boolean` | -| `Signature` | `Signature` | `Boolean` | -| `Struct` | `Struct` | `Boolean` | -| `Record` | `Record` | `Boolean` | +| `address` | `address` | `bool` | +| `bool` | `bool` | `bool` | +| `field` | `field` | `bool` | +| `group` | `group` | `bool` | +| `i8` | `i8` | `bool` | +| `i16` | `i16` | `bool` | +| `i32` | `i32` | `bool` | +| `i64` | `i64` | `bool` | +| `i128` | `i128` | `bool` | +| `u8` | `u8` | `bool` | +| `u16` | `u16` | `bool` | +| `u32` | `u32` | `bool` | +| `u64` | `u64` | `bool` | +| `u128` | `u128` | `bool` | +| `scalar` | `scalar` | `bool` | +| `Signature` | `Signature` | `bool` | +| `struct` | `struct` | `bool` | +| `Record` | `Record` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -615,24 +615,24 @@ let b: bool = 1u8.lt(1u8); // false #### Description -Checks if `first` is less than `second`, storing the outcome in `destination`. +Checks if `first` is less than `second`, storing the result in `destination`. #### Supported Types | First | Second | Destination | |----------|----------|-------------| -| `Field` | `Field` | `Boolean` | -| `I8` | `I8` | `Boolean` | -| `I16` | `I16` | `Boolean` | -| `I32` | `I32` | `Boolean` | -| `I64` | `I64` | `Boolean` | -| `I128` | `I128` | `Boolean` | -| `U8` | `U8` | `Boolean` | -| `U16` | `U16` | `Boolean` | -| `U32` | `U32` | `Boolean` | -| `U64` | `U64` | `Boolean` | -| `U128` | `U128` | `Boolean` | -| `Scalar` | `Scalar` | `Boolean` | +| `field` | `field` | `bool` | +| `i8` | `i8` | `bool` | +| `i16` | `i16` | `bool` | +| `i32` | `i32` | `bool` | +| `i64` | `i64` | `bool` | +| `i128` | `i128` | `bool` | +| `u8` | `u8` | `bool` | +| `u16` | `u16` | `bool` | +| `u32` | `u32` | `bool` | +| `u64` | `u64` | `bool` | +| `u128` | `u128` | `bool` | +| `scalar` | `scalar` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -646,24 +646,24 @@ let b: bool = 1u8.lte(1u8); // true #### Description -Checks if `first` is less than or equal to `second`, storing the outcome in `destination`. +Checks if `first` is less than or equal to `second`, storing the result in `destination`. #### Supported Types | First | Second | Destination | |----------|----------|-------------| -| `Field` | `Field` | `Boolean` | -| `I8` | `I8` | `Boolean` | -| `I16` | `I16` | `Boolean` | -| `I32` | `I32` | `Boolean` | -| `I64` | `I64` | `Boolean` | -| `I128` | `I128` | `Boolean` | -| `U8` | `U8` | `Boolean` | -| `U16` | `U16` | `Boolean` | -| `U32` | `U32` | `Boolean` | -| `U64` | `U64` | `Boolean` | -| `U128` | `U128` | `Boolean` | -| `Scalar` | `Scalar` | `Boolean` | +| `field` | `field` | `bool` | +| `i8` | `i8` | `bool` | +| `i16` | `i16` | `bool` | +| `i32` | `i32` | `bool` | +| `i64` | `i64` | `bool` | +| `i128` | `i128` | `bool` | +| `u8` | `u8` | `bool` | +| `u16` | `u16` | `bool` | +| `u32` | `u32` | `bool` | +| `u64` | `u64` | `bool` | +| `u128` | `u128` | `bool` | +| `scalar` | `scalar` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -676,7 +676,7 @@ let a: u8 = 3u8.mod(2u8); // 1u8 #### Description -Takes the modulus of `first` with respect to `second`, storing the outcome in `destination`. Halts if `second` is zero. +Takes the modulo of `first` with respect to `second`, storing the result in `destination`. Halts if `second` is zero. The semantics of this operation are consistent with the mathematical definition of modulo operation. @@ -684,11 +684,11 @@ The semantics of this operation are consistent with the mathematical definition | First | Second | Destination | |--------|--------|-------------| -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -702,27 +702,27 @@ let b: u8 = a.mul(2u8); // 8u8 #### Description -Multiplies `first` with `second`, storing the outcome in `destination`. +Multiplies `first` with `second`, storing the result in `destination`. -For integer types, a constraint is added to check for overflow/underflow. For cases where wrapping semantics are needed for integer types, see the [mul_wrapped](#mul_wrapped) instruction. +Note that execution will halt if the operation overflows/underflows. For cases where wrapping semantics are needed for integer types, see the [mul_wrapped](#mul_wrapped) instruction. #### Supported Types | First | Second | Destination | |----------|----------|-------------| -| `Field` | `Field` | `Field` | -| `Group` | `Scalar` | `Group` | -| `Scalar` | `Group` | `Group` | -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `field` | `field` | `field` | +| `group` | `scalar` | `group` | +| `scalar` | `group` | `group` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -735,22 +735,22 @@ let a: u8 = 128u8.mul_wrapped(2u8); // 0u8 #### Description -Multiplies `first` with `second`, wrapping around at the boundary of the type, and storing the outcome in `destination`. +Multiplies `first` with `second`, wrapping around at the boundary of the type, and storing the result in `destination`. #### Supported Types | First | Second | Destination | |--------|--------|-------------| -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -763,13 +763,14 @@ let a: bool = true.nand(false); // true #### Description -Returns false only if `first` and `second` are true, storing the outcome in `destination`. +Calculates the negated conjunction of `first` and `second`, storing the result in `destination`. +The result is false if and only if both first and second are true. #### Supported Types | First | Second | Destination | |-----------|-----------|-------------| -| `Boolean` | `Boolean` | `Boolean` | +| `bool` | `bool` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -782,7 +783,7 @@ let a: i8 = -1i8.neg(); // 1i8 #### Description -Negates `first`, storing the outcome in `destination`. +Negates `first`, storing the result in `destination`. For signed integer types, calling `neg` on the minimum value is an invalid operation. For example, the input `-128i8` would not be valid since `128` cannot be represented as an `i8`. @@ -790,13 +791,13 @@ For signed integer types, calling `neg` on the minimum value is an invalid opera | Input | Destination | |---------|-------------| -| `Field` | `Field` | -| `Group` | `Group` | -| `I8` | `I8` | -| `I16` | `I16` | -| `I32` | `I32` | -| `I64` | `I64` | -| `I128` | `I128` | +| `field` | `field` | +| `group` | `group` | +| `i8` | `i8` | +| `i16` | `i16` | +| `i32` | `i32` | +| `i64` | `i64` | +| `i128` | `i128` | [Back to Top](#table-of-standard-operators) *** @@ -809,13 +810,13 @@ let a: bool = false.nor(false); // true #### Description -Returns true when neither `first` nor `second` is true, storing the outcome in `destination`. +Returns true when neither `first` nor `second` is true, storing the result in `destination`. #### Supported Type | First | Second | Destination | |-----------|-----------|-------------| -| `Boolean` | `Boolean` | `Boolean` | +| `bool` | `bool` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -828,23 +829,23 @@ let a: bool = true.not(); // false #### Description -Perform a NOT operation on an integer (bitwise) or boolean input, storing the outcome in `destination`. +Perform a NOT operation on an integer (bitwise) or boolean input, storing the result in `destination`. #### Supported Types | Input | Destination | |-----------|-------------| -| `Boolean` | `Boolean` | -| `I8` | `I8` | -| `I16` | `I16` | -| `I32` | `I32` | -| `I64` | `I64` | -| `I128` | `I128` | -| `U8` | `U8` | -| `U16` | `U16` | -| `U32` | `U32` | -| `U64` | `U64` | -| `U128` | `U128` | +| `bool` | `bool` | +| `i8` | `i8` | +| `i16` | `i16` | +| `i32` | `i32` | +| `i64` | `i64` | +| `i128` | `i128` | +| `u8` | `u8` | +| `u16` | `u16` | +| `u32` | `u32` | +| `u64` | `u64` | +| `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -858,23 +859,23 @@ let b: bool = false.or(false); // false #### Description -Performs an OR operation on integer (bitwise) or boolean `first` and `second`, storing the outcome in `destination`. +Performs an OR operation on integer (bitwise) or boolean `first` and `second`, storing the result in `destination`. #### Supported Types | First | Second | Destination | |-----------|-----------|-------------| -| `Boolean` | `Boolean` | `Boolean` | -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `bool` | `bool` | `bool` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -888,27 +889,27 @@ let b: u8 = a.pow(2u8); // 16u8 #### Description -Raises `first` to the power of `second`, storing the outcome in `destination`. +Raises `first` to the power of `second`, storing the result in `destination`. -For integer types, a constraint is added to check for overflow/underflow. For cases where wrapping semantics are needed for integer types, see the [pow_wrapped](#pow_wrapped) instruction. +Note that execution will halt if the operation overflows/underflows. For cases where wrapping semantics are needed for integer types, see the [pow_wrapped](#pow_wrapped) instruction. #### Supported Types -`Magnitude` can be a `U8`, `U16`, or `U32`. +`Magnitude` can be a `u8`, `u16`, or `u32`. | First | Second | Destination | |---------|-------------|-------------| -| `Field` | `Field` | `Field` | -| `I8` | `Magnitude` | `I8` | -| `I16` | `Magnitude` | `I16` | -| `I32` | `Magnitude` | `I32` | -| `I64` | `Magnitude` | `I64` | -| `I128` | `Magnitude` | `I128` | -| `U8` | `Magnitude` | `U8` | -| `U16` | `Magnitude` | `U16` | -| `U32` | `Magnitude` | `U32` | -| `U64` | `Magnitude` | `U64` | -| `U128` | `Magnitude` | `U128` | +| `field` | `field` | `field` | +| `i8` | `Magnitude` | `i8` | +| `i16` | `Magnitude` | `i16` | +| `i32` | `Magnitude` | `i32` | +| `i64` | `Magnitude` | `i64` | +| `i128` | `Magnitude` | `i128` | +| `u8` | `Magnitude` | `u8` | +| `u16` | `Magnitude` | `u16` | +| `u32` | `Magnitude` | `u32` | +| `u64` | `Magnitude` | `u64` | +| `u128` | `Magnitude` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -921,24 +922,24 @@ let a: u8 = 16u8.pow_wrapped(2u8); // 0u8 #### Description -Raises `first` to the power of `second`, wrapping around at the boundary of the type, storing the outcome in `destination`. +Raises `first` to the power of `second`, wrapping around at the boundary of the type, storing the result in `destination`. #### Supported Types -`Magnitude` can be a `U8`, `U16`, or `U32`. +`Magnitude` can be a `u8`, `u16`, or `u32`. | First | Second | Destination | |--------|-------------|-------------| -| `I8` | `Magnitude` | `I8` | -| `I16` | `Magnitude` | `I16` | -| `I32` | `Magnitude` | `I32` | -| `I64` | `Magnitude` | `I64` | -| `I128` | `Magnitude` | `I128` | -| `U8` | `Magnitude` | `U8` | -| `U16` | `Magnitude` | `U16` | -| `U32` | `Magnitude` | `U32` | -| `U64` | `Magnitude` | `U64` | -| `U128` | `Magnitude` | `U128` | +| `i8` | `Magnitude` | `i8` | +| `i16` | `Magnitude` | `i16` | +| `i32` | `Magnitude` | `i32` | +| `i64` | `Magnitude` | `i64` | +| `i128` | `Magnitude` | `i128` | +| `u8` | `Magnitude` | `u8` | +| `u16` | `Magnitude` | `u16` | +| `u32` | `Magnitude` | `u32` | +| `u64` | `Magnitude` | `u64` | +| `u128` | `Magnitude` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -953,10 +954,10 @@ let b: u8 = 4u8.rem(2u8); // 0u8 #### Description -Computes the truncated remainder of `first` divided by `second`, storing the outcome in `destination`. Halts on division by zero. +Computes the truncated remainder of `first` divided by `second`, storing the result in `destination`. Halts on division by zero. -A constraint is added to check for underflow. This underflow happens when the associated division operation, [div](#div), underflows. +Note that execution will halt if the operation underflows. This underflow happens when the associated division operation, [div](#div), underflows. For cases where wrapping semantics are needed for integer types, see the [rem_wrapped](#rem_wrapped) instruction. @@ -964,16 +965,16 @@ For cases where wrapping semantics are needed for integer types, see the [rem_wr | First | Second | Destination | |--------|--------|-------------| -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -986,22 +987,22 @@ let b: i8 = a.rem_wrapped(-1i8); // 0i8 ``` #### Description -Computes the truncated remainder of `first` divided by `second`, wrapping around at the boundary of the type, and storing the outcome in destination. +Computes the truncated remainder of `first` divided by `second`, wrapping around at the boundary of the type, and storing the result in destination. #### Supported Types | First | Second | Destination | |--------|--------|-------------| -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1018,13 +1019,15 @@ transition verify_field(s: signature, a: address, v: field) { #### Description -Verifies that the signature `first` was signed by the address `second` with respect to the field `third`, storing the outcome in `destination`. +Verifies that the signature `first` was signed by the address `second` with respect to the field `third`, storing the result in `destination`. #### Supported Types +A `Message` is any literal or `struct` type. + | First | Second | Third | Destination | |-------------|-----------|-----------|-------------| -| `Signature` | `Address` | `Message` | `Boolean` | +| `signature` | `address` | `Message` | `bool` | [Back to Top](#table-of-standard-operators) *** @@ -1038,24 +1041,24 @@ let b: u8 = a.shl(1u8); // 4u8 #### Description -Shifts `first` left by `second` bits, storing the outcome in `destination`. +Shifts `first` left by `second` bits, storing the result in `destination`. #### Supported Types -`Magnitude` can be a `U8`, `U16`, or `U32`. +`Magnitude` can be a `u8`, `u16`, or `u32`. | First | Second | Destination | |--------|-------------|-------------| -| `I8` | `Magnitude` | `I8` | -| `I16` | `Magnitude` | `I16` | -| `I32` | `Magnitude` | `I32` | -| `I64` | `Magnitude` | `I64` | -| `I128` | `Magnitude` | `I128` | -| `U8` | `Magnitude` | `U8` | -| `U16` | `Magnitude` | `U16` | -| `U32` | `Magnitude` | `U32` | -| `U64` | `Magnitude` | `U64` | -| `U128` | `Magnitude` | `U128` | +| `i8` | `Magnitude` | `i8` | +| `i16` | `Magnitude` | `i16` | +| `i32` | `Magnitude` | `i32` | +| `i64` | `Magnitude` | `i64` | +| `i128` | `Magnitude` | `i128` | +| `u8` | `Magnitude` | `u8` | +| `u16` | `Magnitude` | `u16` | +| `u32` | `Magnitude` | `u32` | +| `u64` | `Magnitude` | `u64` | +| `u128` | `Magnitude` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1068,24 +1071,24 @@ let a: u8 = 128u8.shl_wrapped(1u8); // 0u8 #### Description -Shifts `first` left by `second` bits, wrapping around at the boundary of the type, storing the outcome in `destination`. +Shifts `first` left by `second` bits, wrapping around at the boundary of the type, storing the result in `destination`. #### Supported Types -`Magnitude` can be a `U8`, `U16`, or `U32`. +`Magnitude` can be a `u8`, `u16`, or `u32`. | First | Second | Destination | |--------|-------------|-------------| -| `I8` | `Magnitude` | `I8` | -| `I16` | `Magnitude` | `I16` | -| `I32` | `Magnitude` | `I32` | -| `I64` | `Magnitude` | `I64` | -| `I128` | `Magnitude` | `I128` | -| `U8` | `Magnitude` | `U8` | -| `U16` | `Magnitude` | `U16` | -| `U32` | `Magnitude` | `U32` | -| `U64` | `Magnitude` | `U64` | -| `U128` | `Magnitude` | `U128` | +| `i8` | `Magnitude` | `i8` | +| `i16` | `Magnitude` | `i16` | +| `i32` | `Magnitude` | `i32` | +| `i64` | `Magnitude` | `i64` | +| `i128` | `Magnitude` | `i128` | +| `u8` | `Magnitude` | `u8` | +| `u16` | `Magnitude` | `u16` | +| `u32` | `Magnitude` | `u32` | +| `u64` | `Magnitude` | `u64` | +| `u128` | `Magnitude` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1099,24 +1102,24 @@ let b: u8 = a.shr(1u8); // 1u8 #### Description -Shifts `first` right by `second` bits, storing the outcome in `destination`. +Shifts `first` right by `second` bits, storing the result in `destination`. #### Supported Types -`Magnitude` can be a `U8`, `U16`, or `U32`. +`Magnitude` can be a `u8`, `u16`, or `u32`. | First | Second | Destination | |--------|-------------|-------------| -| `I8` | `Magnitude` | `I8` | -| `I16` | `Magnitude` | `I16` | -| `I32` | `Magnitude` | `I32` | -| `I64` | `Magnitude` | `I64` | -| `I128` | `Magnitude` | `I128` | -| `U8` | `Magnitude` | `U8` | -| `U16` | `Magnitude` | `U16` | -| `U32` | `Magnitude` | `U32` | -| `U64` | `Magnitude` | `U64` | -| `U128` | `Magnitude` | `U128` | +| `i8` | `Magnitude` | `i8` | +| `i16` | `Magnitude` | `i16` | +| `i32` | `Magnitude` | `i32` | +| `i64` | `Magnitude` | `i64` | +| `i128` | `Magnitude` | `i128` | +| `u8` | `Magnitude` | `u8` | +| `u16` | `Magnitude` | `u16` | +| `u32` | `Magnitude` | `u32` | +| `u64` | `Magnitude` | `u64` | +| `u128` | `Magnitude` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1129,24 +1132,24 @@ let a: u8 = 128u8.shr_wrapped(7u8); // 1u8 #### Description -Shifts `first` right by `second` bits, wrapping around at the boundary of the type, storing the outcome in `destination`. +Shifts `first` right by `second` bits, wrapping around at the boundary of the type, storing the result in `destination`. #### Supported Types -`Magnitude` can be a `U8`, `U16`, or `U32`. +`Magnitude` can be a `u8`, `u16`, or `u32`. | First | Second | Destination | |--------|-------------|-------------| -| `I8` | `Magnitude` | `I8` | -| `I16` | `Magnitude` | `I16` | -| `I32` | `Magnitude` | `I32` | -| `I64` | `Magnitude` | `I64` | -| `I128` | `Magnitude` | `I128` | -| `U8` | `Magnitude` | `U8` | -| `U16` | `Magnitude` | `U16` | -| `U32` | `Magnitude` | `U32` | -| `U64` | `Magnitude` | `U64` | -| `U128` | `Magnitude` | `U128` | +| `i8` | `Magnitude` | `i8` | +| `i16` | `Magnitude` | `i16` | +| `i32` | `Magnitude` | `i32` | +| `i64` | `Magnitude` | `i64` | +| `i128` | `Magnitude` | `i128` | +| `u8` | `Magnitude` | `u8` | +| `u16` | `Magnitude` | `u16` | +| `u32` | `Magnitude` | `u32` | +| `u64` | `Magnitude` | `u64` | +| `u128` | `Magnitude` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1159,13 +1162,13 @@ let a: field = 1field.square(); // 1field #### Description -Squares the input, storing the outcome in `destination`. +Squares the input, storing the result in `destination`. #### Supported Types | Input | Destination | |---------|-------------| -| `Field` | `Field` | +| `field` | `field` | [Back to Top](#table-of-standard-operators) *** @@ -1178,13 +1181,13 @@ let a: field = 1field.square_root(); // 1field #### Description -Computes the square root of the input, storing the outcome in `destination`. +Computes the square root of the input, storing the result in `destination`. #### Supported Types | Input | Destination | |---------|-------------| -| `Field` | `Field` | +| `field` | `field` | [Back to Top](#table-of-standard-operators) *** @@ -1199,24 +1202,24 @@ let b: u8 = a.sub(1u8); // 0u8 #### Description -Computes `first - second`, storing the outcome in `destination`. +Computes `first - second`, storing the result in `destination`. #### Supported Types | First | Second | Destination | |---------|---------|-------------| -| `Field` | `Field` | `Field` | -| `Group` | `Group` | `Group` | -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `field` | `field` | `field` | +| `group` | `group` | `group` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1229,22 +1232,22 @@ let a: u8 = 0u8.sub_wrapped(1u8); // 255u8 #### Description -Computes `first - second`, wrapping around at the boundary of the type, and storing the outcome in `destination`. +Computes `first - second`, wrapping around at the boundary of the type, and storing the result in `destination`. #### Supported Types | First | Second | Destination | |--------|--------|-------------| -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1263,21 +1266,21 @@ Selects `first`, if `condition` is true, otherwise selects `second`, storing the | Condition | First | Second | Destination | |-----------|-------------|-------------|-------------| -| `Boolean` | `Boolean` | `Boolean` | `Boolean` | -| `Boolean` | `Field` | `Field` | `Field` | -| `Boolean` | `Group` | `Group` | `Group` | -| `Boolean` | `I8` | `I8` | `I8` | -| `Boolean` | `I16` | `I16` | `I16` | -| `Boolean` | `I32` | `I32` | `I32` | -| `Boolean` | `I64` | `I64` | `I64` | -| `Boolean` | `I128` | `I128` | `I128` | -| `Boolean` | `U8` | `U8` | `U8` | -| `Boolean` | `U16` | `U16` | `U16` | -| `Boolean` | `U32` | `U32` | `U32` | -| `Boolean` | `U64` | `U64` | `U64` | -| `Boolean` | `U128` | `U128` | `U128` | -| `Boolean` | `Scalar` | `Scalar` | `Scalar` | -| `Boolean` | `Signature` | `Signature` | `Signature` | +| `bool` | `bool` | `bool` | `bool` | +| `bool` | `field` | `field` | `field` | +| `bool` | `group` | `group` | `group` | +| `bool` | `i8` | `i8` | `i8` | +| `bool` | `i16` | `i16` | `i16` | +| `bool` | `i32` | `i32` | `i32` | +| `bool` | `i64` | `i64` | `i64` | +| `bool` | `i128` | `i128` | `i128` | +| `bool` | `u8` | `u8` | `u8` | +| `bool` | `u16` | `u16` | `u16` | +| `bool` | `u32` | `u32` | `u32` | +| `bool` | `u64` | `u64` | `u64` | +| `bool` | `u128` | `u128` | `u128` | +| `bool` | `scalar` | `scalar` | `scalar` | +| `bool` | `Signature` | `Signature` | `Signature` | [Back to Top](#table-of-standard-operators) *** @@ -1290,23 +1293,23 @@ let a: bool = true.xor(false); // true #### Description -Performs a XOR operation on integer (bitwise) or boolean `first` and `second`, storing the outcome in `destination`. +Performs a XOR operation on integer (bitwise) or boolean `first` and `second`, storing the result in `destination`. #### Supported Types | First | Second | Destination | |-----------|-----------|-------------| -| `Boolean` | `Boolean` | `Boolean` | -| `I8` | `I8` | `I8` | -| `I16` | `I16` | `I16` | -| `I32` | `I32` | `I32` | -| `I64` | `I64` | `I64` | -| `I128` | `I128` | `I128` | -| `U8` | `U8` | `U8` | -| `U16` | `U16` | `U16` | -| `U32` | `U32` | `U32` | -| `U64` | `U64` | `U64` | -| `U128` | `U128` | `U128` | +| `bool` | `bool` | `bool` | +| `i8` | `i8` | `i8` | +| `i16` | `i16` | `i16` | +| `i32` | `i32` | `i32` | +| `i64` | `i64` | `i64` | +| `i128` | `i128` | `i128` | +| `u8` | `u8` | `u8` | +| `u16` | `u16` | `u16` | +| `u32` | `u32` | `u32` | +| `u64` | `u64` | `u64` | +| `u128` | `u128` | `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1332,7 +1335,7 @@ It is an associated constant, whose name is `GEN` and whose associated type is ` | Destination | |-------------| -| `Group` | +| `group` | [Back to Top](#table-of-standard-operators) *** @@ -1366,21 +1369,21 @@ Returns a random value with the destination type. | Destination | |-------------| -| `Address` | -| `Boolean` | -| `Field` | -| `Group` | -| `I8` | -| `I16` | -| `I32` | -| `I64` | -| `I128` | -| `U8` | -| `U16` | -| `U32` | -| `U64` | -| `U128` | -| `Scalar` | +| `address` | +| `bool` | +| `field` | +| `group` | +| `i8` | +| `i16` | +| `i32` | +| `i64` | +| `i128` | +| `u8` | +| `u16` | +| `u32` | +| `u64` | +| `u128` | +| `scalar` | ### `BHP256::commit_to_DESTINATION` @@ -1394,7 +1397,7 @@ let c: group = BHP256::commit_to_group(1field, salt); #### Description -Computes a Bowe-Hopwood-Pedersen commitment on inputs of 256-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment can be an `Address`, `Field` or, `Group` value. +Computes a Bowe-Hopwood-Pedersen commitment on inputs of 256-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment can be an `address`, `field` or, `group` value. The instruction will halt if the given input is smaller than 129 bits. @@ -1402,22 +1405,22 @@ The instruction will halt if the given input is smaller than 129 bits. | First | Second | Destination | |-----------|----------|:----------------------------| -| `Address` | `Scalar` | `Address`, `Field`, `Group` | -| `Boolean` | `Scalar` | `Address`, `Field`, `Group` | -| `Field` | `Scalar` | `Address`, `Field`, `Group` | -| `Group` | `Scalar` | `Address`, `Field`, `Group` | -| `I8` | `Scalar` | `Address`, `Field`, `Group` | -| `I16` | `Scalar` | `Address`, `Field`, `Group` | -| `I32` | `Scalar` | `Address`, `Field`, `Group` | -| `I64` | `Scalar` | `Address`, `Field`, `Group` | -| `I128` | `Scalar` | `Address`, `Field`, `Group` | -| `U8` | `Scalar` | `Address`, `Field`, `Group` | -| `U16` | `Scalar` | `Address`, `Field`, `Group` | -| `U32` | `Scalar` | `Address`, `Field`, `Group` | -| `U64` | `Scalar` | `Address`, `Field`, `Group` | -| `U128` | `Scalar` | `Address`, `Field`, `Group` | -| `Scalar` | `Scalar` | `Address`, `Field`, `Group` | -| `Struct` | `Scalar` | `Address`, `Field`, `Group` | +| `address` | `scalar` | `address`, `field`, `group` | +| `bool` | `scalar` | `address`, `field`, `group` | +| `field` | `scalar` | `address`, `field`, `group` | +| `group` | `scalar` | `address`, `field`, `group` | +| `i8` | `scalar` | `address`, `field`, `group` | +| `i16` | `scalar` | `address`, `field`, `group` | +| `i32` | `scalar` | `address`, `field`, `group` | +| `i64` | `scalar` | `address`, `field`, `group` | +| `i128` | `scalar` | `address`, `field`, `group` | +| `u8` | `scalar` | `address`, `field`, `group` | +| `u16` | `scalar` | `address`, `field`, `group` | +| `u32` | `scalar` | `address`, `field`, `group` | +| `u64` | `scalar` | `address`, `field`, `group` | +| `u128` | `scalar` | `address`, `field`, `group` | +| `scalar` | `scalar` | `address`, `field`, `group` | +| `struct` | `scalar` | `address`, `field`, `group` | [Back to Top](#table-of-standard-operators) *** @@ -1433,7 +1436,7 @@ let c: group = BHP512::commit_to_group(1field, salt); #### Description -Computes a Bowe-Hopwood-Pedersen commitment on inputs of 512-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value. +Computes a Bowe-Hopwood-Pedersen commitment on inputs of 512-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value. The instruction will halt if the given input is smaller than 171 bits. @@ -1441,22 +1444,22 @@ The instruction will halt if the given input is smaller than 171 bits. | First | Second | Destination | |-----------|----------|:----------------------------| -| `Address` | `Scalar` | `Address`, `Field`, `Group` | -| `Boolean` | `Scalar` | `Address`, `Field`, `Group` | -| `Field` | `Scalar` | `Address`, `Field`, `Group` | -| `Group` | `Scalar` | `Address`, `Field`, `Group` | -| `I8` | `Scalar` | `Address`, `Field`, `Group` | -| `I16` | `Scalar` | `Address`, `Field`, `Group` | -| `I32` | `Scalar` | `Address`, `Field`, `Group` | -| `I64` | `Scalar` | `Address`, `Field`, `Group` | -| `I128` | `Scalar` | `Address`, `Field`, `Group` | -| `U8` | `Scalar` | `Address`, `Field`, `Group` | -| `U16` | `Scalar` | `Address`, `Field`, `Group` | -| `U32` | `Scalar` | `Address`, `Field`, `Group` | -| `U64` | `Scalar` | `Address`, `Field`, `Group` | -| `U128` | `Scalar` | `Address`, `Field`, `Group` | -| `Scalar` | `Scalar` | `Address`, `Field`, `Group` | -| `Struct` | `Scalar` | `Address`, `Field`, `Group` | +| `address` | `scalar` | `address`, `field`, `group` | +| `bool` | `scalar` | `address`, `field`, `group` | +| `field` | `scalar` | `address`, `field`, `group` | +| `group` | `scalar` | `address`, `field`, `group` | +| `i8` | `scalar` | `address`, `field`, `group` | +| `i16` | `scalar` | `address`, `field`, `group` | +| `i32` | `scalar` | `address`, `field`, `group` | +| `i64` | `scalar` | `address`, `field`, `group` | +| `i128` | `scalar` | `address`, `field`, `group` | +| `u8` | `scalar` | `address`, `field`, `group` | +| `u16` | `scalar` | `address`, `field`, `group` | +| `u32` | `scalar` | `address`, `field`, `group` | +| `u64` | `scalar` | `address`, `field`, `group` | +| `u128` | `scalar` | `address`, `field`, `group` | +| `scalar` | `scalar` | `address`, `field`, `group` | +| `struct` | `scalar` | `address`, `field`, `group` | [Back to Top](#table-of-standard-operators) *** @@ -1472,7 +1475,7 @@ let c: group = BHP768::commit_to_group(1field, salt); #### Description -Computes a Bowe-Hopwood-Pedersen commitment on inputs of 768-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value. +Computes a Bowe-Hopwood-Pedersen commitment on inputs of 768-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value. The instruction will halt if the given input is smaller than 129 bits. @@ -1480,22 +1483,22 @@ The instruction will halt if the given input is smaller than 129 bits. | First | Second | Destination | |-----------|----------|:----------------------------| -| `Address` | `Scalar` | `Address`, `Field`, `Group` | -| `Boolean` | `Scalar` | `Address`, `Field`, `Group` | -| `Field` | `Scalar` | `Address`, `Field`, `Group` | -| `Group` | `Scalar` | `Address`, `Field`, `Group` | -| `I8` | `Scalar` | `Address`, `Field`, `Group` | -| `I16` | `Scalar` | `Address`, `Field`, `Group` | -| `I32` | `Scalar` | `Address`, `Field`, `Group` | -| `I64` | `Scalar` | `Address`, `Field`, `Group` | -| `I128` | `Scalar` | `Address`, `Field`, `Group` | -| `U8` | `Scalar` | `Address`, `Field`, `Group` | -| `U16` | `Scalar` | `Address`, `Field`, `Group` | -| `U32` | `Scalar` | `Address`, `Field`, `Group` | -| `U64` | `Scalar` | `Address`, `Field`, `Group` | -| `U128` | `Scalar` | `Address`, `Field`, `Group` | -| `Scalar` | `Scalar` | `Address`, `Field`, `Group` | -| `Struct` | `Scalar` | `Address`, `Field`, `Group` | +| `address` | `scalar` | `address`, `field`, `group` | +| `bool` | `scalar` | `address`, `field`, `group` | +| `field` | `scalar` | `address`, `field`, `group` | +| `group` | `scalar` | `address`, `field`, `group` | +| `i8` | `scalar` | `address`, `field`, `group` | +| `i16` | `scalar` | `address`, `field`, `group` | +| `i32` | `scalar` | `address`, `field`, `group` | +| `i64` | `scalar` | `address`, `field`, `group` | +| `i128` | `scalar` | `address`, `field`, `group` | +| `u8` | `scalar` | `address`, `field`, `group` | +| `u16` | `scalar` | `address`, `field`, `group` | +| `u32` | `scalar` | `address`, `field`, `group` | +| `u64` | `scalar` | `address`, `field`, `group` | +| `u128` | `scalar` | `address`, `field`, `group` | +| `scalar` | `scalar` | `address`, `field`, `group` | +| `struct` | `scalar` | `address`, `field`, `group` | [Back to Top](#table-of-standard-operators) *** @@ -1511,7 +1514,7 @@ let c: group = BHP1024::commit_to_group(1field, salt); #### Description -Computes a Bowe-Hopwood-Pedersen commitment on inputs of 1024-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value. +Computes a Bowe-Hopwood-Pedersen commitment on inputs of 1024-bit chunks in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value. The instruction will halt if the given input is smaller than 171 bits. @@ -1519,22 +1522,22 @@ The instruction will halt if the given input is smaller than 171 bits. | First | Second | Destination | |-----------|----------|:----------------------------| -| `Address` | `Scalar` | `Address`, `Field`, `Group` | -| `Boolean` | `Scalar` | `Address`, `Field`, `Group` | -| `Field` | `Scalar` | `Address`, `Field`, `Group` | -| `Group` | `Scalar` | `Address`, `Field`, `Group` | -| `I8` | `Scalar` | `Address`, `Field`, `Group` | -| `I16` | `Scalar` | `Address`, `Field`, `Group` | -| `I32` | `Scalar` | `Address`, `Field`, `Group` | -| `I64` | `Scalar` | `Address`, `Field`, `Group` | -| `I128` | `Scalar` | `Address`, `Field`, `Group` | -| `U8` | `Scalar` | `Address`, `Field`, `Group` | -| `U16` | `Scalar` | `Address`, `Field`, `Group` | -| `U32` | `Scalar` | `Address`, `Field`, `Group` | -| `U64` | `Scalar` | `Address`, `Field`, `Group` | -| `U128` | `Scalar` | `Address`, `Field`, `Group` | -| `Scalar` | `Scalar` | `Address`, `Field`, `Group` | -| `Struct` | `Scalar` | `Address`, `Field`, `Group` | +| `address` | `scalar` | `address`, `field`, `group` | +| `bool` | `scalar` | `address`, `field`, `group` | +| `field` | `scalar` | `address`, `field`, `group` | +| `group` | `scalar` | `address`, `field`, `group` | +| `i8` | `scalar` | `address`, `field`, `group` | +| `i16` | `scalar` | `address`, `field`, `group` | +| `i32` | `scalar` | `address`, `field`, `group` | +| `i64` | `scalar` | `address`, `field`, `group` | +| `i128` | `scalar` | `address`, `field`, `group` | +| `u8` | `scalar` | `address`, `field`, `group` | +| `u16` | `scalar` | `address`, `field`, `group` | +| `u32` | `scalar` | `address`, `field`, `group` | +| `u64` | `scalar` | `address`, `field`, `group` | +| `u128` | `scalar` | `address`, `field`, `group` | +| `scalar` | `scalar` | `address`, `field`, `group` | +| `struct` | `scalar` | `address`, `field`, `group` | [Back to Top](#table-of-standard-operators) *** @@ -1550,22 +1553,22 @@ let c: group = Pedersen64::commit_to_group(1field, salt); #### Description -Computes a Pedersen commitment up to a 64-bit input in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value. +Computes a Pedersen commitment up to a 64-bit input in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value. -The instruction will halt if the given `Struct` value exceeds the 64-bit limit. +The instruction will halt if the given `struct` value exceeds the 64-bit limit. #### Supported Types | First | Second | Destination | |-----------|----------|:----------------------------| -| `Boolean` | `Scalar` | `Address`, `Field`, `Group` | -| `I8` | `Scalar` | `Address`, `Field`, `Group` | -| `I16` | `Scalar` | `Address`, `Field`, `Group` | -| `I32` | `Scalar` | `Address`, `Field`, `Group` | -| `U8` | `Scalar` | `Address`, `Field`, `Group` | -| `U16` | `Scalar` | `Address`, `Field`, `Group` | -| `U32` | `Scalar` | `Address`, `Field`, `Group` | -| `Struct` | `Scalar` | `Address`, `Field`, `Group` | +| `bool` | `scalar` | `address`, `field`, `group` | +| `i8` | `scalar` | `address`, `field`, `group` | +| `i16` | `scalar` | `address`, `field`, `group` | +| `i32` | `scalar` | `address`, `field`, `group` | +| `u8` | `scalar` | `address`, `field`, `group` | +| `u16` | `scalar` | `address`, `field`, `group` | +| `u32` | `scalar` | `address`, `field`, `group` | +| `struct` | `scalar` | `address`, `field`, `group` | [Back to Top](#table-of-standard-operators) *** @@ -1581,25 +1584,25 @@ let c: group = Pedersen64::commit_to_group(1field, salt); #### Description -Computes a Pedersen commitment up to a 128-bit input in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `Scalar` value, and the produced commitment will always be a `Group` value. +Computes a Pedersen commitment up to a 128-bit input in `first`, and some randomness in `second`, storing the commitment in `destination`. Randomness should always be a `scalar` value, and the produced commitment will always be a `group` value. -The instruction will halt if the given `Struct` value exceeds the 128-bit limit. +The instruction will halt if the given `struct` value exceeds the 128-bit limit. #### Supported Types | First | Second | Destination | |-----------|----------|:----------------------------| -| `Boolean` | `Scalar` | `Address`, `Field`, `Group` | -| `I8` | `Scalar` | `Address`, `Field`, `Group` | -| `I16` | `Scalar` | `Address`, `Field`, `Group` | -| `I32` | `Scalar` | `Address`, `Field`, `Group` | -| `I64` | `Scalar` | `Address`, `Field`, `Group` | -| `U8` | `Scalar` | `Address`, `Field`, `Group` | -| `U16` | `Scalar` | `Address`, `Field`, `Group` | -| `U32` | `Scalar` | `Address`, `Field`, `Group` | -| `U64` | `Scalar` | `Address`, `Field`, `Group` | -| `Struct` | `Scalar` | `Address`, `Field`, `Group` | +| `bool` | `scalar` | `address`, `field`, `group` | +| `i8` | `scalar` | `address`, `field`, `group` | +| `i16` | `scalar` | `address`, `field`, `group` | +| `i32` | `scalar` | `address`, `field`, `group` | +| `i64` | `scalar` | `address`, `field`, `group` | +| `u8` | `scalar` | `address`, `field`, `group` | +| `u16` | `scalar` | `address`, `field`, `group` | +| `u32` | `scalar` | `address`, `field`, `group` | +| `u64` | `scalar` | `address`, `field`, `group` | +| `struct` | `scalar` | `address`, `field`, `group` | [Back to Top](#table-of-standard-operators) *** @@ -1626,7 +1629,7 @@ let result: u128 = BHP256::hash_to_u128(1field); #### Description -Computes a Bowe-Hopwood-Pedersen hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Computes a Bowe-Hopwood-Pedersen hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. The instruction will halt if the given input is smaller than 129 bits. @@ -1634,22 +1637,22 @@ The instruction will halt if the given input is smaller than 129 bits. | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1675,7 +1678,7 @@ let result: u128 = BHP512::hash_to_u128(1field); #### Description -Computes a Bowe-Hopwood-Pedersen hash on inputs of 512-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Computes a Bowe-Hopwood-Pedersen hash on inputs of 512-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. The instruction will halt if the given input is smaller than 171 bits. @@ -1683,22 +1686,22 @@ The instruction will halt if the given input is smaller than 171 bits. | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1724,7 +1727,7 @@ let result: u128 = BHP768::hash_to_u128(1field); #### Description -Computes a Bowe-Hopwood-Pedersen hash on inputs of 768-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Computes a Bowe-Hopwood-Pedersen hash on inputs of 768-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. The instruction will halt if the given input is smaller than 129 bits. @@ -1732,22 +1735,22 @@ The instruction will halt if the given input is smaller than 129 bits. | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1773,7 +1776,7 @@ let result: u128 = BHP1024::hash_to_u128(1field); #### Description -Computes a Bowe-Hopwood-Pedersen hash on inputs of 1024-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Computes a Bowe-Hopwood-Pedersen hash on inputs of 1024-bit chunks in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. The instruction will halt if the given input is smaller than 171 bits. @@ -1781,22 +1784,22 @@ The instruction will halt if the given input is smaller than 171 bits. | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1823,28 +1826,28 @@ let result: u128 = Keccak256::hash_to_u128(1field); #### Description Computes a Keccak256 hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`. -The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1871,28 +1874,28 @@ let result: u128 = Keccak384::hash_to_u128(1field); #### Description Computes a Keccak384 hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`. -The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1919,28 +1922,28 @@ let result: u128 = Keccak512::hash_to_u128(1field); #### Description Computes a Keccak512 hash on inputs of 256-bit chunks in `first`, storing the hash in `destination`. -The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -1966,22 +1969,22 @@ let result: u128 = Pedersen64::hash_to_u128(1field); #### Description -Computes a Pedersen hash up to a 64-bit input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Computes a Pedersen hash up to a 64-bit input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. -The instruction will halt if the given `Struct` value exceeds the 64-bit limit. +The instruction will halt if the given `struct` value exceeds the 64-bit limit. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -2007,24 +2010,24 @@ let result: u128 = Pedersen128::hash_to_u128(1field); #### Description -Computes a Pedersen hash up to a 128-bit input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Computes a Pedersen hash up to a 128-bit input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. -The instruction will halt if the given `Struct` value exceeds the 64-bit limit. +The instruction will halt if the given `struct` value exceeds the 64-bit limit. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -2051,28 +2054,28 @@ let result: u128 = Poseidon2::hash_to_u128(1field); #### Description -Calculates a Poseidon hash with an input rate of 2, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Calculates a Poseidon hash with an input rate of 2, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -2099,28 +2102,28 @@ let result: u128 = Poseidon4::hash_to_u128(1field); #### Description -Calculates a Poseidon hash with an input rate of 4, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Calculates a Poseidon hash with an input rate of 4, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -2147,28 +2150,28 @@ let result: u128 = Poseidon8::hash_to_u128(1field); #### Description -Calculates a Poseidon hash with an input rate of 8, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Calculates a Poseidon hash with an input rate of 8, from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -2194,28 +2197,28 @@ let result: u128 = SHA3_256::hash_to_u128(1field); #### Description -Calculates a SHA3_256 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Calculates a SHA3_256 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -2241,28 +2244,28 @@ let result: u128 = SHA3_384::hash_to_u128(1field); #### Description -Calculates a SHA3_384 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Calculates a SHA3_384 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** @@ -2288,28 +2291,28 @@ let result: u128 = SHA3_512::hash_to_u128(1field); #### Description -Calculates a SHA3_512 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`U8`, `U16`, `U32`, `U64`, `U128`, `I8`, `I16`, `I32`,`I64`,`I128`, `Field`, `Group`, or `Scalar`) or `Address` value, as specified via `hash_to_DESTINATION` at the end of the function. +Calculates a SHA3_512 hash from an input in `first`, storing the hash in `destination`. The produced hash will always be an arithmetic (`u8`, `u16`, `u32`, `u64`, `u128`, `i8`, `i16`, `i32`,`i64`,`i128`, `field`, `group`, or `scalar`) or `address` value, as specified via `hash_to_DESTINATION` at the end of the function. #### Supported Types | First | Destination | |-----------|:----------------------------------------------------------------------------------------------------------| -| `Address` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Boolean` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Field` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Group` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `I128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U8` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U16` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U32` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U64` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `U128` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Scalar` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | -| `Struct` | `Address`, `Field`, `Group`, `Scalar`, `I8`, `I16`, `I32`,`I64`,`I128`, `U8`, `U16`, `U32`, `U64`, `U128` | +| `address` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `bool` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `field` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `group` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `i128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u8` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u16` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u32` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u64` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `u128` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `scalar` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | +| `struct` | `address`, `field`, `group`, `scalar`, `i8`, `i16`, `i32`,`i64`,`i128`, `u8`, `u16`, `u32`, `u64`, `u128` | [Back to Top](#table-of-standard-operators) *** diff --git a/documentation/leo/08_resources.md b/documentation/leo/08_resources.md index 3f70502ba..fab4e6bde 100644 --- a/documentation/leo/08_resources.md +++ b/documentation/leo/08_resources.md @@ -142,7 +142,9 @@ as well as the recommended code solution. ### Conditional Branches -Conditional `if else` statements in Leo are expensive. It is preferred to use ternary `? :` expressions. +The Leo compiler rewrites if-else statements inside `transitions` into a sequence of ternary expressions. +This is because the underlying circuit construction does not support branching. +For precise control over the circuit size, it is recommended to use ternary expressions directly. ```leo title="Example:" if (condition) {