pyfcstm.dsl.node

State Machine DSL AST Module

This module defines the Abstract Syntax Tree (AST) classes for a State Machine Domain Specific Language. It provides a comprehensive set of classes to represent various elements of state machines including:

States and transitions
Expressions and operations
Conditions and assignments
Event handling with enter, during, and exit actions

The AST classes enable parsing, manipulation, and generation of state machine definitions in a structured way, supporting both simple and hierarchical state machines.

ASTNode

class pyfcstm.dsl.node.ASTNode[source]

Abstract base class for all AST nodes in the state machine DSL.

This class serves as the foundation for all nodes in the Abstract Syntax Tree, providing a common type for all elements in the state machine definition.

Return type:: ASTNode

Identifier

class pyfcstm.dsl.node.Identifier[source]

Abstract base class for identifiers in the state machine DSL.

Identifiers are used to reference variables, states, and other named elements in the state machine definition.

Return type:: Identifier

ChainID

class pyfcstm.dsl.node.ChainID(path: List[str], is_absolute: bool = False)[source]

Represents a chained identifier (e.g., a.b.c) in the state machine DSL.

Parameters:: path (List[str]) – List of string components that make up the chained identifier
Return type:: ChainID

Example:

>>> chain_id = ChainID(['state1', 'event'])
>>> str(chain_id)
'state1.event'

__str__()[source]

Convert the ChainID to its string representation.

Returns:: String representation of the chained identifier
Return type:: str

Expr

class pyfcstm.dsl.node.Expr[source]

Abstract base class for expressions in the state machine DSL.

Expressions represent computations that produce values, which can be used in conditions, assignments, and other contexts within the state machine.

Return type:: Expr

Literal

class pyfcstm.dsl.node.Literal(raw: str)[source]

Base class for literal values in expressions.

Literal values are constants directly expressed in the code, such as numbers, booleans, or predefined constants.

Parameters:: raw (str) – The raw string representation of the literal
Return type:: Literal

__str__()[source]

Convert the literal to its string representation.

Returns:: String representation of the literal’s value
Return type:: str

property value

Get the actual value of the literal.

Returns:: The evaluated value of the literal
Return type:: Any

Boolean

class pyfcstm.dsl.node.Boolean(raw: str)[source]

Represents a boolean literal in the state machine DSL.

Parameters:: raw (str) – The raw string representation of the boolean (“true” or “false”)
Return type:: Boolean

Example:

>>> bool_val = Boolean("true")
>>> bool_val.value
True

__post_init__()[source]: Normalize the raw value to lowercase after initialization.

__str__()

Convert the literal to its string representation.

Returns:: String representation of the literal’s value
Return type:: str

property value

Get the actual value of the literal.

Returns:: The evaluated value of the literal
Return type:: Any

Integer

class pyfcstm.dsl.node.Integer(raw: str)[source]

Represents an integer literal in the state machine DSL.

Parameters:: raw (str) – The raw string representation of the integer
Return type:: Integer

Example:

>>> int_val = Integer("42")
>>> int_val.value
42

property value

Get the actual value of the literal.

Returns:: The evaluated value of the literal
Return type:: Any

HexInt

class pyfcstm.dsl.node.HexInt(raw: str)[source]

Represents a hexadecimal integer literal in the state machine DSL.

Parameters:: raw (str) – The raw string representation of the hexadecimal integer (e.g., “0xFF”)
Return type:: HexInt

Example:

>>> hex_val = HexInt("0xFF")
>>> hex_val.value
255

__str__()[source]

Convert the hexadecimal integer to its string representation.

Returns:: Lowercase string representation of the hexadecimal value
Return type:: str

property value

Get the actual value of the literal.

Returns:: The evaluated value of the literal
Return type:: Any

Float

class pyfcstm.dsl.node.Float(raw: str)[source]

Represents a floating-point literal in the state machine DSL.

Parameters:: raw (str) – The raw string representation of the float
Return type:: Float

Example:

>>> float_val = Float("3.14")
>>> float_val.value
3.14

__str__()[source]

Convert the float to its string representation.

Returns:: String representation of the float
Return type:: str

property value

Get the actual value of the literal.

Returns:: The evaluated value of the literal
Return type:: Any

Constant

class pyfcstm.dsl.node.Constant(raw: str)[source]

