Struct starlark::values::function::NativeFunction

pub struct NativeFunction { /* private fields */ }

Starlark representation of native (Rust) functions.

Almost always created with #[starlark_module].

Implementations

impl NativeFunction

pub fn new_direct<F>(function: F, name: String) -> Self where
    F: for<'v> Fn(&mut Evaluator<'v, '_>, &Arguments<'v, '_>) -> Result<Value<'v>> + Send + Sync + 'static, 

Create a new NativeFunction from the Rust function which works directly on the parameters. The called function is responsible for validating the parameters are correct.

pub fn new<F>(
    function: F,
    name: String,
    parameters: ParametersSpec<FrozenValue>
) -> Self where
    F: for<'v> Fn(&mut Evaluator<'v, '_>, ParametersParser<'v, '_>) -> Result<Value<'v>> + Send + Sync + 'static, 

Create a new NativeFunction from the Rust function, plus the parameter specification.

pub fn set_type(&mut self, typ: FrozenValue)

A .type value, if one exists. Specified using #[starlark(type("the_type"))].

Trait Implementations

impl AllocFrozenValue for NativeFunction

fn alloc_frozen_value(self, heap: &FrozenHeap) -> FrozenValue

Allocate a value in the frozen heap and return a reference to the allocated value.

impl<'v> AllocValue<'v> for NativeFunction

