Enum Value

pub enum Value {
    Bool {
        val: bool,
        internal_span: Span,
    },
    Int {
        val: i64,
        internal_span: Span,
    },
    Float {
        val: f64,
        internal_span: Span,
    },
    String {
        val: String,
        internal_span: Span,
    },
    Glob {
        val: String,
        no_expand: bool,
        internal_span: Span,
    },
    Filesize {
        val: i64,
        internal_span: Span,
    },
    Duration {
        val: i64,
        internal_span: Span,
    },
    Date {
        val: DateTime<FixedOffset>,
        internal_span: Span,
    },
    Range {
        val: Box<Range>,
        internal_span: Span,
    },
    Record {
        val: SharedCow<Record>,
        internal_span: Span,
    },
    List {
        vals: Vec<Value>,
        internal_span: Span,
    },
    Closure {
        val: Box<Closure>,
        internal_span: Span,
    },
    Error {
        error: Box<ShellError>,
        internal_span: Span,
    },
    Binary {
        val: Vec<u8>,
        internal_span: Span,
    },
    CellPath {
        val: CellPath,
        internal_span: Span,
    },
    Custom {
        val: Box<dyn CustomValue>,
        internal_span: Span,
    },
    Nothing {
        internal_span: Span,
    },
}

Core structured values that pass through the pipeline in Nushell.

Variants

Bool

Fields

val: bool

internal_span: Span

Int

Fields

val: i64

internal_span: Span

Float

Fields

val: f64

internal_span: Span

String

Fields

val: String

internal_span: Span

Glob

Fields

val: String

no_expand: bool

internal_span: Span

Filesize

Fields

val: i64

internal_span: Span

Duration

Fields

val: i64

internal_span: Span

Date

Fields

val: DateTime<FixedOffset>

internal_span: Span

Range

Fields

val: Box<Range>

internal_span: Span

Record

Fields

val: SharedCow<Record>

internal_span: Span

List

Fields

vals: Vec<Value>

internal_span: Span

Closure

Fields

val: Box<Closure>

internal_span: Span

Error

Fields

error: Box<ShellError>

internal_span: Span

Binary

Fields

val: Vec<u8>

internal_span: Span

CellPath

Fields

val: CellPath

internal_span: Span

Custom

Fields

val: Box<dyn CustomValue>

internal_span: Span

Nothing

Fields

internal_span: Span

Implementations

impl Value

pub fn as_bool(&self) -> Result<bool, ShellError>

Returns the inner bool value or an error if this Value is not a bool

pub fn as_int(&self) -> Result<i64, ShellError>

Returns the inner i64 value or an error if this Value is not an int

pub fn as_float(&self) -> Result<f64, ShellError>

Returns the inner f64 value or an error if this Value is not a float

pub fn coerce_float(&self) -> Result<f64, ShellError>

Returns this Value converted to a f64 or an error if it cannot be converted

Only the following Value cases will return an Ok result:

• Int
• Float

for val in Value::test_values() {
    assert_eq!(
        matches!(val, Value::Float { .. } | Value::Int { .. }),
        val.coerce_float().is_ok(),
    );
}

pub fn as_filesize(&self) -> Result<i64, ShellError>

Returns the inner i64 filesize value or an error if this Value is not a filesize

pub fn as_duration(&self) -> Result<i64, ShellError>

Returns the inner i64 duration value or an error if this Value is not a duration

pub fn as_date(&self) -> Result<DateTime<FixedOffset>, ShellError>

Returns the inner DateTime value or an error if this Value is not a date

pub fn as_range(&self) -> Result<Range, ShellError>

Returns a reference to the inner Range value or an error if this Value is not a range

pub fn into_range(self) -> Result<Range, ShellError>

Unwraps the inner Range value or returns an error if this Value is not a range

pub fn as_str(&self) -> Result<&str, ShellError>

Returns a reference to the inner str value or an error if this Value is not a string

