Enum pr47::vm::al31f::insc::Insc[−][src]

pub enum Insc {

Show 111 variants    AddInt(usize, usize, usize),
    AddFloat(usize, usize, usize),
    AddAny(usize, usize, usize),
    IncrInt(usize),
    DecrInt(usize),
    SubInt(usize, usize, usize),
    SubFloat(usize, usize, usize),
    SubAny(usize, usize, usize),
    MulInt(usize, usize, usize),
    MulFloat(usize, usize, usize),
    MulAny(usize, usize, usize),
    DivInt(usize, usize, usize),
    DivFloat(usize, usize, usize),
    DivAny(usize, usize, usize),
    ModInt(usize, usize, usize),
    ModAny(usize, usize, usize),
    EqValue(usize, usize, usize),
    EqRef(usize, usize, usize),
    EqAny(usize, usize, usize),
    NeValue(usize, usize, usize),
    NeRef(usize, usize, usize),
    NeAny(usize, usize, usize),
    LtInt(usize, usize, usize),
    LtFloat(usize, usize, usize),
    LtAny(usize, usize, usize),
    GtInt(usize, usize, usize),
    GtFloat(usize, usize, usize),
    GtAny(usize, usize, usize),
    LeInt(usize, usize, usize),
    LeFloat(usize, usize, usize),
    LeAny(usize, usize, usize),
    GeInt(usize, usize, usize),
    GeFloat(usize, usize, usize),
    GeAny(usize, usize, usize),
    BAndInt(usize, usize, usize),
    BAndAny(usize, usize, usize),
    BOrInt(usize, usize, usize),
    BOrAny(usize, usize, usize),
    BXorInt(usize, usize, usize),
    BXorAny(usize, usize, usize),
    BNotInt(usize, usize),
    BNotAny(usize, usize),
    NegInt(usize, usize),
    NegFloat(usize, usize),
    NegAny(usize, usize),
    AndBool(usize, usize, usize),
    AndAny(usize, usize, usize),
    OrBool(usize, usize, usize),
    OrAny(usize, usize, usize),
    NotBool(usize, usize),
    NotAny(usize, usize),
    ShlInt(usize, usize, usize),
    ShlAny(usize, usize, usize),
    ShrInt(usize, usize, usize),
    ShrAny(usize, usize, usize),
    MakeIntConst(i64, usize),
    MakeFloatConst(f64, usize),
    MakeCharConst(char, usize),
    MakeBoolConst(bool, usize),
    MakeNull(usize),
    LoadConst(usize, usize),
    SaveConst(usize, usize),
    CastFloatInt(usize, usize),
    CastBoolInt(usize, usize),
    CastAnyInt(usize, usize),
    CastIntFloat(usize, usize),
    CastAnyFloat(usize, usize),
    CastAnyChar(usize, usize),
    CastIntBool(usize, usize),
    CastAnyBool(usize, usize),
    IsNull(usize, usize),
    NullCheck(usize),
    TypeCheck(usize, NonNull<TyckInfo>),
    Call(usize, Box<[usize]>, Box<[usize]>),
    CallPtr(usize, Box<[usize]>, Box<[usize]>),
    CallOverload(usize, Box<[usize]>, Box<[usize]>),
    ReturnNothing,
    ReturnOne(usize),
    Return(Box<[usize]>),
    FFICallRtlc(usize, Box<[usize]>, Box<[usize]>),
    FFICall(usize, Box<[usize]>, Box<[usize]>),
    FFICallAsync(usize, Box<[usize]>, usize),
    Await(usize, Box<[usize]>),
    Raise(usize),
    JumpIfTrue(usize, usize),
    JumpIfFalse(usize, usize),
    Jump(usize),
    CreateString(usize),
    CreateObject(usize),
    CreateContainer(GenericTypeCtor, NonNull<GenericTypeVT>, usize),
    VecIndex(usize, usize, usize),
    VecIndexPut(usize, usize, usize),
    VecInsert(usize, usize, usize),
    VecRemove(usize, usize, usize),
    VecLen(usize),
    VecClear(usize),
    DenseVecIndex(usize, usize, usize),
    DenseVecIndexPut(usize, usize, usize),
    DenseVecInsert(usize, usize, usize),
    DenseVecRemove(usize, usize, usize),
    DenseVecLen(usize),
    DenseVecClear(usize),
    StrConcat(usize, usize, usize),
    StrFormat(usize, Box<[usize]>, usize),
    StrLen(usize, usize),
    StrSlice(usize, usize, usize, usize),
    StrEquals(usize, usize),
    ObjectGet(usize, NonNull<str>, usize),
    ObjectGetDyn(usize, usize, usize),
    ObjectPut(usize, NonNull<str>, usize),
    ObjectPutDyn(usize, usize, usize),

}
Expand description

