Enum Hook 

#[repr(u8)]
pub enum Hook {
    Add = 0,
    Sub = 1,
    Mul = 2,
    Div = 3,
    Rem = 4,
    FloorDiv = 5,
    FloorMod = 6,
    BitAnd = 7,
    BitOr = 8,
    BitXor = 9,
    Shl = 10,
    Shr = 11,
    Neg = 12,
    BitNot = 13,
    Eq = 14,
    Lt = 15,
    Le = 16,
    Truthy = 17,
    Concat = 18,
    GetIndex = 19,
    SetIndex = 20,
    GetProp = 21,
    SetProp = 22,
    HasProp = 23,
    Iter = 24,
    Len = 25,
    Call = 26,
    Spawn = 27,
    Pow = 28,
    Abs = 29,
    CallShape = 30,
}

A dynamic-operation hook: the function a dynamic instruction calls when its built-in fast path does not apply (for example dadd on two strings, or get_prop on an object with no such field).

Hooks are how a dynamic language supplies its own semantics (PHP’s loose ==, Python’s list equality) without a separate instruction set per language. A missing hook makes the operation raise TypeError (E0100) or the error the instruction documents.

Examples

use bytecode_lang::Hook;

assert_eq!(Hook::Add.code(), 0);
assert_eq!(Hook::GetProp.to_string(), "get_prop");

Variants

Add = 0

dadd fallback: (dyn, dyn) -> dyn.

Sub = 1

dsub fallback: (dyn, dyn) -> dyn.

Mul = 2

dmul fallback: (dyn, dyn) -> dyn.

Div = 3

ddiv fallback: (dyn, dyn) -> dyn.

Rem = 4

drem fallback: (dyn, dyn) -> dyn.

FloorDiv = 5

dfloor_div fallback: (dyn, dyn) -> dyn.

FloorMod = 6

dfloor_mod fallback: (dyn, dyn) -> dyn.

BitAnd = 7

dand fallback: (dyn, dyn) -> dyn.

BitOr = 8

dor fallback: (dyn, dyn) -> dyn.

BitXor = 9

dxor fallback: (dyn, dyn) -> dyn.

Shl = 10

dshl fallback: (dyn, dyn) -> dyn.

Shr = 11

dshr fallback: (dyn, dyn) -> dyn.

Neg = 12

dneg fallback: (dyn) -> dyn.

BitNot = 13

dnot fallback: (dyn) -> dyn.

Eq = 14

deq/dne fallback: (dyn, dyn) -> dyn returning a boolean.

Lt = 15

dlt/dgt fallback: (dyn, dyn) -> dyn returning a boolean.

Le = 16

dle/dge fallback: (dyn, dyn) -> dyn returning a boolean.

Truthy = 17

dtruthy for kinds other than nil, bool, int, float: (dyn) -> dyn.

Concat = 18

dconcat fallback: (dyn, dyn) -> dyn.

GetIndex = 19

dget_index fallback: (dyn, dyn) -> dyn.

SetIndex = 20

dset_index fallback: (dyn, dyn, dyn) -> ().

GetProp = 21

get_prop fallback: (dyn, dyn) -> dyn (object, name string).

SetProp = 22

set_prop fallback: (dyn, dyn, dyn) -> ().

HasProp = 23

has_prop fallback: (dyn, dyn) -> dyn returning a boolean.

Iter = 24

diter_new fallback: (dyn) -> dyn returning something iterable.

Len = 25

dlen fallback: (dyn) -> dyn returning an integer.

Call = 26

dcall on a non-callable: (dyn, dyn) -> dyn (callee, argument array).

Spawn = 27

spawn: hands a new coroutine to the host scheduler (host-lang): (dyn) -> dyn (coroutine, task handle).

Pow = 28

dpow fallback: (dyn, dyn) -> dyn.

Abs = 29

dabs fallback: (dyn) -> dyn.

CallShape = 30

dcall_shape on a non-callable: (dyn, dyn, dyn) -> dyn (callee, positional arguments as an array, named arguments as a map from name to value). Without it, a call with no named arguments falls back to the call hook.

Implementations

impl Hook

pub const ALL: &'static [Hook]

Every value, in code order.

pub const fn from_code(code: u8) -> Option<Self>

The value with this stable code, or None if no value has it.

pub const fn code(self) -> u8

The stable code this value is encoded as.

pub const fn name(self) -> &'static str

The lowercase name the disassembler prints.

Trait Implementations

impl Clone for Hook

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Hook

impl Debug for Hook

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Hook

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Hook

impl Hash for Hook

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Hook

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Hook

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Hook

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Hook