Represents a named mathematical constant in the state machine DSL.

Parameters:: raw (str) – The name of the constant (e.g., “pi”, “E”)
Return type:: Constant

Example:

>>> pi_const = Constant("pi")
>>> pi_const.value
3.141592653589793

__str__()[source]

Convert the constant to its string representation.

Returns:: The name of the constant
Return type:: str

property value

Get the actual value of the literal.

Returns:: The evaluated value of the literal
Return type:: Any

Name

class pyfcstm.dsl.node.Name(name: str)[source]

Represents a named reference in the state machine DSL.

Names are used to reference variables, states, or other named elements.

Parameters:: name (str) – The identifier name
Return type:: Name

Example:

>>> var_name = Name("counter")
>>> str(var_name)
'counter'

__str__()[source]

Convert the name to its string representation.

Returns:: The name as a string
Return type:: str

Paren

class pyfcstm.dsl.node.Paren(expr: Expr)[source]

Represents a parenthesized expression in the state machine DSL.

Parentheses are used to control the order of operations in expressions.

Parameters:: expr (Expr) – The expression within the parentheses
Return type:: Paren

Example:

>>> inner_expr = BinaryOp(Name("a"), "+", Name("b"))
>>> paren_expr = Paren(inner_expr)
>>> str(paren_expr)
'(a + b)'

__str__()[source]

Convert the parenthesized expression to its string representation.

Returns:: The expression surrounded by parentheses
Return type:: str

UnaryOp

class pyfcstm.dsl.node.UnaryOp(op: str, expr: Expr)[source]

Represents a unary operation in the state machine DSL.

Unary operations apply a single operator to an expression.

Parameters:

op (str) – The unary operator (e.g., “!”, “not”, “-“)
expr (Expr) – The expression to which the operator is applied

Return type:

Example:

>>> not_expr = UnaryOp("not", Name("condition"))
>>> str(not_expr)
'!condition'

__post_init__()[source]: Replace any operator aliases with their canonical form.

__str__()[source]

Convert the unary operation to its string representation.

Returns:: String representation of the unary operation
Return type:: str

BinaryOp

class pyfcstm.dsl.node.BinaryOp(expr1: Expr, op: str, expr2: Expr)[source]

Represents a binary operation in the state machine DSL.

Binary operations apply an operator to two expressions.

Parameters:

expr1 (Expr) – The left-hand expression
op (str) – The binary operator (e.g., “+”, “-”, “and”, “or”)
expr2 (Expr) – The right-hand expression

Return type:

Example:

>>> add_expr = BinaryOp(Name("a"), "+", Name("b"))
>>> str(add_expr)
'a + b'
>>> and_expr = BinaryOp(Name("x"), "and", Name("y"))
>>> str(and_expr)
'x && y'

__post_init__()[source]: Replace any operator aliases with their canonical form.

__str__()[source]

Convert the binary operation to its string representation.

Returns:: String representation of the binary operation
Return type:: str

ConditionalOp

class pyfcstm.dsl.node.ConditionalOp(cond: Expr, value_true: Expr, value_false: Expr)[source]

Represents a conditional (ternary) operation in the state machine DSL.

The conditional operation evaluates a condition and returns one of two expressions based on whether the condition is true or false.

Parameters:

cond (Expr) – The condition expression
value_true (Expr) – The expression to evaluate if the condition is true
value_false (Expr) – The expression to evaluate if the condition is false

Return type:

Example:

>>> cond_op = ConditionalOp(Name("x"), Integer("1"), Integer("0"))
>>> str(cond_op)
'(x) ? 1 : 0'

__str__()[source]

Convert the conditional operation to its string representation.

Returns:: String representation of the conditional operation
Return type:: str

UFunc

class pyfcstm.dsl.node.UFunc(func: str, expr: Expr)[source]

Represents a unary function call in the state machine DSL.

Unary functions apply a named function to a single expression.

Parameters:

func (str) – The function name
expr (Expr) – The expression to which the function is applied

Return type:

Example:

>>> func_call = UFunc("abs", Name("x"))
>>> str(func_call)
'abs(x)'

__str__()[source]

Convert the function call to its string representation.

Returns:: String representation of the function call
Return type:: str

Statement

class pyfcstm.dsl.node.Statement[source]

Abstract base class for statements in the state machine DSL.