An VM instruction

This is a tri-address like instruction set for register machine.

Variants

AddInt(usize, usize, usize)

ADD-INT [INT@SRC1] [INT@SRC2] [DEST]

Add integers in register SRC1 and SRC2, put result to register DEST, No type checking.

Tuple Fields of AddInt

0: usize1: usize2: usize
AddFloat(usize, usize, usize)

ADD-FLOAT [FLOAT@SRC1] [FLOAT@SRC2] [DEST]

Add floats in register SRC1 and SRC2, put result to register DEST, No type checking.

Tuple Fields of AddFloat

0: usize1: usize2: usize
AddAny(usize, usize, usize)

ADD-ANY [SRC1] [SRC2] [DEST]

Load numbers in register SRC1 and SRC2, check types at run time and perform appropriate addition calculation accordingly, and put result to register DEST.

Tuple Fields of AddAny

0: usize1: usize2: usize
IncrInt(usize)

INCR [INT@POS]

Increment the integer stored in register POS, in place. No type checking.

Tuple Fields of IncrInt

0: usize
DecrInt(usize)

DECR [INT@POS]

Decrement the integer stored in register POS, in place. No type checking.

Tuple Fields of DecrInt

0: usize
SubInt(usize, usize, usize)

SUB-INT [INT@SRC1] [INT@SRC2] [DEST]

Subtract integers in register SRC1 and SRC2, put result to register DEST, No type checking.

Tuple Fields of SubInt

0: usize1: usize2: usize
SubFloat(usize, usize, usize)

SUB-FLOAT [FLOAT@SRC1] [FLOAT@SRC1] [DEST]

Subtract floats in register SRC1 and SRC2, put result to register DEST, No type checking.

Tuple Fields of SubFloat

0: usize1: usize2: usize
SubAny(usize, usize, usize)

SUB-ANY [SRC1] [SRC2] [DEST]

Load numbers in register SRC1 and SRC2, check types at run time and perform appropriate subtraction calculation accordingly, and put result to register DEST.

Tuple Fields of SubAny

0: usize1: usize2: usize
MulInt(usize, usize, usize)

MUL-INT [INT@SRC1] [INT@SRC2] [DEST]

Multiply integers in register SRC1 and SRC2, put result to register DEST, No type checking.

Tuple Fields of MulInt

0: usize1: usize2: usize
MulFloat(usize, usize, usize)

MUL-FLOAT [FLOAT@SRC1] [FLOAT@SRC2] [DEST]

Multiply floats in register SRC1 and SRC2, put result to register DEST, No type checking.

Tuple Fields of MulFloat

0: usize1: usize2: usize
MulAny(usize, usize, usize)

MUL-ANY [SRC1] [SRC2] [DEST]

Load numbers in register SRC1 and SRC2, check types at run time and perform appropriate multiplication calculation accordingly, and put result to register DEST.

Tuple Fields of MulAny

0: usize1: usize2: usize
DivInt(usize, usize, usize)

DIV-INT [INT@SRC1] [INT@SRC2] [DEST]

Divide integer in register SRC1 by integer in register SRC2, put result to register DEST, No type checking.

