Enum ArrayMethodCall 

pub enum ArrayMethodCall {
    Map {
        item_var: String,
        body: Box<ValueExpr>,
    },
    Filter {
        item_var: String,
        predicate: Box<ValueExpr>,
    },
    Find {
        item_var: String,
        predicate: Box<ValueExpr>,
    },
    Slice {
        start: usize,
        end: Option<usize>,
    },
    Length,
    Some {
        item_var: String,
        predicate: Box<ValueExpr>,
    },
    Every {
        item_var: String,
        predicate: Box<ValueExpr>,
    },
    Reduce {
        acc_var: String,
        item_var: String,
        body: Box<ValueExpr>,
        initial: Box<ValueExpr>,
    },
    Push {
        item: Box<ValueExpr>,
    },
    Concat {
        other: Box<ValueExpr>,
    },
    Includes {
        item: Box<ValueExpr>,
    },
    IndexOf {
        item: Box<ValueExpr>,
    },
    Join {
        separator: Option<String>,
    },
    Reverse,
    Sort {
        comparator: Option<(String, String, Box<ValueExpr>)>,
    },
    Flat,
    FlatMap {
        item_var: String,
        body: Box<ValueExpr>,
    },
    First,
    Last,
    ToLowerCase,
    ToUpperCase,
    StartsWith {
        search: Box<ValueExpr>,
    },
    EndsWith {
        search: Box<ValueExpr>,
    },
    Trim,
    Replace {
        search: Box<ValueExpr>,
        replacement: Box<ValueExpr>,
    },
    Split {
        separator: Box<ValueExpr>,
    },
    Substring {
        start: Box<ValueExpr>,
        end: Option<Box<ValueExpr>>,
    },
    ToString,
}

Array method calls.

Variants

Map

.map(x => expr)

Fields

item_var: String

body: Box<ValueExpr>

Filter

.filter(x => expr)

Fields

item_var: String

predicate: Box<ValueExpr>

Find

.find(x => expr)

Fields

item_var: String

predicate: Box<ValueExpr>

Slice

.slice(start, end)

Fields

start: usize

end: Option<usize>

Length

.length

Some

.some(x => expr)

Fields

item_var: String

predicate: Box<ValueExpr>

Every

.every(x => expr)

Fields

item_var: String

predicate: Box<ValueExpr>

Reduce

.reduce((acc, x) => expr, init)

Fields

acc_var: String

item_var: String

body: Box<ValueExpr>

initial: Box<ValueExpr>

Push

.push(item) - returns new array (pure)

Fields

item: Box<ValueExpr>

Concat

.concat(other)

Fields

other: Box<ValueExpr>

Includes

.includes(item)

Fields

item: Box<ValueExpr>

IndexOf

.indexOf(item)

Fields

item: Box<ValueExpr>

Join

.join(separator)

Fields

separator: Option<String>

Reverse

.reverse() - returns new array (pure)

Sort

.sort() or .sort((a, b) => expr) - returns new array (pure)

Fields

comparator: Option<(String, String, Box<ValueExpr>)>

Flat

.flat() - flatten nested arrays

FlatMap

.flatMap(x => expr)

Fields

item_var: String

body: Box<ValueExpr>

First

Get first element: [0] or .at(0)

Last

Get last element: .at(-1)

ToLowerCase

.toLowerCase() (string-only)

ToUpperCase

.toUpperCase() (string-only)

StartsWith

.startsWith(searchString)

Fields

search: Box<ValueExpr>

EndsWith

.endsWith(searchString)

Fields

search: Box<ValueExpr>

Trim

.trim()

Replace

.replace(search, replacement) — first occurrence only

Fields

search: Box<ValueExpr>

replacement: Box<ValueExpr>

Split

.split(separator)

Fields

separator: Box<ValueExpr>

Substring

.substring(start, end?)

Fields

start: Box<ValueExpr>

end: Option<Box<ValueExpr>>

ToString

.toString() — works on strings (identity), numbers, arrays, objects

Trait Implementations

impl Clone for ArrayMethodCall

fn clone(&self) -> ArrayMethodCall

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ArrayMethodCall

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

Formats the value using the given formatter.

impl Serialize for ArrayMethodCall

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.