Struct Ast 

pub struct Ast { /* private fields */ }

Unified AST representation matching cel-go’s Ast type.

An Ast can be either checked (has type info) or unchecked (parsed only). This follows the cel-go pattern where a single type represents both states.

Creating an Ast

• Use Env::compile() to get a checked Ast
• Use Env::parse_only() to get an unchecked Ast

Proto Conversion

For proto wire format conversion, use the cel-core-proto crate directly.

Implementations

impl Ast

pub fn new_unchecked(expr: SpannedExpr, source: impl Into<Arc<str>>) -> Self

Create an unchecked AST (after parsing, before type checking).

pub fn new_checked( expr: SpannedExpr, source: impl Into<Arc<str>>, check_result: CheckResult, ) -> Self

Create a checked AST (after type checking).

pub fn is_checked(&self) -> bool

Returns true if this AST has been type-checked.

pub fn expr(&self) -> &SpannedExpr

Get the expression tree.

pub fn source(&self) -> &str

Get the original source text.

pub fn type_info(&self) -> Option<&CheckResult>

Get type checking results (if checked).

pub fn result_type(&self) -> Option<&CelType>

Get the result type of the expression (if checked).

Returns the type of the root expression from the type map.

Examples found in repository

examples/extensions.rs (line 20)

fn main() {
    // Enable all extensions (strings, math, encoders, optionals)
    // Extensions currently provide type declarations for the checker
    let env = Env::with_standard_library()
        .with_all_extensions()
        .with_variable("values", CelType::list(CelType::Int))
        .with_variable("text", CelType::String);

    // Math extension functions type-check correctly
    let ast = env.compile("math.greatest(values)").unwrap();
    println!("math.greatest(values) type: {:?}", ast.result_type());

    let ast = env.compile("math.least(values)").unwrap();
    println!("math.least(values) type:    {:?}", ast.result_type());

    let ast = env.compile("math.abs(-42)").unwrap();
    println!("math.abs(-42) type:         {:?}", ast.result_type());

    // String extension functions type-check correctly
    let ast = env.compile("text.split(' ')").unwrap();
    println!("text.split(' ') type:       {:?}", ast.result_type());

    let ast = env.compile("['a', 'b'].join('-')").unwrap();
    println!("['a','b'].join('-') type:   {:?}", ast.result_type());

    // Note: Runtime evaluation of extension functions is in progress.
    // For now, use standard library functions that are fully implemented:
    println!("\n=== Standard library (fully implemented) ===");

    let ast = env.compile("size(values)").unwrap();
    println!("size(values) type: {:?}", ast.result_type());

    let ast = env.compile("text.contains('hello')").unwrap();
    println!("text.contains type: {:?}", ast.result_type());

    let ast = env.compile("text.startsWith('h')").unwrap();
    println!("text.startsWith type: {:?}", ast.result_type());
}

pub fn to_cel_string(&self) -> String

Convert the AST back to CEL source text.

The output is a valid CEL expression that is semantically equivalent to the original. Formatting may differ (whitespace, parenthesization).

Example

use cel_core::Env;

let env = Env::with_standard_library();
let ast = env.compile("1 + 2 * 3").unwrap();
assert_eq!(ast.to_cel_string(), "1 + 2 * 3");

Trait Implementations

impl Clone for Ast

fn clone(&self) -> Ast

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ast

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

Formats the value using the given formatter.