Struct ReplaceTypes 

pub struct ReplaceTypes { /* private fields */ }

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

A lowering ComposablePass that replaces types, ops and constants, i.e. changing node signatures/interfaces.

The struct configures what types, ops, and constants should be replaced with what, and may be applied to a Hugr via Self::run.

Parametrized types and ops will be reparameterized taking into account the replacements, but any ops taking/returning the replaced types not as a result of parametrization, will also need to be replaced - see Self::replace_op. Similarly Consts.

Types that are Copyable may also be replaced with types that are not, see Linearizer.

Note that although this pass may be used before monomorphization, there are some limitations (that do not apply if done after monomorphization):

• NodeTemplate::CompoundOp only works for operations that do not use type variables
• “Overrides” of specific instantiations of polymorphic types will not be detected if the instantiations are created inside polymorphic functions. For example, suppose we Self::replace_type type A with X, Self::replace_parametrized_type container MyList with List, and Self::replace_type MyList<A> with SpecialListOfXs. If a function foo polymorphic over a type variable T dealing with MyList<T>s, that is called with type argument A, then foo<T> will be updated to deal with List<T>s and the call foo<A> updated to foo<X>, but this will still result in using List<X> rather than SpecialListOfXs. (However this would be fine after monomorphization: the monomorphic definition of foo_A would use SpecialListOfXs.)
• See also limitations noted for Linearizer.

Implementations

impl ReplaceTypes

pub fn new_empty() -> Self

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Makes a new instance. Unlike Self::default, this does not understand any extension types, even those in the prelude.

pub fn replace_type(&mut self, src: CustomType, dest: Type)

👎Deprecated since 0.25.0:

Use set_replace_type

Configures this instance to replace occurrences of type src with dest.

pub fn set_replace_type(&mut self, src: CustomType, dest: Type)

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Configures this instance to replace occurrences of type src with dest.

dest will be recursively transformed by this ReplaceTypes before replacement. (Cases where a type should be replaced by a type containing an instance of the first type, must be handled by two separate ReplaceTypes’s via a temporary type. )

Note that if src is an instance of a parametrized TypeDef, this takes precedence over Self::replace_parametrized_type where the srcs overlap. Thus, this should only be used on already-monomorphized Hugrs, as substitution (parametric polymorphism) happening later will not respect this replacement.

If there are any LoadConstants of this type, callers should also call Self::replace_consts (or Self::replace_consts_parametrized) as the LoadConstants will be reparameterized (and this will break the edge from Const to LoadConstant).

Note that if src is Copyable and dest is Linear, then (besides linearity violations) SignatureError will be raised if this leads to an impossible type e.g. ArrayOfCopyables(src). (This can be overridden by an additional Self::replace_type.)

pub fn replace_type_opts( &mut self, src: CustomType, dest: Type, opts: ReplacementOptions, )

👎Deprecated since 0.25.0:

Use set_replace_type

Configures this instance to replace occurrences of type src with dest, according to the given ReplacementOptions.