Statements represent actions or declarations in the state machine definition.

Return type:: Statement

ConstantDefinition

class pyfcstm.dsl.node.ConstantDefinition(name: str, expr: Expr)[source]

Represents a constant definition statement in the state machine DSL.

Parameters:

name (str) – The name of the constant
expr (Expr) – The expression defining the constant’s value

Return type:

ConstantDefinition

Example:

>>> const_def = ConstantDefinition("MAX_COUNT", Integer("100"))
>>> str(const_def)
'MAX_COUNT = 100;'

__str__()[source]

Convert the constant definition to its string representation.

Returns:: String representation of the constant definition
Return type:: str

InitialAssignment

class pyfcstm.dsl.node.InitialAssignment(name: str, expr: Expr)[source]

Represents an initial assignment statement in the state machine DSL.

Initial assignments are used to set initial values for variables.

Parameters:

name (str) – The name of the variable
expr (Expr) – The expression defining the variable’s initial value

Return type:

InitialAssignment

Example:

>>> init_assign = InitialAssignment("counter", Integer("0"))
>>> str(init_assign)
'counter := 0;'

__str__()[source]

Convert the initial assignment to its string representation.

Returns:: String representation of the initial assignment
Return type:: str

DefAssignment

class pyfcstm.dsl.node.DefAssignment(name: str, type: str, expr: Expr)[source]

Represents a definition assignment statement in the state machine DSL.

Definition assignments are used to declare and initialize typed variables.

Parameters:

name (str) – The name of the variable
type (str) – The type of the variable
expr (Expr) – The expression defining the variable’s value

Return type:

Example:

>>> def_assign = DefAssignment("counter", "int", Integer("0"))
>>> str(def_assign)
'def int counter = 0;'

__str__()[source]

Convert the definition assignment to its string representation.

Returns:: String representation of the definition assignment
Return type:: str

OperationalDeprecatedAssignment

class pyfcstm.dsl.node.OperationalDeprecatedAssignment(name: str, expr: Expr)[source]

Represents a deprecated form of operational assignment in the state machine DSL.

Parameters:

name (str) – The name of the variable
expr (Expr) – The expression defining the variable’s value

Return type:

OperationalDeprecatedAssignment

Example:

>>> op_assign = OperationalDeprecatedAssignment("counter", BinaryOp(Name("counter"), "+", Integer("1")))
>>> str(op_assign)
'counter := counter + 1;'

__str__()[source]

Convert the operational deprecated assignment to its string representation.

Returns:: String representation of the operational deprecated assignment
Return type:: str

Preamble

class pyfcstm.dsl.node.Preamble(stats: List[ConstantDefinition | InitialAssignment])[source]

Represents a preamble section in the state machine DSL.

The preamble contains constant definitions and initial assignments that set up the state machine’s environment.

Parameters:: stats (List[Union[ConstantDefinition, InitialAssignment]]) – List of statements in the preamble
Return type:: Preamble

Example:

>>> const_def = ConstantDefinition("MAX", Integer("100"))
>>> init_assign = InitialAssignment("counter", Integer("0"))
>>> preamble = Preamble([const_def, init_assign])
>>> print(str(preamble))
MAX = 100;
counter := 0;

__str__()[source]

Convert the preamble to its string representation.

Returns:: String representation of the preamble
Return type:: str

Operation

class pyfcstm.dsl.node.Operation(stats: List[OperationalDeprecatedAssignment])[source]

Represents an operation block in the state machine DSL.

Operations are sequences of assignments that modify the state machine’s variables.

Parameters:: stats (List[OperationalDeprecatedAssignment]) – List of operational assignments
Return type:: Operation

Example:

>>> op1 = OperationalDeprecatedAssignment("counter", BinaryOp(Name("counter"), "+", Integer("1")))
>>> op2 = OperationalDeprecatedAssignment("flag", Boolean("true"))
>>> operation = Operation([op1, op2])
>>> print(str(operation))
counter := counter + 1;
flag := true;

__str__()[source]

Convert the operation to its string representation.

Returns:: String representation of the operation
Return type:: str

Condition

class pyfcstm.dsl.node.Condition(expr: Expr)[source]

Represents a condition in the state machine DSL.

Conditions are used in transitions and other contexts to determine when actions should occur.

Parameters:: expr (Expr) – The expression defining the condition
Return type:: Condition

