Enum dmntk_feel::FeelType

pub enum FeelType {
    Any,
    Boolean,
    Context(BTreeMap<Name, FeelType>),
    Date,
    DateTime,
    DaysAndTimeDuration,
    Function(Vec<FeelType>, Box<FeelType>),
    List(Box<FeelType>),
    Null,
    Number,
    Range(Box<FeelType>),
    String,
    Time,
    YearsAndMonthsDuration,
}

Variants

Any

Type representing any valid FEEL type.

Boolean

Type representing a boolean value.

Context(BTreeMap<Name, FeelType>)

Tuple Fields

0: BTreeMap<Name, FeelType>

Types of context entries.

Type representing a context value.

Date

Type representing a date value.

DateTime

Type representing adate and time value.

DaysAndTimeDuration

Type representing a days and time duration value.

Function(Vec<FeelType>, Box<FeelType>)

Tuple Fields

0: Vec<FeelType>

List of types of the function’s parameters.

1: Box<FeelType>

Type of the function’s result.

Type representing a function value.

List(Box<FeelType>)

Type representing a list of values.

Null

Type representing a null value.

Number

Type representing a number value.

Range(Box<FeelType>)

Type representing a range values.

String

Type representing a string value.

Time

Type representing a time value.

YearsAndMonthsDuration

Type representing a years and months duration value.

Implementations

impl FeelType

pub fn coerced(&self, actual_value: &Value) -> Value

When a value appears in a certain context, it must be compatible with a type expected in that context, called the target type. After the type of the value is known, an implicit conversion from the type of the value to the target type can be performed. If an implicit conversion is mandatory but it cannot be performed, the result is null.

There are several possible type conversions:

• to singleton list:

  When the type of the value is T and the target type is List<T>, the simple value is converted to a singleton list.

• from singleton list:

  When the type of the value is List, and the value is a singleton list and the target type is T, the value is converted by unwrapping the first element.

• conforms to:

  When the type of the value is T1, the target type is T2, and T1 conforms to T2, the value remains unchanged. Otherwise the result is null.

All these conversion rules are implemented in this function.

pub fn get_conformant_value(&self, actual_value: &Value) -> Value

pub fn get_value_checked(&self, value: &Value) -> Result<Value>

Returns a new value cloned from provided value, and retrieved with type checking.

pub fn is_simple_built_in_type(&self) -> bool

Returns true when this type is a simple FEEL type.

pub fn list(items_type: &FeelType) -> FeelType

Creates a list type with specified items’ type.

pub fn range(elements_type: &FeelType) -> FeelType

Creates a range type with specified elements’ type.

pub fn context(entries_types: &[(&Name, &FeelType)]) -> FeelType

Creates a context type with specified entries.

pub fn function(
    parameter_types: &[FeelType],
    result_type: &FeelType
) -> FeelType

Creates a function type with specified parameter types and result type.

pub fn zip(&self, other: &FeelType) -> Self

pub fn is_equivalent(&self, other: &FeelType) -> bool

pub fn is_conformant(&self, other: &FeelType) -> bool

Trait Implementations

impl Clone for FeelType

fn clone(&self) -> FeelType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for FeelType

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

Formats the value using the given formatter.

impl Display for FeelType

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

Formats the value using the given formatter.

impl From<&'_ Name> for FeelType

fn from(name: &Name) -> Self

Converts a FEEL name to built-in type.

impl FromStr for FeelType

fn from_str(s: &str) -> Result<Self, Self::Err>

Converts a string to built-in type.

type Err = DmntkError

The associated error which can be returned from parsing.

impl PartialEq<FeelType> for FeelType

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

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

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

This method tests for !=.

impl StructuralPartialEq for FeelType