pub fn replace_parametrized_type( &mut self, src: &TypeDef, dest_fn: impl Fn(&[TypeArg]) -> Option<Type> + 'static, )

👎Deprecated since 0.25.0:

Use set_replace_parametrized_type

Configures this instance to change occurrences of a parametrized type src via a callback that builds the replacement type given the TypeArgs.

pub fn set_replace_parametrized_type( &mut self, src: &TypeDef, dest_fn: impl Fn(&[TypeArg]) -> Option<Type> + 'static, )

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Configures this instance to change occurrences of a parametrized type src via a callback that builds the replacement type given the TypeArgs.

Note that the TypeArgs will already have been updated (e.g. they may not fit the bounds of the original type). The callback may return None to indicate no change (in which case the supplied TypeArgs will be given to src). The returned type will also be subject to recursive processing by this ReplaceTypes. (Cases where a type should be replaced by a type containing an instance of the first type, must be handled by two separate ReplaceTypes’s via a temporary type. )

If there are any LoadConstants of any of these types, callers should also call Self::replace_consts_parametrized (or Self::replace_consts) as the LoadConstants will be reparameterized (and this will break the edge from Const to LoadConstant). See Self::set_replace_type for more details (including recursion).

pub fn replace_parametrized_type_opts( &mut self, src: &TypeDef, dest_fn: impl Fn(&[TypeArg]) -> Option<Type> + 'static, opts: ReplacementOptions, )

👎Deprecated since 0.25.0:

Use set_replace_parametrized_type

Configures this instance to change occurrences of a parametrized type src via a callback that builds the replacement type given the TypeArgs, and using the given ReplacementOptions.

pub fn linearizer(&mut self) -> &mut DelegatingLinearizer

👎Deprecated since 0.25.0:

Use get_linearizer or linearizer_mut

Allows to configure how to deal with types/wires that were Copyable but have become linear as a result of type-changing.

pub fn linearizer_mut(&mut self) -> &mut DelegatingLinearizer

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Allows to configure how to deal with types/wires that were Copyable but have become linear as a result of type-changing. Specifically, the Linearizer is used whenever lowering produces an outport which both

• has a non-Copyable type - perhaps a direct substitution, or perhaps e.g. as a result of changing the element type of a collection such as an array
• has other than one connected inport,

pub fn get_linearizer(&self) -> &impl Linearizer

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Allows use of the linearizer (e.g. in a callback passed to Self::set_replace_parametrized_op)

pub fn replace_op(&mut self, src: &ExtensionOp, dest: NodeTemplate)

👎Deprecated since 0.25.0:

Use set_replace_op

Configures this instance to change occurrences of src to dest.

pub fn set_replace_op(&mut self, src: &ExtensionOp, dest: NodeTemplate)

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Configures this instance to change occurrences of src to dest.

The RHS will be recursively processed by this ReplaceTypes. (Cases where an op should be replaced by a container including an instance of the same op, must be handled by two separate ReplaceTypes’s via a temporary op.)

Note that if src is an instance of a parametrized OpDef, this takes precedence over Self::set_replace_parametrized_op where the srcs overlap. Thus, this method should only be used for already-monomorphized Hugrs, as substitution (parametric polymorphism) happening later will not respect this replacement.

pub fn replace_op_with( &mut self, src: &ExtensionOp, dest: NodeTemplate, opts: ReplacementOptions, )

👎Deprecated since 0.25.0:

Use set_replace_op

Configures this instance to change occurrences of src to dest.

pub fn replace_parametrized_op( &mut self, src: &OpDef, dest_fn: impl Fn(&[TypeArg]) -> Option<NodeTemplate> + 'static, )

👎Deprecated since 0.25.0:

Use set_replace_parametrized_op

Configures this instance to change occurrences of a parametrized op src via a callback that builds the replacement type given the TypeArgs.

pub fn set_replace_parametrized_op( &mut self, src: &OpDef, dest_fn: impl Fn(&[TypeArg], &ReplaceTypes) -> Result<Option<NodeTemplate>, ReplaceTypesError> + 'static, )

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Configures this instance to change occurrences of a parametrized op src via a callback that builds the replacement type given the TypeArgs. Note that the TypeArgs will already have been updated (e.g. they may not fit the bounds of the original op); and the returned NodeTemplate will be recursively processed by this ReplaceTypes. (Cases where an op should be replaced by a container including an instance of the same op, must be handled by two separate ReplaceTypes’s via a temporary op.)

If the Callback returns None, the new typeargs will be applied to the original op.

pub fn replace_parametrized_op_with( &mut self, src: &OpDef, dest_fn: impl Fn(&[TypeArg]) -> Option<NodeTemplate> + 'static, opts: ReplacementOptions, )

👎Deprecated since 0.25.0:

Use set_replace_parametrized_op

Configures this instance to change occurrences of a parametrized op src via a callback that builds the replacement type given the TypeArgs.

pub fn replace_consts( &mut self, src_ty: CustomType, const_fn: impl Fn(&OpaqueValue, &ReplaceTypes) -> Result<Value, ReplaceTypesError> + 'static, )

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Configures this instance to change Consts of type src_ty, using a callback that is passed the value of the constant (of that type).

Note that if src_ty is an instance of a parametrized TypeDef, this takes precedence over Self::replace_consts_parametrized where the src_tys overlap.

pub fn replace_consts_parametrized( &mut self, src_ty: &TypeDef, const_fn: impl Fn(&OpaqueValue, &ReplaceTypes) -> Result<Option<Value>, ReplaceTypesError> + 'static, )

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Configures this instance to change Consts of all types that are instances of a parametrized typedef src_ty, using a callback that is passed the value of the constant (the OpaqueValue contains the TypeArgs). The callback may return None to indicate no change to the constant.

pub fn set_regions(&mut self, regions: impl IntoIterator<Item = Node>)

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Set the regions of the Hugr to which this pass should be applied.

If not set, the pass is applied to the whole Hugr. Each call overwrites any previous calls to set_regions and/or Self::with_scope.

pub fn change_value(&self, value: &mut Value) -> Result<bool, ReplaceTypesError>

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Modifies the specified Value in-place according to current configuration. Returns whether the value has changed (conservative over-approximation).

Trait Implementations

impl Clone for ReplaceTypes

fn clone(&self) -> ReplaceTypes

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<H: HugrMut<Node = Node>> ComposablePass<H> for ReplaceTypes

type Error = ReplaceTypesError

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Error thrown by this pass.

type Result = bool

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Result returned by this pass.

fn run(&self, hugr: &mut H) -> Result<bool, ReplaceTypesError>

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Run the pass on the given HUGR.

fn map_err<E2: Error>( self, f: impl Fn(Self::Error) -> E2, ) -> impl ComposablePass<H, Result = Self::Result, Error = E2>

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Apply a function to the error type of this pass, returning a new ComposablePass that has the same result type.

fn then<P: ComposablePass<H>, E: ErrorCombiner<Self::Error, P::Error>>( self, other: P, ) -> impl ComposablePass<H, Result = (Self::Result, P::Result), Error = E>

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Returns a ComposablePass that does “self then other”, so long as other::Err can be combined with ours.

impl Default for ReplaceTypes

fn default() -> Self

Returns the “default value” for a type.

impl TypeTransformer for ReplaceTypes

type Err = ReplaceTypesError

Error returned when a CustomType cannot be transformed, or a type containing it (e.g. if changing a runtime type from copyable to linear invalidates a parameterized type).

fn apply_custom(&self, ct: &CustomType) -> Result<Option<Type>, Self::Err>

Applies the transformation to an extension type.

impl WithScope for ReplaceTypes

fn with_scope(self, scope: impl Into<PassScope>) -> Self

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Sets the scope within which the pass will operate. Note that this pass ignores

• PassScope::preserve_interface, as this is a lowering pass: its purpose is to change node signatures.
• PassScope::recursive, as non-recursion generally leads to invalid Hugrs.

Hence, really only the PassScope::root affects the pass.

fn default_with_scope(scope: PassScope) -> Self

where Self: Default,

👎Deprecated since 0.26.2:

hugr-passes is deprecated. Use tket::passes instead

Return a default instance of the pass with the given scope.