Struct Array 

pub struct Array<A: IVm>(/* private fields */);

use nanvm_lib::{
    vm::{ToArray, IVm, Array, Any, Number, ToAny},
    common::{sized_index::SizedIndex, default::default},
    naive::Naive
};
fn array_test<A: IVm>() {
    let b: Array<A> = [Number::from(1.0).to_any(), true.to_any()].to_array();
    assert_eq!(b.length(), 2);
    assert_eq!(b[0], Number::from(1.0).to_any());
    assert_eq!(b[1], true.to_any());
    let b1: Array<A> = [Number::from(1.0).to_any(), true.to_any()].to_array();
    assert_eq!(b, b);
    assert_ne!(b, b1);
    let ac: Any<A> = b.clone().to_any();
    let d: Array<A> = ac.try_into().unwrap();
    assert_eq!(d, b);
    let e0: Array<A> = default();
    let e1: Array<A> = [].to_array();
    assert_ne!(e0, e1);
}

array_test::<Naive>();

Implementations

impl<A: IVm> Array<A>

pub fn argument(&self, i: u32) -> Any<A>

The i-th argument of a call whose arguments this array holds, or undefined past the end, as JavaScript binds a parameter the call left out. What a built-in and a compiled function’s body read their fixed arguments with: one bounds check and one clone, where Index<u32> panics past the end.

pub fn present(&self, i: u32) -> Option<Any<A>>

The i-th argument if the call passed one, undefined included, and None if it did not: for a reader whose answer depends on whether an argument is there, not only on its value — lastIndexOf(x) searches from the end, lastIndexOf(x, undefined) from 0, and an effect’s optional parameter is absent.

impl<A: IVm> Array<A>

pub fn rest(&self, i: u32) -> Array<A>

The arguments from the i-th on, as a rest parameter of a call whose arguments this array holds reads them: the array itself for i == 0, since nothing is skipped, and a new array of the items from i otherwise — empty when i is past the end.

The array is the call’s own: a call step builds it from the argument list, a spread iterated, so no program holds it but the callee, and answering it as the rest shares nothing a program can see (fjs/edag/README.md, “An engine may form the arguments the way the callee reads them”). A host calling Any::call with an array it keeps is handing the callee that array, and reads it back as the rest.

Trait Implementations

impl<A: Clone + IVm> Clone for Array<A>

where A::InternalArray: Clone,

fn clone(&self) -> Array<A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<A: IVm> Debug for Array<A>

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

Formats the value using the given formatter.

impl<A: IVm> Default for Array<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: IVm> From<Array<A>> for Unpacked<A>

fn from(value: Array<A>) -> Self

Converts to this type from the input type.

impl<A: IVm> Index<u32> for Array<A>

fn index(&self, index: u32) -> &Self::Output

Currently panics if out of bounds. TODO: Future versions may change to return Nullish::Undefined.

type Output = Any<A>

The returned type after indexing.

impl<A: IVm> IntoIterator for Array<A>

type Item = Any<A>

The type of the elements being iterated over.

type IntoIter = IndexIter<u32, Array<A>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<A: IVm> PartialEq for Array<A>

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

Equality operator ==.

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

Inequality operator !=.

impl<A: IVm> TryFrom<Any<A>> for Array<A>

type Error = Any<A>

The type returned in the event of a conversion error.

fn try_from(value: Any<A>) -> Result<Self, Self::Error>

Performs the conversion.

impl<A: IVm, const N: usize> TryFrom<Array<A>> for [Any<A>; N]

An array of exactly N items as a fixed-size Rust array, to destructure: let [tag, value]: [Any<A>; 2] = array.try_into()?. An array of any other length is handed back unchanged, as Vec’s conversion hands back the Vec.

type Error = Array<A>

The type returned in the event of a conversion error.

fn try_from(value: Array<A>) -> Result<Self, Self::Error>

Performs the conversion.