pub fn into_string(self) -> Result<String, ShellError>

Unwraps the inner String value or returns an error if this Value is not a string

pub fn coerce_str(&self) -> Result<Cow<'_, str>, ShellError>

Returns this Value converted to a str or an error if it cannot be converted

Only the following Value cases will return an Ok result:

• Int
• Float
• String
• Glob
• Binary (only if valid utf-8)
• Date

for val in Value::test_values() {
    assert_eq!(
        matches!(
            val,
            Value::Int { .. }
                | Value::Float { .. }
                | Value::String { .. }
                | Value::Glob { .. }
                | Value::Binary { .. }
                | Value::Date { .. }
        ),
        val.coerce_str().is_ok(),
    );
}

pub fn coerce_string(&self) -> Result<String, ShellError>

Returns this Value converted to a String or an error if it cannot be converted

Note

This function is equivalent to value.coerce_str().map(Cow::into_owned) which might allocate a new String.

To avoid this allocation, prefer coerce_str if you do not need an owned String, or coerce_into_string if you do not need to keep the original Value around.

Only the following Value cases will return an Ok result:

• Int
• Float
• String
• Glob
• Binary (only if valid utf-8)
• Date

for val in Value::test_values() {
    assert_eq!(
        matches!(
            val,
            Value::Int { .. }
                | Value::Float { .. }
                | Value::String { .. }
                | Value::Glob { .. }
                | Value::Binary { .. }
                | Value::Date { .. }
        ),
        val.coerce_string().is_ok(),
    );
}

pub fn coerce_into_string(self) -> Result<String, ShellError>

Returns this Value converted to a String or an error if it cannot be converted

Only the following Value cases will return an Ok result:

• Int
• Float
• String
• Glob
• Binary (only if valid utf-8)
• Date

for val in Value::test_values() {
    assert_eq!(
        matches!(
            val,
            Value::Int { .. }
                | Value::Float { .. }
                | Value::String { .. }
                | Value::Glob { .. }
                | Value::Binary { .. }
                | Value::Date { .. }
        ),
        val.coerce_into_string().is_ok(),
    );
}

pub fn as_char(&self) -> Result<char, ShellError>

Returns this Value as a char or an error if it is not a single character string

pub fn to_path(&self) -> Result<PathBuf, ShellError>

Converts this Value to a PathBuf or returns an error if it is not a string

pub fn as_record(&self) -> Result<&Record, ShellError>

Returns a reference to the inner Record value or an error if this Value is not a record

pub fn into_record(self) -> Result<Record, ShellError>

Unwraps the inner Record value or returns an error if this Value is not a record

pub fn as_list(&self) -> Result<&[Value], ShellError>

Returns a reference to the inner list slice or an error if this Value is not a list

pub fn into_list(self) -> Result<Vec<Value>, ShellError>

Unwraps the inner list Vec or returns an error if this Value is not a list

pub fn as_closure(&self) -> Result<&Closure, ShellError>

Returns a reference to the inner Closure value or an error if this Value is not a closure

pub fn into_closure(self) -> Result<Closure, ShellError>

Unwraps the inner Closure value or returns an error if this Value is not a closure

pub fn as_binary(&self) -> Result<&[u8], ShellError>

Returns a reference to the inner binary slice or an error if this Value is not a binary value

pub fn into_binary(self) -> Result<Vec<u8>, ShellError>

Unwraps the inner binary Vec or returns an error if this Value is not a binary value

pub fn coerce_binary(&self) -> Result<&[u8], ShellError>

Returns this Value as a u8 slice or an error if it cannot be converted

Prefer coerce_into_binary if you do not need to keep the original Value around.

Only the following Value cases will return an Ok result:

• Binary
• String

for val in Value::test_values() {
    assert_eq!(
        matches!(val, Value::Binary { .. } | Value::String { .. }),
        val.coerce_binary().is_ok(),
    );
}

pub fn coerce_into_binary(self) -> Result<Vec<u8>, ShellError>