Tuple Fields of DivInt

0: usize1: usize2: usize
DivFloat(usize, usize, usize)

DIV-FLOAT [FLOAT@SRC1] [FLOAT@SRC2] [DEST]

Divide float in register SRC1 by float in register SRC2, put result to register DEST, No type checking.

Tuple Fields of DivFloat

0: usize1: usize2: usize
DivAny(usize, usize, usize)

DIV-ANY [SRC1] [SRC2] [DEST]

Load numbers in register SRC1 and SRC2, check types at run time and perform appropriate division calculation accordingly, and put result to register DEST.

Tuple Fields of DivAny

0: usize1: usize2: usize
ModInt(usize, usize, usize)

MOD-INT [INT@SRC1] [INT@SRC2] [DEST]

Take the remainder of dividing integer in register SRC1 by integer in register SRC2, put result to register DEST, No type checking..

Tuple Fields of ModInt

0: usize1: usize2: usize
ModAny(usize, usize, usize)

MOD-ANY [FLOAT@SRC1] [FLOAT@SRC2] [DEST]

Check data in both SRC1 and SRC2 to be integer, perform integer remainder operation, and put result to register DEST.

Tuple Fields of ModAny

0: usize1: usize2: usize
EqValue(usize, usize, usize)

EQ-VALUE [VALUE@SRC1] [VALUE@SRC2] [DEST]

Assume that SRC1 and SRC2 are values of same type, check their equality. This instruction should not be used for float comparison. For comparing float values, use EQ-FLOAT.

Tuple Fields of EqValue

0: usize1: usize2: usize
EqRef(usize, usize, usize)

EQ-REF [REF@SRC1] [REF@SRC2] [DEST]

Assume that SRC1 and SRC2 are both references, check their equality.

Tuple Fields of EqRef

0: usize1: usize2: usize
EqAny(usize, usize, usize)

EQ-ANY [SRC1] [SRC2] [DEST]

Make no assumptions on SRC1 and SRC2, check their equality.

Tuple Fields of EqAny

0: usize1: usize2: usize
NeValue(usize, usize, usize)

NE-VALUE [VALUE@SRC1] [VALUE@SRC2] [DEST]

Similar to EQ-VALUE but yields inverted result.

Tuple Fields of NeValue

0: usize1: usize2: usize
NeRef(usize, usize, usize)

NE-REF [REF@SRC1] [REF@SRC2] [DEST]

Similar to EQ-REF but yields inverted result.

Tuple Fields of NeRef

0: usize1: usize2: usize
NeAny(usize, usize, usize)

NE-ANY [SRC1] [SRC2] [DEST]

Similar to EQ-ANY but yields inverted result.

Tuple Fields of NeAny

0: usize1: usize2: usize
LtInt(usize, usize, usize)

LT-INT [INT@SRC1] [INT@SRC2] [DEST]

Check if integer in register SRC1 is less than integer in register SRC2, put the boolean result to DEST. No type checking.

Tuple Fields of LtInt

0: usize1: usize2: usize
LtFloat(usize, usize, usize)

LT-FLOAT [SRC1] [SRC2] [DEST]

Check if float in register SRC1 is less than float in register SRC2, put the boolean result to DEST. No type checking.

Tuple Fields of LtFloat

0: usize1: usize2: usize
LtAny(usize, usize, usize)

LT-ANY [SRC1] [SRC2] [DEST]

Load numbers in register SRC1 and SRC2, check types at run time and perform appropriate less-than comparison accordingly, and put result to register DEST.

Tuple Fields of LtAny

0: usize1: usize2: usize
GtInt(usize, usize, usize)

GT-INT [INT@SRC1] [INT@SRC2] [DEST]

Similar to LT-INT but yields inverted result.

Tuple Fields of GtInt

0: usize1: usize2: usize
GtFloat(usize, usize, usize)

GT-FLOAT [SRC1] [SRC2] [DEST]

