Enum Atomic 

pub enum Atomic {
    TString,
    TLiteralString(Arc<str>),
    TClassString(Option<Arc<str>>),
    TNonEmptyString,
    TNumericString,
    TInt,
    TLiteralInt(i64),
    TIntRange {
        min: Option<i64>,
        max: Option<i64>,
    },
    TPositiveInt,
    TNegativeInt,
    TNonNegativeInt,
    TFloat,
    TLiteralFloat(i64, i64),
    TBool,
    TTrue,
    TFalse,
    TNull,
    TVoid,
    TNever,
    TMixed,
    TScalar,
    TNumeric,
    TObject,
    TNamedObject {
        fqcn: Arc<str>,
        type_params: Vec<Union>,
    },
    TStaticObject {
        fqcn: Arc<str>,
    },
    TSelf {
        fqcn: Arc<str>,
    },
    TParent {
        fqcn: Arc<str>,
    },
    TCallable {
        params: Option<Vec<FnParam>>,
        return_type: Option<Box<Union>>,
    },
    TClosure {
        params: Vec<FnParam>,
        return_type: Box<Union>,
        this_type: Option<Box<Union>>,
    },
    TArray {
        key: Box<Union>,
        value: Box<Union>,
    },
    TList {
        value: Box<Union>,
    },
    TNonEmptyArray {
        key: Box<Union>,
        value: Box<Union>,
    },
    TNonEmptyList {
        value: Box<Union>,
    },
    TKeyedArray {
        properties: IndexMap<ArrayKey, KeyedProperty>,
        is_open: bool,
        is_list: bool,
    },
    TTemplateParam {
        name: Arc<str>,
        as_type: Box<Union>,
        defining_entity: Arc<str>,
    },
    TConditional {
        subject: Box<Union>,
        if_true: Box<Union>,
        if_false: Box<Union>,
    },
    TInterfaceString,
    TEnumString,
    TTraitString,
    TLiteralEnumCase {
        enum_fqcn: Arc<str>,
        case_name: Arc<str>,
    },
    TIntersection {
        parts: Vec<Union>,
    },
}

Variants

TString

string

TLiteralString(Arc<str>)

"hello" — a specific string literal

TClassString(Option<Arc<str>>)

class-string or class-string<T>

TNonEmptyString

non-empty-string

TNumericString

numeric-string

TInt

int

TLiteralInt(i64)

42 — a specific integer literal

TIntRange

int<min, max> — bounded integer range

Fields

min: Option<i64>

max: Option<i64>

TPositiveInt

positive-int

TNegativeInt

negative-int

TNonNegativeInt

non-negative-int

TFloat

float

TLiteralFloat(i64, i64)

3.14 — a specific float literal

TBool

bool

TTrue

true

TFalse

false

TNull

null

TVoid

void — return-only; can’t be used as a value

TNever

never — function that never returns (throws or infinite loop)

TMixed

mixed — top type; accepts anything

TScalar

scalar — int | float | string | bool

TNumeric

numeric — int | float | numeric-string

TObject

object — any object

TNamedObject

ClassName / ClassName<T1, T2> — specific named class/interface

Fields

fqcn: Arc<str>

type_params: Vec<Union>

Resolved generic type arguments (e.g. Collection<int>)

TStaticObject

static — late static binding type; resolved to calling class at call site

Fields

fqcn: Arc<str>

TSelf

self — the class in whose body the type appears

Fields

fqcn: Arc<str>

TParent

parent — the parent class

Fields

fqcn: Arc<str>

TCallable

callable or callable(T): R

Fields

params: Option<Vec<FnParam>>

return_type: Option<Box<Union>>

TClosure

Closure or Closure(T): R — more specific than TCallable

Fields

params: Vec<FnParam>

return_type: Box<Union>

this_type: Option<Box<Union>>

TArray

array or array<K, V>

Fields

key: Box<Union>

value: Box<Union>

TList

list<T> — integer-keyed sequential array (keys 0, 1, 2, …)

Fields

value: Box<Union>

TNonEmptyArray

non-empty-array<K, V>

Fields

key: Box<Union>

value: Box<Union>

TNonEmptyList

non-empty-list<T>

Fields

value: Box<Union>

TKeyedArray

array{key: T, ...} — shape / keyed array

Fields

properties: IndexMap<ArrayKey, KeyedProperty>

is_open: bool

If true, additional keys beyond the declared ones may exist

is_list: bool

If true, the shape represents a list (integer keys only)

TTemplateParam

T — a template type parameter

Fields

name: Arc<str>

as_type: Box<Union>

defining_entity: Arc<str>

The entity (class or function FQN) that declared this template

TConditional

(T is string ? A : B) — conditional type

Fields

subject: Box<Union>

if_true: Box<Union>

if_false: Box<Union>

TInterfaceString

interface-string

TEnumString

enum-string

TTraitString

trait-string

TLiteralEnumCase

EnumName::CaseName — a specific enum case literal

Fields

enum_fqcn: Arc<str>

case_name: Arc<str>

TIntersection

A&B&C — PHP 8.1+ pure intersection type

Fields

parts: Vec<Union>

Implementations

impl Atomic

pub fn can_be_falsy(&self) -> bool

Whether this atomic type can ever evaluate to a falsy value.

pub fn can_be_truthy(&self) -> bool

Whether this atomic type can ever evaluate to a truthy value.

pub fn is_numeric(&self) -> bool

Whether this atomic represents a numeric type (int, float, or numeric-string).

pub fn is_int(&self) -> bool

Whether this atomic is an integer variant.

pub fn is_string(&self) -> bool

Whether this atomic is a string variant.

pub fn is_array(&self) -> bool

Whether this atomic is an array variant.

pub fn is_object(&self) -> bool

Whether this atomic is an object variant.

pub fn is_callable(&self) -> bool

Whether this atomic is a callable variant.

pub fn named_object_fqcn(&self) -> Option<&str>

Returns the FQCN if this is a named object type.

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

A human-readable name for this type (used in error messages).

Trait Implementations

impl Clone for Atomic

fn clone(&self) -> Atomic

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Atomic

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Atomic

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Atomic

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

Formats the value using the given formatter.

impl Hash for Atomic

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Atomic

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Atomic

impl StructuralPartialEq for Atomic