Returns this Value as a Vec<u8> or an error if it cannot be converted

Only the following Value cases will return an Ok result:

• Binary
• String

for val in Value::test_values() {
    assert_eq!(
        matches!(val, Value::Binary { .. } | Value::String { .. }),
        val.coerce_into_binary().is_ok(),
    );
}

pub fn as_cell_path(&self) -> Result<&CellPath, ShellError>

Returns a reference to the inner CellPath value or an error if this Value is not a cell path

pub fn into_cell_path(self) -> Result<CellPath, ShellError>

Unwraps the inner CellPath value or returns an error if this Value is not a cell path

pub fn as_custom_value(&self) -> Result<&dyn CustomValue, ShellError>

Returns a reference to the inner CustomValue trait object or an error if this Value is not a custom value

pub fn into_custom_value(self) -> Result<Box<dyn CustomValue>, ShellError>

Unwraps the inner CustomValue trait object or returns an error if this Value is not a custom value

pub fn span(&self) -> Span

Get the span for the current value

pub fn set_span(&mut self, new_span: Span)

Set the value’s span to a new span

pub fn with_span(self, new_span: Span) -> Value

Update the value with a new span

pub fn get_type(&self) -> Type

Get the type of the current Value

pub fn get_data_by_key(&self, name: &str) -> Option<Value>

pub fn to_expanded_string(&self, separator: &str, config: &Config) -> String

Converts this Value to a string according to the given Config and separator

This functions recurses into records and lists, returning a string that contains the stringified form of all nested Values.

pub fn to_abbreviated_string(&self, config: &Config) -> String

Converts this Value to a string according to the given Config

This functions does not recurse into records and lists. Instead, it will shorten the first list or record it finds like so:

• “[table {n} rows]”
• “[list {n} items]”
• “[record {n} fields]”

pub fn to_parsable_string(&self, separator: &str, config: &Config) -> String

Converts this Value to a string according to the given Config and separator

This function adds quotes around strings, so that the returned string can be parsed by nushell. The other Value cases are already parsable when converted strings or are not yet handled by this function.

This functions behaves like to_expanded_string and will recurse into records and lists.

pub fn to_debug_string(&self) -> String

Convert this Value to a debug string

In general, this function should only be used for debug purposes, and the resulting string should not be displayed to the user (not even in an error).

pub fn follow_cell_path( self, cell_path: &[PathMember], insensitive: bool, ) -> Result<Value, ShellError>

Follow a given cell path into the value: for example accessing select elements in a stream or list

pub fn upsert_cell_path( &mut self, cell_path: &[PathMember], callback: Box<dyn FnOnce(&Value) -> Value>, ) -> Result<(), ShellError>

Follow a given cell path into the value: for example accessing select elements in a stream or list

pub fn upsert_data_at_cell_path( &mut self, cell_path: &[PathMember], new_val: Value, ) -> Result<(), ShellError>

pub fn update_cell_path<'a>( &mut self, cell_path: &[PathMember], callback: Box<dyn FnOnce(&Value) -> Value + 'a>, ) -> Result<(), ShellError>

Follow a given cell path into the value: for example accessing select elements in a stream or list

pub fn update_data_at_cell_path( &mut self, cell_path: &[PathMember], new_val: Value, ) -> Result<(), ShellError>

pub fn remove_data_at_cell_path( &mut self, cell_path: &[PathMember], ) -> Result<(), ShellError>

pub fn insert_data_at_cell_path( &mut self, cell_path: &[PathMember], new_val: Value, head_span: Span, ) -> Result<(), ShellError>

pub fn recurse_mut<E>( &mut self, f: &mut impl FnMut(&mut Value) -> Result<(), E>, ) -> Result<(), E>

Visits all values contained within the value (including this value) with a mutable reference given to the closure.

If the closure returns Err, the traversal will stop.

Captures of closure values are currently visited, as they are values owned by the closure.

pub fn is_empty(&self) -> bool