Similar to LT-FLOAT but yields inverted result.

Tuple Fields of GtFloat

0: usize1: usize2: usize
GtAny(usize, usize, usize)

GT-ANY [SRC1] [SRC2] [DEST]

Similar to LT-ANY but yields inverted result.

Tuple Fields of GtAny

0: usize1: usize2: usize
LeInt(usize, usize, usize)

LE-INT [INT@SRC1] [INT@SRC2] [DEST]

Check if integer in register SRC1 is less than or equal to integer in register SRC2, put the boolean result to DEST. No type checking.

Tuple Fields of LeInt

0: usize1: usize2: usize
LeFloat(usize, usize, usize)

LE-FLOAT [SRC1] [SRC2] [DEST]

Check if float in register SRC1 is less than or equal to float in register SRC2, put the boolean result to DEST. No type checking.

Tuple Fields of LeFloat

0: usize1: usize2: usize
LeAny(usize, usize, usize)

LE-ANY [SRC1] [SRC2] [DEST]

Load numbers in register SRC1 and SRC2, check types at run time and perform appropriate less-than-or-equal-to comparison accordingly, and put result to register DEST.

Tuple Fields of LeAny

0: usize1: usize2: usize
GeInt(usize, usize, usize)

GE-INT [INT@SRC1] [INT@SRC2] [DEST]

Similar to LE-INT but yields inverted result.

Tuple Fields of GeInt

0: usize1: usize2: usize
GeFloat(usize, usize, usize)

GE-FLOAT [SRC1] [SRC2] [DEST]

Similar to LE-FLOAT but yields inverted result.

Tuple Fields of GeFloat

0: usize1: usize2: usize
GeAny(usize, usize, usize)

GE-ANY [SRC1] [SRC2] [DEST]

Similar to LE-ANY but yields inverted result.

Tuple Fields of GeAny

0: usize1: usize2: usize
BAndInt(usize, usize, usize)

BITAND-INT [INT@SRC1] [INT@SRC2] [DEST]

Bit-and integers in register SRC1 and SRC2, put result to register DEST. No type checking.

Tuple Fields of BAndInt

0: usize1: usize2: usize
BAndAny(usize, usize, usize)

BITAND-ANY [SRC1] [SRC2] [DEST]

Check data in both SRC1 and SRC2 to be integer, perform integer bit-and operation, and put result to register DEST.

Tuple Fields of BAndAny

0: usize1: usize2: usize
BOrInt(usize, usize, usize)

BITOR-INT [INT@SRC1] [INT@SRC2] [DEST]

Bit-or integers in register SRC1 and SRC2, put result to register DEST. No type checking.

Tuple Fields of BOrInt

0: usize1: usize2: usize
BOrAny(usize, usize, usize)

BITOR-ANY [SRC1] [SRC2] [DEST]

Check data in both SRC1 and SRC2 to be integer, perform integer bit-or operation, and put result to register DEST.

Tuple Fields of BOrAny

0: usize1: usize2: usize
BXorInt(usize, usize, usize)

BITXOR-INT [INT@SRC1] [INT@SRC2] [DEST]

Bit-xor integers in register SRC1 and SRC2, put result to register DEST. No type checking.

Tuple Fields of BXorInt

0: usize1: usize2: usize
BXorAny(usize, usize, usize)

BITXOR-ANY [SRC1] [SRC2] [DEST]

Check data in both SRC1 and SRC2 to be integer, perform integer bit-xor operation, and put result to register DEST.

Tuple Fields of BXorAny

0: usize1: usize2: usize
BNotInt(usize, usize)

BITNOT-INT [SRC] [DEST]

Bit-not integer in register SRC, put the result to register DEST. No type checking.

Tuple Fields of BNotInt

0: usize1: usize
BNotAny(usize, usize)

BITNOT-ANY [SRC] [DEST]

Check data in SRC to be integer, perform integer bit-not operation, and put result to register DEST

Tuple Fields of BNotAny

