Enum immense::TransformArgument

pub enum TransformArgument {
    Single(Transform),
    Many(Vec<Transform>),
}

A TransformArgument is a transform that should be applied to the invocation of a Rule.

See the From and Into implementations which produce this type to find out what kind of argument each type becomes.

Variants

Single(Transform)

A single transform that corresponds to one invocation with the given transform.

Many(Vec<Transform>)

An arbitrary number of transforms (e.g. from Replicate) that correspond to one invocation each.

Trait Implementations

impl Debug for TransformArgument

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

Formats the value using the given formatter.

impl From<&[Transform]> for TransformArgument

A slice of transforms will be sequentially composed into a single transform and correspond to one invocation.

fn from(transforms: &[Transform]) -> Self

Converts to this type from the input type.

impl From<Option<Transform>> for TransformArgument

An optional transform will of course correspond to one invocation. This implementation also allows you to pass None to invoke rules unmodified.

fn from(maybe_input: Option<Transform>) -> Self

Converts to this type from the input type.

impl From<Transform> for TransformArgument

A single transform will correspond to one invocation.

fn from(transform: Transform) -> Self

Converts to this type from the input type.

impl From<Vec<Replicate, Global>> for TransformArgument

A vector of replications will be composed sequentially, which means the number of corresponding rule invocations is the product of each replication. A vector with a replication of transform A 36 times then replication of B 10 times will yield transforms for every sequence of A then B (e.g. (A_1, B_1), (A_1, B_2), …, (A_36, B_36)), so 360 total.

fn from(replications: Vec<Replicate>) -> TransformArgument

Converts to this type from the input type.

impl From<Vec<Transform, Global>> for TransformArgument

A vector of transforms will be sequentially composed into a single transform and correspond to one invocation.

fn from(transforms: Vec<Transform>) -> Self

Converts to this type from the input type.

impl From<Vec<TransformArgument, Global>> for TransformArgument

fn from(args: Vec<TransformArgument>) -> Self

Converts to this type from the input type.

impl Into<TransformArgument> for Replicate

The replication will become n transforms, corresponding to one invocation each.

fn into(self) -> TransformArgument

Converts this type into the (usually inferred) input type.

impl Into<Vec<Transform, Global>> for TransformArgument

fn into(self) -> Vec<Transform>

Converts this type into the (usually inferred) input type.