fn alloc_value(self, heap: &'v Heap) -> Value<'v>

Allocate the value on a heap and return a reference to the allocated value.

impl Debug for NativeFunction

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

Formats the value using the given formatter.

impl Display for NativeFunction

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

Formats the value using the given formatter.

impl ProvidesStaticType for NativeFunction

type StaticType = NativeFunction

Same type as Self but with lifetimes dropped to 'static.

impl<'v> Serialize for NativeFunction where
    Self: StarlarkValue<'v>, 

fn serialize<__NoSerializeS>(
    &self,
    serializer: __NoSerializeS
) -> Result<__NoSerializeS::Ok, __NoSerializeS::Error> where
    __NoSerializeS: Serializer, 

Serialize this value into the given Serde serializer.

impl<'v> StarlarkValue<'v> for NativeFunction

Define the function type

fn get_type(&self) -> &'static str

Return a string describing the type of self, as returned by the type() function.

fn get_type_value_static() -> FrozenStringValue

Like get_type, but returns a reusable FrozenStringValue pointer to it. This function deliberately doesn’t take a heap, as it would not be performant to allocate a new value each time.

fn invoke(
    &self,
    _me: Value<'v>,
    args: &Arguments<'v, '_>,
    eval: &mut Evaluator<'v, '_>
) -> Result<Value<'v>>

Directly invoke a function. The number of named and names arguments are guaranteed to be equal.

fn extra_memory(&self) -> usize

Return how much extra memory is consumed by this data type, in bytes, in addition to the direct size_of measurements. Used for profiling, so best effort rather than precise. Defaults to 0. Should not reported any memory held on to by a Value.

fn get_attr(&self, attribute: &str, _heap: &'v Heap) -> Option<Value<'v>>

Get an attribute for the current value as would be returned by dotted expression (i.e. a.attribute).

fn dir_attr(&self) -> Vec<String>

Return a vector of string listing all attribute of the current value.

fn documentation(&self) -> Option<DocItem>

Return structured documentation for self, if available.

fn matches_type(&self, ty: &str) -> bool

Is this value a match for a named type. Usually returns true for values matching get_type, but might also work for subtypes it implements.

fn get_methods(&self) -> Option<&'static Methods>

Get the members associated with this type, accessible via this_type.x. These members will have dir/getattr/hasattr properly implemented, so it is the preferred way to go if possible. See MethodsStatic for an example of how to define this method.

fn collect_repr(&self, collector: &mut String)

Return a string representation of self, as returned by the repr() function. Defaults to the Display instance - which should be fine for nearly all types. In many cases the repr() representation will also be a Starlark expression for creating the value.

fn collect_repr_cycle(&self, collector: &mut String)

Invoked to print repr when a cycle is the object stack is detected.

fn to_bool(&self) -> bool

Convert self to a boolean, as returned by the bool() function. The default implementation returns true.

fn to_int(&self) -> Result<i32>

Convert self to a integer value, as returned by the int() function if the type is numeric (not for string). Works for int and bool (0 = false, 1 = true).

fn write_hash(&self, hasher: &mut StarlarkHasher) -> Result<()>

Return a hash data for self to be used when self is placed as a key in a Dict. Return an Err if there is no hash for this value (e.g. list). Must be stable between frozen and non-frozen values.

fn equals(&self, _other: Value<'v>) -> Result<bool>

Compare self with other for equality. Should only return an error on excessive recursion.

fn compare(&self, other: Value<'v>) -> Result<Ordering>

Compare self with other. This method returns a result of type Ordering, or an Err if the two types differ.

fn at(&self, index: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>>

Return the result of a[index] if a is indexable.

fn slice(
    &self,
    _start: Option<Value<'v>>,
    _stop: Option<Value<'v>>,
    _stride: Option<Value<'v>>,
    _heap: &'v Heap
) -> Result<Value<'v>>

Extract a slice of the underlying object if the object is indexable. The result will be object between start and stop (both of them are added length() if negative and then clamped between 0 and length()). stride indicates the direction.

fn iterate<'a>(
    &'a self,
    _heap: &'v Heap
) -> Result<Box<dyn Iterator<Item = Value<'v>> + 'a>> where
    'v: 'a, 

Returns an iterable over the value of this container if this value holds an iterable container.

fn with_iterator(
    &self,
    heap: &'v Heap,
    f: &mut dyn FnMut(&mut dyn Iterator<Item = Value<'v>>) -> Result<()>
) -> Result<()>

Call a function with the same iterator as would be returned from iterate. The one advantage is that the iterator does not need to be allocated in a Box. If you implement this function you must also implement iterate, but the reverse is not true (this function has a sensible default).

fn length(&self) -> Result<i32>

Returns the length of the value, if this value is a sequence.

fn has_attr(&self, _attribute: &str) -> bool

Return true if an attribute of name attribute exists for the current value.

fn is_in(&self, other: Value<'v>) -> Result<bool>

Tell wether other is in the current value, if it is a container.

fn plus(&self, _heap: &'v Heap) -> Result<Value<'v>>

Apply the + unary operator to the current value.

fn minus(&self, _heap: &'v Heap) -> Result<Value<'v>>

Apply the - unary operator to the current value.

fn radd(&self, _lhs: Value<'v>, _heap: &'v Heap) -> Option<Result<Value<'v>>>

Add with the arguments the other way around. Should return None to fall through to normal add.

fn add(&self, rhs: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>>

Add other to the current value. Pass both self and the Value form of self as original.

fn sub(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>>

Substract other from the current value.

fn mul(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>>

Multiply the current value with other.

fn div(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>>

Divide the current value by other. Always results in a float value.

fn percent(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>>

Apply the percent operator between the current value and other. Usually used on strings, as per the Starlark spec.

fn floor_div(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>>

Floor division between the current value and other.

fn bit_and(&self, other: Value<'v>) -> Result<Value<'v>>

Bitwise & operator.

fn bit_or(&self, other: Value<'v>, _heap: &'v Heap) -> Result<Value<'v>>

Bitwise | operator.

fn bit_xor(&self, other: Value<'v>) -> Result<Value<'v>>

Bitwise ^ operator.

fn left_shift(&self, other: Value<'v>) -> Result<Value<'v>>

Bitwise << operator.

fn right_shift(&self, other: Value<'v>) -> Result<Value<'v>>

Bitwise >> operator.

fn export_as(&self, _variable_name: &str, _eval: &mut Evaluator<'v, '_>)

Called when exporting a value under a specific name,

fn set_at(&self, _index: Value<'v>, _new_value: Value<'v>) -> Result<()>

Set the value at index with the new value.

fn set_attr(&self, attribute: &str, _new_value: Value<'v>) -> Result<()>

Set the attribute named attribute of the current value to value (e.g. a.attribute = value).