0: usize1: usize
NegInt(usize, usize)

NEG-INT [SRC] [DEST]

Negate the integer in register SRC, put the result to register DEST, No type checking.

Tuple Fields of NegInt

0: usize1: usize
NegFloat(usize, usize)

NEG-FLOAT [SRC] [DEST]

Negate the float in register SRC, put the result to register DEST. No type checking.

Tuple Fields of NegFloat

0: usize1: usize
NegAny(usize, usize)

NEG-ANY [SRC] [DEST]

Check data in SRC to be integer, negate the integer and put the result into register DEST.

Tuple Fields of NegAny

0: usize1: usize
AndBool(usize, usize, usize)

AND-BOOL [SRC1] [SRC2] [DEST]

Logic-and booleans in registers SRC1 and SRC2, put result into register DEST. No type checking.

Tuple Fields of AndBool

0: usize1: usize2: usize
AndAny(usize, usize, usize)

AND-ANY [SRC1] [SRC2] [DEST]

Check data in both SRC1 and SRC2 to be boolean, perform boolean logic-and operation, and put result to register DEST.

Tuple Fields of AndAny

0: usize1: usize2: usize
OrBool(usize, usize, usize)

OR-BOOL [SRC1] [SRC2] [DEST]

Logic-or booleans in registers SRC1 and SRC2, put result into register DEST. No type checking.

Tuple Fields of OrBool

0: usize1: usize2: usize
OrAny(usize, usize, usize)

OR-ANY [SRC1] [SRC2] [DEST]

Check data in both SRC1 and SRC2 to be boolean, perform boolean logic-or operation, and put result to register DEST.

Tuple Fields of OrAny

0: usize1: usize2: usize
NotBool(usize, usize)

NOT-BOOL [SRC] [DEST]

Logic negate the float in register SRC, put the result to register DEST. No type checking.

Tuple Fields of NotBool

0: usize1: usize
NotAny(usize, usize)

NOT-ANY [SRC] [DEST]

Check data in SRC to be boolean, perform boolean logic negate operation, and put result to register DEST.

Tuple Fields of NotAny

0: usize1: usize
ShlInt(usize, usize, usize)

SHL-INT [INT@SRC1] [INT@SRC2] [DEST]

Left shift the integer in register SRC1 with the integer in register SRC2, put result to register DEST, No type checking.

Tuple Fields of ShlInt

0: usize1: usize2: usize
ShlAny(usize, usize, usize)

SHL-ANY [SRC1] [SRC2] [DEST]

Check data in both SRC1 and SRC2 to be integer, perform the left-shift operation, and put result to register DEST.

Tuple Fields of ShlAny

0: usize1: usize2: usize
ShrInt(usize, usize, usize)

SHR-INT [INT@SRC1] [INT@SRC2] [DEST]

Right shift the integer in register SRC1 with the integer in register SRC2, put result to register DEST, No type checking.

Tuple Fields of ShrInt

0: usize1: usize2: usize
ShrAny(usize, usize, usize)

SHR-ANY [SRC1] [SRC2] [DEST]

Check data in both SRC1 and SRC2 to be integer, perform the right-shift operation, and put result to register DEST.

Tuple Fields of ShrAny

0: usize1: usize2: usize
MakeIntConst(i64, usize)

MAKE-INT-CONST [INT-LIT] [DEST]

Put the integer literal LIT to register DEST.

Tuple Fields of MakeIntConst

0: i641: usize
MakeFloatConst(f64, usize)

MAKE-FLOAT-CONST [FLOAT-LIT] [DEST]

Put the float literal LIT to register DEST.

Tuple Fields of MakeFloatConst

0: f641: usize
MakeCharConst(char, usize)

MAKE-CHAR-CONST [CHAR-LIT] [DEST]

Put the char literal LIT to register DEST.

Tuple Fields of MakeCharConst

0: char1: usize
MakeBoolConst(bool, usize)

MAKE-BOOL-CONST [BOOL-LIT] [DEST]