Check if the content is empty

pub fn is_nothing(&self) -> bool

pub fn is_error(&self) -> bool

pub fn is_true(&self) -> bool

pub fn is_false(&self) -> bool

pub fn columns(&self) -> impl Iterator<Item = &String>

pub fn bool(val: bool, span: Span) -> Value

pub fn int(val: i64, span: Span) -> Value

pub fn float(val: f64, span: Span) -> Value

pub fn filesize(val: i64, span: Span) -> Value

pub fn duration(val: i64, span: Span) -> Value

pub fn date(val: DateTime<FixedOffset>, span: Span) -> Value

pub fn range(val: Range, span: Span) -> Value

pub fn string(val: impl Into<String>, span: Span) -> Value

pub fn glob(val: impl Into<String>, no_expand: bool, span: Span) -> Value

pub fn record(val: Record, span: Span) -> Value

pub fn list(vals: Vec<Value>, span: Span) -> Value

pub fn closure(val: Closure, span: Span) -> Value

pub fn nothing(span: Span) -> Value

Create a new Nothing value

pub fn error(error: ShellError, span: Span) -> Value

pub fn binary(val: impl Into<Vec<u8>>, span: Span) -> Value

pub fn cell_path(val: CellPath, span: Span) -> Value

pub fn custom(val: Box<dyn CustomValue>, span: Span) -> Value

pub fn test_bool(val: bool) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_int(val: i64) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_float(val: f64) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_filesize(val: i64) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_duration(val: i64) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_date(val: DateTime<FixedOffset>) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_range(val: Range) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_string(val: impl Into<String>) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_glob(val: impl Into<String>) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_record(val: Record) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_list(vals: Vec<Value>) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_closure(val: Closure) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_nothing() -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_binary(val: impl Into<Vec<u8>>) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_cell_path(val: CellPath) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_custom_value(val: Box<dyn CustomValue>) -> Value

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

pub fn test_values() -> Vec<Value>

Note: Only use this for test data, not live data, as it will point into unknown source when used in errors.

Returns a Vec containing one of each value case (Value::Int, Value::String, etc.) except for Value::CustomValue.

impl Value

pub fn add( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn append( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn sub( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn mul( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn div( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn modulo( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn floor_div( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn lt(&self, op: Span, rhs: &Value, span: Span) -> Result<Value, ShellError>

pub fn lte( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn gt(&self, op: Span, rhs: &Value, span: Span) -> Result<Value, ShellError>

pub fn gte( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn eq(&self, op: Span, rhs: &Value, span: Span) -> Result<Value, ShellError>

pub fn ne(&self, op: Span, rhs: &Value, span: Span) -> Result<Value, ShellError>

pub fn in(&self, op: Span, rhs: &Value, span: Span) -> Result<Value, ShellError>

pub fn not_in( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn regex_match( &self, engine_state: &EngineState, op: Span, rhs: &Value, invert: bool, span: Span, ) -> Result<Value, ShellError>

pub fn starts_with( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn ends_with( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn bit_shl( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn bit_shr( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn bit_or( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn bit_xor( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn bit_and( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn and( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn or(&self, op: Span, rhs: &Value, span: Span) -> Result<Value, ShellError>

pub fn xor( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

pub fn pow( &self, op: Span, rhs: &Value, span: Span, ) -> Result<Value, ShellError>

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl Default for Value

fn default() -> Value

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Value

fn deserialize<__D>( __deserializer: __D, ) -> Result<Value, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromValue for Value

fn from_value(v: Value) -> Result<Value, ShellError>

Loads a value from a Value.

fn expected_type() -> Type

Expected Value type.

impl IntoValue for Value

fn into_value(self, span: Span) -> Value

Converts the given value to a Value.

impl PartialEq for Value

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Value

fn partial_cmp(&self, other: &Value) -> 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 Serialize for Value

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

where __S: Serializer,

Serialize this value into the given Serde serializer.