Enum nu_protocol::SyntaxShape

pub enum SyntaxShape {
    Any,
    Binary,
    Block,
    Boolean,
    CellPath,
    Closure(Option<Vec<SyntaxShape>>),
    CompleterWrapper(Box<SyntaxShape>, DeclId),
    DateTime,
    Directory,
    Duration,
    Error,
    Expression,
    Filepath,
    Filesize,
    Float,
    FullCellPath,
    GlobPattern,
    Int,
    ImportPattern,
    Keyword(Vec<u8>, Box<SyntaxShape>),
    List(Box<SyntaxShape>),
    MathExpression,
    MatchBlock,
    Nothing,
    Number,
    OneOf(Vec<SyntaxShape>),
    Operator,
    Range,
    Record(Vec<(String, SyntaxShape)>),
    RowCondition,
    Signature,
    String,
    Table(Vec<(String, SyntaxShape)>),
    VarWithOptType,
}

The syntactic shapes that describe how a sequence should be parsed.

This extends beyond Type which describes how Values are represented. SyntaxShapes can describe the parsing rules for arguments to a command. e.g. SyntaxShape::GlobPattern/SyntaxShape::Filepath serve the completer, but don’t have an associated Value There are additional SyntaxShapes that only make sense in particular expressions or keywords

Variants

Any

Any syntactic form is allowed

Binary

A binary literal

Block

A block is allowed, eg {start this thing}

Boolean

A boolean value, eg true or false

CellPath

A dotted path to navigate the table

Closure(Option<Vec<SyntaxShape>>)

A closure is allowed, eg {|| start this thing}

CompleterWrapper(Box<SyntaxShape>, DeclId)

A SyntaxShape with custom completion logic

DateTime

A datetime value, eg 2022-02-02 or 2019-10-12T07:20:50.52+00:00

Directory

A directory is allowed

Duration

A duration value is allowed, eg 19day

Error

An error value

Expression

A general expression, eg 1 + 2 or foo --bar

Filepath

A filepath is allowed

Filesize

A filesize value is allowed, eg 10kb

Float

A floating point value, eg 1.0

FullCellPath

A dotted path including the variable to access items

Fully qualified

GlobPattern

A glob pattern is allowed, eg foo*

Int

Only an integer value is allowed

ImportPattern

A module path pattern used for imports

Keyword(Vec<u8>, Box<SyntaxShape>)

A specific match to a word or symbol

List(Box<SyntaxShape>)

A list is allowed, eg [first second]

MathExpression

A general math expression, eg 1 + 2

MatchBlock

A block of matches, used by match

Nothing

Nothing

Number

Only a numeric (integer or float) value is allowed

OneOf(Vec<SyntaxShape>)

One of a list of possible items, checked in order

Operator

An operator, eg +

Range

A range is allowed (eg, 1..3)

Record(Vec<(String, SyntaxShape)>)

A record value, eg {x: 1, y: 2}

RowCondition

A math expression which expands shorthand forms on the lefthand side, eg foo > 1 The shorthand allows us to more easily reach columns inside of the row being passed in

Signature

A signature for a definition, [x:int, --foo]

String

Strings and string-like bare words are allowed

Table(Vec<(String, SyntaxShape)>)

A table is allowed, eg [[first, second]; [1, 2]]

VarWithOptType

A variable with optional type, x or x: int

Implementations

impl SyntaxShape

pub fn to_type(&self) -> Type

If possible provide the associated concrete Type

Note: Some SyntaxShapes don’t have a corresponding Value Here we currently return Type::Any

use nu_protocol::{SyntaxShape, Type};
let non_value = SyntaxShape::ImportPattern;
assert_eq!(non_value.to_type(), Type::Any);

Trait Implementations

impl Clone for SyntaxShape

fn clone(&self) -> SyntaxShape

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SyntaxShape

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SyntaxShape

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SyntaxShape

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

Formats the value using the given formatter.

impl PartialEq for SyntaxShape

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for SyntaxShape

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for SyntaxShape

impl StructuralPartialEq for SyntaxShape