Put the boolean literal LIT to register DEST.

Tuple Fields of MakeBoolConst

0: bool1: usize
MakeNull(usize)

MAKE-NULL [DEST]

Put a null literal to register DEST.

Tuple Fields of MakeNull

0: usize
LoadConst(usize, usize)

LOAD-CONST [CONST-ID] [DEST]

Load constant CONST-ID from constant pool, and put it to register DEST.

Tuple Fields of LoadConst

0: usize1: usize
SaveConst(usize, usize)

SAVE-CONST [CONST] [CONST-ID]

Save the value in register CONST to constant pool location CONST-ID. Using this instruction outside the initialization stage is a logical error. Compiler should not generate codes in such a way.

Tuple Fields of SaveConst

0: usize1: usize
CastFloatInt(usize, usize)

CAST-FLOAT-INT [FLOAT@SRC] [DEST]

Convert the float in SRC to integer, put the result to register DEST. No type checking.

Tuple Fields of CastFloatInt

0: usize1: usize
CastBoolInt(usize, usize)

CAST-BOOL-INT [BOOL@SRC] [DEST]

Convert the boolean value in SRC to integer, put the result into register DEST. No type checking.

Tuple Fields of CastBoolInt

0: usize1: usize
CastAnyInt(usize, usize)

CAST-ANY-INT [SRC] [DEST]

Tuple Fields of CastAnyInt

0: usize1: usize
CastIntFloat(usize, usize)

Tuple Fields of CastIntFloat

0: usize1: usize
CastAnyFloat(usize, usize)

Tuple Fields of CastAnyFloat

0: usize1: usize
CastAnyChar(usize, usize)

Tuple Fields of CastAnyChar

0: usize1: usize
CastIntBool(usize, usize)

Tuple Fields of CastIntBool

0: usize1: usize
CastAnyBool(usize, usize)

Tuple Fields of CastAnyBool

0: usize1: usize
IsNull(usize, usize)

IS-NULL [SRC] [DEST]

Check if data stored in SRC is null, and save the boolean result to DEST.

Tuple Fields of IsNull

0: usize1: usize
NullCheck(usize)

NULL-CHECK [SRC]

Similar to IS-NULL, but throws null pointer exception instead

Tuple Fields of NullCheck

0: usize
TypeCheck(usize, NonNull<TyckInfo>)

TYCK [SRC] [TYCK-INFO]

Check if data stored SRC satisfies TYCK-INFO, throws type checking exception if not.

Tuple Fields of TypeCheck

0: usize1: NonNull<TyckInfo>

CALL-UNCHECKED [FUNC-ID] [ARGS..] [RETS..]

Call the function denoted by FUNC-ID with given ARGS, store the return values to RETS. No type checking.

Tuple Fields of Call

0: usize1: Box<[usize]>2: Box<[usize]>
CallPtr(usize, Box<[usize]>, Box<[usize]>)

CALL-PTR [SRC] [ARGS..] [RETS..]

Call the function stored in function pointer SRC with given ARGS, store the return values to RETS. No type checking.

Tuple Fields of CallPtr

0: usize1: Box<[usize]>2: Box<[usize]>
CallOverload(usize, Box<[usize]>, Box<[usize]>)

CALL-OVERLOAD [OVERLOAD-TBL] [ARGS..] [RETS..]

Tuple Fields of CallOverload

0: usize1: Box<[usize]>2: Box<[usize]>
ReturnNothing

RETURN-NOTHING

ReturnOne(usize)

RETURN-ONE [RETURN-VALUE-LOC]

Tuple Fields of ReturnOne

0: usize
Return(Box<[usize]>)

RETURN [RETURN-VALUE-LOCS...]

Tuple Fields of Return

0: Box<[usize]>
FFICallRtlc(usize, Box<[usize]>, Box<[usize]>)

FFI-CALL-RTLC [FFI-FUNC-ID] [ARGS..] [RETS..]