Example:

>>> cond = Condition(BinaryOp(Name("counter"), ">=", Integer("10")))
>>> str(cond)
'counter >= 10'

__str__()[source]

Convert the condition to its string representation.

Returns:: String representation of the condition
Return type:: str

TransitionDefinition

class pyfcstm.dsl.node.TransitionDefinition(from_state: str | _StateSingletonMark, to_state: str | _StateSingletonMark, event_id: ChainID | None, condition_expr: Expr | None, post_operations: List[OperationAssignment])[source]

Represents a transition definition in the state machine DSL.

Transitions define how the state machine moves from one state to another in response to events and conditions.

Parameters:

from_state (Union[str, _StateSingletonMark]) – The source state name or INIT_STATE singleton
to_state (Union[str, _StateSingletonMark]) – The target state name or EXIT_STATE singleton
event_id (Optional[ChainID]) – Optional event identifier that triggers the transition
condition_expr (Optional[Expr]) – Optional condition expression that must be true for the transition
post_operations (List[OperationAssignment]) – List of operations to perform after the transition

Return type:

TransitionDefinition

Example:

>>> # Transition from initial state to "idle" state
>>> init_trans = TransitionDefinition(INIT_STATE, "idle", None, None, [])
>>> # Transition from "idle" to "active" on "start" event
>>> event_trans = TransitionDefinition("idle", "active", ChainID(["idle", "start"]), None, [])
>>> # Transition with condition and operations
>>> op = OperationAssignment("counter", Integer("0"))
>>> cond_trans = TransitionDefinition("active", "idle", None, BinaryOp(Name("counter"), ">", Integer("10")), [op])

__str__()[source]

Convert the transition definition to its string representation.

Returns:: String representation of the transition definition
Return type:: str

ForceTransitionDefinition

class pyfcstm.dsl.node.ForceTransitionDefinition(from_state: str | _StateSingletonMark, to_state: str | _StateSingletonMark, event_id: ChainID | None, condition_expr: Expr | None)[source]

Represents a forced transition definition in the state machine DSL.

Forced transitions override normal transitions and are used for special cases like error handling or interrupts.

Parameters:

from_state (Union[str, _StateSingletonMark]) – The source state name or ALL singleton
to_state (Union[str, _StateSingletonMark]) – The target state name or EXIT_STATE singleton
event_id (Optional[ChainID]) – Optional event identifier that triggers the transition
condition_expr (Optional[Expr]) – Optional condition expression that must be true for the transition

Return type:

ForceTransitionDefinition

Example:

>>> # Force transition from any state to "error" state
>>> force_trans = ForceTransitionDefinition(ALL, "error", None, None)
>>> str(force_trans)
'! * -> error;'

__str__()[source]

Convert the force transition definition to its string representation.

Returns:: String representation of the force transition definition
Return type:: str

StateDefinition

class pyfcstm.dsl.node.StateDefinition(name: str, substates: List[StateDefinition] | None = None, transitions: List[TransitionDefinition] | None = None, enters: List[EnterStatement] | None = None, durings: List[DuringStatement] | None = None, exits: List[ExitStatement] | None = None, during_aspects: List[DuringAspectStatement] | None = None, force_transitions: List[ForceTransitionDefinition] | None = None)[source]

Represents a state definition in the state machine DSL.

States are the fundamental building blocks of state machines, containing transitions, substates, and actions to be performed on entry, during, and exit.

Parameters:

name (str) – The name of the state
substates (List[StateDefinition]) – List of nested state definitions
transitions (List[TransitionDefinition]) – List of transitions from this state
enters (List[EnterStatement]) – List of actions to perform when entering the state
durings (List[DuringStatement]) – List of actions to perform while in the state
exits (List[ExitStatement]) – List of actions to perform when exiting the state

Return type:

StateDefinition

Example:

>>> # Simple state with no internal elements
>>> simple_state = StateDefinition("idle", [], [], [], [], [])
>>> str(simple_state)
'state idle;'

>>> # State with transitions
>>> trans = TransitionDefinition("idle", "active", ChainID(["idle", "start"]), None, [])
>>> state_with_trans = StateDefinition("idle", [], [trans], [], [], [])

__str__()[source]

Convert the state definition to its string representation.

Returns:: String representation of the state definition
Return type:: str

OperationAssignment

