# PodExpression<T> class abstract interface

Pod Expression Contract

Represents an abstract, generic expression that evaluates into a Pod or related object in the dependency injection container.

A `PodExpression` is part of the evaluation pipeline for JetLeaf-style dependency injection. It acts like an AST (abstract syntax tree) node that can be:

- A literal reference to a pod.
- A composite expression combining multiple pods.
- A dynamic expression resolved at runtime.

The generic type parameter `T` represents the expected result type of the evaluation, typically the type of object the pod produces.

# Usage

Developers typically do not implement `PodExpression` directly. Instead, it is used by the DI framework when parsing, combining, or lazily evaluating pod configurations.

Example:

    final expr = SomeConcretePodExpression<String>();
    final context = PodExpressionContext(factory, scope);

    // Evaluates expression into an ObjectHolder<String>
    final result = expr.evaluate(context);
    print(result.getPod()); // e.g., prints a singleton String pod

# Notes for Implementors

- Must be immutable and thread-safe.
- Should perform minimal work until evaluate is invoked.
- Designed to support async or sync evaluation (via FutureOr).

Annotations
  - @Generic(PodExpression)

## Properties

hashCode → int
  The hash code for this object.
  no setter inherited
runtimeType → Type
  A representation of the runtime type of the object.
  no setter inherited

## Methods

evaluate(PodExpressionContext context) → FutureOr<ObjectHolder<T>>
  Evaluate the Pod Expression
noSuchMethod(Invocation invocation) → dynamic
  Invoked when a nonexistent method or property is accessed.
  inherited
toString() → String
  A string representation of this object.
  inherited

## Operators

operator ==(Object other) → bool
  The equality operator.
  inherited