Tuple Fields of FFICallRtlc

0: usize1: Box<[usize]>2: Box<[usize]>
FFICall(usize, Box<[usize]>, Box<[usize]>)

FFI-CALL [FFI-FUNC-ID] [ARGS..] [RETS..]

Tuple Fields of FFICall

0: usize1: Box<[usize]>2: Box<[usize]>
FFICallAsync(usize, Box<[usize]>, usize)

FFI-CALL-ASYNC [FUNC-ID] [ARGS..] [RET]

Call the async function denoted by FUNC-ID with given ARGS, store the returned promise to RET. No type checking. Please note that when feature optimized-rtlc is enabled, all async FFI calls have RTLC.

Tuple Fields of FFICallAsync

0: usize1: Box<[usize]>2: usize
Await(usize, Box<[usize]>)

AWAIT [FUT] [RETS..]

Await the given promise, store its results into given destinations.

Tuple Fields of Await

0: usize1: Box<[usize]>
Raise(usize)

RAISE [EXCEPTION]

Tuple Fields of Raise

0: usize
JumpIfTrue(usize, usize)

Tuple Fields of JumpIfTrue

0: usize1: usize
JumpIfFalse(usize, usize)

Tuple Fields of JumpIfFalse

0: usize1: usize
Jump(usize)

Tuple Fields of Jump

0: usize
CreateString(usize)

Tuple Fields of CreateString

0: usize
CreateObject(usize)

Tuple Fields of CreateObject

0: usize

Tuple Fields of CreateContainer

0: GenericTypeCtor1: NonNull<GenericTypeVT>2: usize
VecIndex(usize, usize, usize)

Tuple Fields of VecIndex

0: usize1: usize2: usize
VecIndexPut(usize, usize, usize)

Tuple Fields of VecIndexPut

0: usize1: usize2: usize
VecInsert(usize, usize, usize)

Tuple Fields of VecInsert

0: usize1: usize2: usize
VecRemove(usize, usize, usize)

Tuple Fields of VecRemove

0: usize1: usize2: usize
VecLen(usize)

Tuple Fields of VecLen

0: usize
VecClear(usize)

Tuple Fields of VecClear

0: usize
DenseVecIndex(usize, usize, usize)

Tuple Fields of DenseVecIndex

0: usize1: usize2: usize
DenseVecIndexPut(usize, usize, usize)

Tuple Fields of DenseVecIndexPut

0: usize1: usize2: usize
DenseVecInsert(usize, usize, usize)

Tuple Fields of DenseVecInsert

0: usize1: usize2: usize
DenseVecRemove(usize, usize, usize)

Tuple Fields of DenseVecRemove

0: usize1: usize2: usize
DenseVecLen(usize)

Tuple Fields of DenseVecLen

0: usize
DenseVecClear(usize)

Tuple Fields of DenseVecClear

0: usize
StrConcat(usize, usize, usize)

Tuple Fields of StrConcat

0: usize1: usize2: usize
StrFormat(usize, Box<[usize]>, usize)

Tuple Fields of StrFormat

0: usize1: Box<[usize]>2: usize
StrLen(usize, usize)

Tuple Fields of StrLen

0: usize1: usize
StrSlice(usize, usize, usize, usize)

Tuple Fields of StrSlice

0: usize1: usize2: usize3: usize
StrEquals(usize, usize)

Tuple Fields of StrEquals

0: usize1: usize
ObjectGet(usize, NonNull<str>, usize)

Tuple Fields of ObjectGet

0: usize1: NonNull<str>2: usize
ObjectGetDyn(usize, usize, usize)

Tuple Fields of ObjectGetDyn

0: usize1: usize2: usize
ObjectPut(usize, NonNull<str>, usize)

Tuple Fields of ObjectPut

0: usize1: NonNull<str>2: usize
ObjectPutDyn(usize, usize, usize)

Tuple Fields of ObjectPutDyn

0: usize1: usize2: usize

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Performs the conversion.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.