class pyfcstm.dsl.node.OperationAssignment(name: str, expr: Expr)[source]

Represents an operation assignment in the state machine DSL.

Operation assignments are used to modify variables during transitions or state actions.

Parameters:

name (str) – The name of the variable
expr (Expr) – The expression defining the new value

Return type:

OperationAssignment

Example:

>>> op_assign = OperationAssignment("counter", BinaryOp(Name("counter"), "+", Integer("1")))
>>> str(op_assign)
'counter = counter + 1;'

__str__()[source]

Convert the operation assignment to its string representation.

Returns:: String representation of the operation assignment
Return type:: str

StateMachineDSLProgram

class pyfcstm.dsl.node.StateMachineDSLProgram(definitions: List[DefAssignment], root_state: StateDefinition)[source]

Represents a complete state machine DSL program.

A program consists of variable definitions and a root state that contains the entire state machine hierarchy.

Parameters:

definitions (List[DefAssignment]) – List of variable definitions
root_state (StateDefinition) – The root state of the state machine

Return type:

StateMachineDSLProgram

Example:

>>> def_var = DefAssignment("counter", "int", Integer("0"))
>>> root = StateDefinition("root", [], [], [], [], [])
>>> program = StateMachineDSLProgram([def_var], root)
>>> print(str(program))
def int counter = 0;
state root;

__str__()[source]

Convert the state machine program to its string representation.

Returns:: String representation of the state machine program
Return type:: str

EnterStatement

class pyfcstm.dsl.node.EnterStatement[source]

Abstract base class for enter statements in the state machine DSL.

Enter statements define actions to be performed when entering a state.

Return type:: EnterStatement

EnterOperations

class pyfcstm.dsl.node.EnterOperations(operations: List[OperationAssignment], name: str | None = None)[source]

Represents a block of operations to perform when entering a state.

Parameters:: operations (List[OperationAssignment]) – List of operation assignments
Return type:: EnterOperations

Example:

>>> op = OperationAssignment("counter", Integer("0"))
>>> enter_ops = EnterOperations([op])
>>> print(str(enter_ops))
enter {
    counter = 0;
}

__str__()[source]

Convert the enter operations to their string representation.

Returns:: String representation of the enter operations
Return type:: str

EnterAbstractFunction

class pyfcstm.dsl.node.EnterAbstractFunction(name: str | None, doc: str | None)[source]

Represents an abstract function to call when entering a state.

Abstract functions are placeholders for implementation-specific behavior.

Parameters:

name (Optional[str]) – Optional name of the function
doc (Optional[str]) – Optional documentation for the function

Return type:

EnterAbstractFunction

Example:

>>> enter_func = EnterAbstractFunction("initState", "Initialize the state")
>>> print(str(enter_func))
enter abstract initState /*
    Initialize the state
*/

__str__()[source]

Convert the enter abstract function to its string representation.

Returns:: String representation of the enter abstract function
Return type:: str

ExitStatement

class pyfcstm.dsl.node.ExitStatement[source]

Abstract base class for exit statements in the state machine DSL.

Exit statements define actions to be performed when exiting a state.

Return type:: ExitStatement

ExitOperations

class pyfcstm.dsl.node.ExitOperations(operations: List[OperationAssignment], name: str | None = None)[source]

Represents a block of operations to perform when exiting a state.

Parameters:: operations (List[OperationAssignment]) – List of operation assignments
Return type:: ExitOperations

Example:

>>> op = OperationAssignment("active", Boolean("false"))
>>> exit_ops = ExitOperations([op])
>>> print(str(exit_ops))
exit {
    active = false;
}

__str__()[source]

Convert the exit operations to their string representation.

Returns:: String representation of the exit operations
Return type:: str

ExitAbstractFunction

class pyfcstm.dsl.node.ExitAbstractFunction(name: str | None, doc: str | None)[source]

Represents an abstract function to call when exiting a state.

Abstract functions are placeholders for implementation-specific behavior.

Parameters:

name (Optional[str]) – Optional name of the function
doc (Optional[str]) – Optional documentation for the function

Return type:

ExitAbstractFunction

Example:

>>> exit_func = ExitAbstractFunction("cleanupState", "Clean up resources")
>>> print(str(exit_func))
exit abstract cleanupState /*
    Clean up resources
*/

__str__()[source]

