Enum JsonnetValue 

pub enum JsonnetValue {
    Null,
    Boolean(bool),
    Number(f64),
    String(String),
    Array(Vec<JsonnetValue>),
    Object(HashMap<String, JsonnetValue>),
    Function(JsonnetFunction),
    Builtin(JsonnetBuiltin),
}

Jsonnet value types

Variants

Null

Null value

Boolean(bool)

Boolean value

Number(f64)

Number value (f64)

String(String)

String value

Array(Vec<JsonnetValue>)

Array value

Object(HashMap<String, JsonnetValue>)

Object value

Function(JsonnetFunction)

Function value

Builtin(JsonnetBuiltin)

Builtin function value

Implementations

impl JsonnetValue

pub fn from_json_value(value: Value) -> Self

Convert from serde_json::Value to JsonnetValue

pub fn slice(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

slice(array|string, start, [end]) - Extract slice from array or string

pub fn zip(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

zip(arrays…) - Zip multiple arrays together

pub fn transpose(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

transpose(matrix) - Transpose a matrix (array of arrays)

pub fn flatten(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

flatten(array, [depth]) - Completely flatten nested arrays

pub fn sum(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

sum(array) - Sum all numbers in array

pub fn product(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

product(array) - Product of all numbers in array

pub fn all(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

all(array) - Check if all elements are truthy

pub fn any(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

any(array) - Check if any element is truthy

pub fn sort_by(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

sortBy(array, keyFunc) - Sort array by key function

pub fn group_by(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

groupBy(array, keyFunc) - Group array elements by key function

pub fn partition(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

partition(array, predFunc) - Partition array by predicate function

pub fn chunk(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

chunk(array, size) - Split array into chunks of given size

pub fn unique(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

unique(array) - Remove duplicates from array (alternative to uniq)

pub fn difference(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

difference(arrays…) - Set difference of arrays

pub fn intersection(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

intersection(arrays…) - Set intersection of arrays

pub fn symmetric_difference(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

symmetricDifference(a, b) - Symmetric difference of two arrays

pub fn is_subset(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

isSubset(a, b) - Check if a is subset of b

pub fn is_superset(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

isSuperset(a, b) - Check if a is superset of b

pub fn is_disjoint(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

isDisjoint(a, b) - Check if a and b are disjoint

pub fn cartesian(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

cartesian(arrays) - Cartesian product of arrays

pub fn cross(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

cross(a, b) - Cross product of two arrays

pub fn dot(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

dot(a, b) - Dot product of two numeric arrays

pub fn norm(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

norm(array) - Euclidean norm of numeric array

pub fn normalize(&mut self, args: Vec<JsonnetValue>) -> Result<JsonnetValue>

normalize(array) - Normalize numeric array

pub fn distance(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

distance(a, b) - Euclidean distance between two points

pub fn angle(&mut self, args: Vec<JsonnetValue>) -> Result<JsonnetValue>

angle(a, b) - Angle between two vectors

pub fn rotate(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

rotate(point, angle, [center]) - Rotate 2D point

pub fn scale(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

scale(point, factor, [center]) - Scale 2D point

pub fn translate(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

translate(point, offset) - Translate 2D point

pub fn reflect(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

reflect(point, axis) - Reflect 2D point over axis

pub fn affine(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

affine(point, matrix) - Apply affine transformation

pub fn split_limit(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

splitLimit(string, sep, limit) - Split string with limit

pub fn join_variadic(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

join(sep, arrays…) - Join arrays with separator (variadic version)

pub fn replace(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

replace(string, old, new) - Replace all occurrences

pub fn contains_variadic(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

contains(container, element) - Check if container contains element

pub fn ai_http_get(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

ai.httpGet(url, headers={}) - Make HTTP GET request

pub fn ai_http_post(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

ai.httpPost(url, body, headers={}) - Make HTTP POST request

pub fn ai_call_model(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

ai.callModel(model, messages, options={}) - Call AI model

pub fn tool_execute(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

tool.execute(command, args=[], env={}) - Execute external command

pub fn memory_get(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

memory.get(key) - Get value from memory

pub fn memory_set(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

memory.set(key, value) - Set value in memory

pub fn agent_create(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

agent.create(type, config) - Create an AI agent

pub fn agent_execute(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

agent.execute(agent, input) - Execute agent with input

pub fn chain_create(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

chain.create(steps) - Create a processing chain

pub fn chain_execute(args: Vec<JsonnetValue>) -> Result<JsonnetValue>

chain.execute(chain, input) - Execute a processing chain

impl JsonnetValue

pub fn null() -> Self

Create a null value

pub fn boolean(b: bool) -> Self

Create a boolean value

pub fn number(n: f64) -> Self

Create a number value

pub fn string(s: impl Into<String>) -> Self

Create a string value

pub fn array(values: Vec<JsonnetValue>) -> Self

Create an array value

pub fn object(fields: HashMap<String, JsonnetValue>) -> Self

Create an object value

pub fn is_truthy(&self) -> bool

Check if the value is truthy

pub fn type_name(&self) -> &'static str

Get the type name of this value

pub fn to_json_value(&self) -> Value

Convert to serde_json::Value for serialization

pub fn as_string(&self) -> Result<&str>

Try to convert to a string

pub fn as_number(&self) -> Result<f64>

Try to convert to a number

pub fn as_boolean(&self) -> Result<bool>

Try to convert to a boolean

pub fn as_array(&self) -> Result<&Vec<JsonnetValue>>

Try to convert to an array

pub fn as_object(&self) -> Result<&HashMap<String, JsonnetValue>>

Try to convert to an object

pub fn get_field(&self, field: &str) -> Result<&JsonnetValue>

Get a field from an object

pub fn get_index(&self, index: i64) -> Result<&JsonnetValue>

Get an element from an array by index

pub fn equals(&self, other: &JsonnetValue) -> bool

Check if two values are equal

pub fn add(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn sub(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn mul(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn div(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn modulo(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn lt(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn le(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn gt(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn ge(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn eq(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn ne(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn and(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn or(&self, other: &JsonnetValue) -> Result<JsonnetValue>

pub fn not(&self) -> Result<JsonnetValue>

pub fn neg(&self) -> Result<JsonnetValue>

Trait Implementations

impl Clone for JsonnetValue

fn clone(&self) -> JsonnetValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for JsonnetValue

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

Formats the value using the given formatter.

impl Default for JsonnetValue

fn default() -> JsonnetValue

Returns the “default value” for a type.

impl Display for JsonnetValue

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

Formats the value using the given formatter.

impl PartialEq for JsonnetValue

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for JsonnetValue