Enum CompileEffectKind 

#[non_exhaustive]
pub enum CompileEffectKind {
    DeclarePackage,
    DeclareSub,
    DeclareMethod,
    DeclareBinding,
    SetPragmaState,
    AddIncludePath,
    RemoveIncludePath,
    RequestModule,
    ImportSymbols,
    AssignInheritance,
    AssignGlobAlias,
    DefineConstant,
    RegisterPrototype,
    EmitDynamicBoundary,
}

Compiler state mutation represented by an effect.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

DeclarePackage

Declare a package/stash.

DeclareSub

Declare a subroutine code slot.

DeclareMethod

Declare a method code slot.

DeclareBinding

Declare a lexical or package binding.

SetPragmaState

Set effective pragma or feature state.

AddIncludePath

Add an include path.

RemoveIncludePath

Remove an include path.

RequestModule

Record a module load or resolution request.

ImportSymbols

Record an import-symbol relationship.

AssignInheritance

Assign an inheritance edge.

AssignGlobAlias

Assign a simple typeglob alias.

DefineConstant

Define a constant-like code slot.

RegisterPrototype

Register a prototype-bearing subroutine.

EmitDynamicBoundary

Emit a dynamic-boundary fact instead of guessing.

Trait Implementations

impl Clone for CompileEffectKind

fn clone(&self) -> CompileEffectKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CompileEffectKind

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

Formats the value using the given formatter.

impl Hash for CompileEffectKind

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 CompileEffectKind

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

impl Eq for CompileEffectKind

impl StructuralPartialEq for CompileEffectKind