Convert the exit abstract function to its string representation.

Returns:: String representation of the exit abstract function
Return type:: str

DuringStatement

class pyfcstm.dsl.node.DuringStatement[source]

Abstract base class for during statements in the state machine DSL.

During statements define actions to be performed while in a state.

Return type:: DuringStatement

DuringOperations

class pyfcstm.dsl.node.DuringOperations(aspect: str | None, operations: List[OperationAssignment], name: str | None = None)[source]

Represents a block of operations to perform while in a state.

Parameters:

aspect (Optional[str]) – Optional aspect name (e.g., “entry”, “do”, “exit”)
operations (List[OperationAssignment]) – List of operation assignments

Return type:

DuringOperations

Example:

>>> op = OperationAssignment("counter", BinaryOp(Name("counter"), "+", Integer("1")))
>>> during_ops = DuringOperations("do", [op])
>>> print(str(during_ops))
during do {
    counter = counter + 1;
}

__str__()[source]

Convert the during operations to their string representation.

Returns:: String representation of the during operations
Return type:: str

DuringAbstractFunction

class pyfcstm.dsl.node.DuringAbstractFunction(name: str | None, aspect: str | None, doc: str | None)[source]

Represents an abstract function to call while in a state.

Abstract functions are placeholders for implementation-specific behavior.

Parameters:

name (Optional[str]) – Optional name of the function
aspect (Optional[str]) – Optional aspect name (e.g., “entry”, “do”, “exit”)
doc (Optional[str]) – Optional documentation for the function

Return type:

DuringAbstractFunction

Example:

>>> during_func = DuringAbstractFunction("processData", "do", "Process incoming data")
>>> print(str(during_func))
during do abstract processData /*
    Process incoming data
*/

__str__()[source]

Convert the during abstract function to its string representation.

Returns:: String representation of the during abstract function
Return type:: str

DuringAspectStatement

class pyfcstm.dsl.node.DuringAspectStatement[source]

Abstract base class for during aspect statements in the state machine DSL.

During aspect statements define aspect-specific actions to be performed while in a state.

Return type:: DuringAspectStatement

DuringAspectOperations

class pyfcstm.dsl.node.DuringAspectOperations(aspect: str, operations: List[OperationAssignment], name: str | None = None)[source]

Represents a block of aspect-specific operations to perform while in a state.

Parameters:

aspect (str) – The aspect name (e.g., “entry”, “do”, “exit”)
operations (List[OperationAssignment]) – List of operation assignments
name (Optional[str]) – Optional name for the operation block

Return type:

DuringAspectOperations

Example:

>>> op = OperationAssignment("counter", BinaryOp(Name("counter"), "+", Integer("1")))
>>> during_ops = DuringAspectOperations("before", [op])
>>> print(str(during_ops))
>> during before {
    counter = counter + 1;
}

__str__()[source]

Convert the during aspect operations to their string representation.

Returns:: String representation of the during aspect operations
Return type:: str

DuringAspectAbstractFunction

class pyfcstm.dsl.node.DuringAspectAbstractFunction(name: str | None, aspect: str, doc: str | None)[source]

Represents an abstract function to call for a specific aspect while in a state.

Abstract functions are placeholders for implementation-specific behavior.

Parameters:

name (Optional[str]) – Optional name of the function
aspect (str) – The aspect name (e.g., “before”, “after”)
doc (Optional[str]) – Optional documentation for the function

Return type:

DuringAspectAbstractFunction

Example:

>>> during_func = DuringAspectAbstractFunction("processData", "before", "Process incoming data")
>>> print(str(during_func))
>> during before abstract processData /*
    Process incoming data
*/

__str__()[source]

Convert the during aspect abstract function to its string representation.

Returns:: String representation of the during aspect abstract function
Return type:: str

INIT_STATE

pyfcstm.dsl.node.INIT_STATE = INIT_STATE

Special singleton marker representing the initial state in a state machine.

This is used to define transitions from the initial pseudo-state.

EXIT_STATE

pyfcstm.dsl.node.EXIT_STATE = EXIT_STATE

Special singleton marker representing the exit state in a state machine.

This is used to define transitions to the final pseudo-state.

ALL

pyfcstm.dsl.node.ALL = ALL

Special singleton marker representing all states in a state machine.

This is used to define transitions or actions that apply to all states.