qubit-function 0.18.2

Functional programming traits and Box/Rc/Arc adapters for Rust, inspired by Java functional interfaces
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

// =============================================================================
//    Copyright (c) 2025 - 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================
//! # Transformer Common Methods Macro
//!
//! Provides macros that generate common constructor and name-management
//! methods for one-input and two-input transformers. One-input transformers
//! also receive an `identity` constructor.

/// Generates constructor methods for supported transformer types.
///
/// The target type selects the underlying transformer trait and its bounds;
/// the wrapper expression adapts the supplied closure to the target's storage.
/// This helper is invoked inside the target type's `impl` block by
/// [`impl_transformer_common_methods`].
///
/// The closure-trait token group is retained in the invocation syntax, while
/// this macro selects bounds from the target type.
macro_rules! impl_transformer_new_methods {
    (BoxTransformer<$t:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@one Transformer, $t, $r, ('static), |$f| $w); };
    (RcTransformer<$t:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@one Transformer, $t, $r, ('static), |$f| $w); };
    (ArcTransformer<$t:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@one Transformer, $t, $r, (Send + Sync + 'static), |$f| $w); };
    (BoxStatefulTransformer<$t:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@one_mut StatefulTransformer, $t, $r, ('static), |$f| $w); };
    (RcStatefulTransformer<$t:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@one_mut StatefulTransformer, $t, $r, ('static), |$f| $w); };
    (ArcStatefulTransformer<$t:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@one_mut StatefulTransformer, $t, $r, (Send + 'static), |$f| $w); };
    (BoxTransformerOnce<$t:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@one TransformerOnce, $t, $r, ('static), |$f| $w); };
    (BoxBiTransformer<$t:ident, $u:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@two BiTransformer, $t, $u, $r, ('static), |$f| $w); };
    (RcBiTransformer<$t:ident, $u:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@two BiTransformer, $t, $u, $r, ('static), |$f| $w); };
    (ArcBiTransformer<$t:ident, $u:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@two BiTransformer, $t, $u, $r, (Send + Sync + 'static), |$f| $w); };
    (BoxStatefulBiTransformer<$t:ident, $u:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@two_mut StatefulBiTransformer, $t, $u, $r, ('static), |$f| $w); };
    (RcStatefulBiTransformer<$t:ident, $u:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@two_mut StatefulBiTransformer, $t, $u, $r, ('static), |$f| $w); };
    (ArcStatefulBiTransformer<$t:ident, $u:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@two_mut StatefulBiTransformer, $t, $u, $r, (Send + 'static), |$f| $w); };
    (BoxBiTransformerOnce<$t:ident, $u:ident, $r:ident>, |$f:ident| $w:expr) => { $crate::transformers::macros::impl_transformer_new_methods!(@two BiTransformerOnce, $t, $u, $r, ('static), |$f| $w); };
    (@one $tr:ident, $t:ident, $r:ident, ($($b:tt)+), |$f:ident| $w:expr) => { crate::macros::impl_common_new_methods!(semantic ($tr<$t, $r> + $($b)+), |source| move |input: $t| source.apply(input), |$f| $w, "transformer"); };
    (@one_mut $tr:ident, $t:ident, $r:ident, ($($b:tt)+), |$f:ident| $w:expr) => { crate::macros::impl_common_new_methods!(semantic_mut ($tr<$t, $r> + $($b)+), |source| move |input: $t| source.apply(input), |$f| $w, "transformer"); };
    (@two $tr:ident, $t:ident, $u:ident, $r:ident, ($($b:tt)+), |$f:ident| $w:expr) => { crate::macros::impl_common_new_methods!(semantic ($tr<$t, $u, $r> + $($b)+), |source| move |first: $t, second: $u| source.apply(first, second), |$f| $w, "bi-transformer"); };
    (@two_mut $tr:ident, $t:ident, $u:ident, $r:ident, ($($b:tt)+), |$f:ident| $w:expr) => { crate::macros::impl_common_new_methods!(semantic_mut ($tr<$t, $u, $r> + $($b)+), |source| move |first: $t, second: $u| source.apply(first, second), |$f| $w, "bi-transformer"); };
}

/// Generates constructor and name-management methods for a transformer type.
///
/// The macro selects an implementation based on whether the target transforms
/// one input or two. Single-input transformers also receive an `identity`
/// constructor; two-input transformers do not. Invoke it inside the target
/// type's `impl` block.
///
/// # Parameters
///
/// * `$struct_name<$generics>` - Transformer type and its generic parameters
/// * `$fn_trait_with_bounds` - Closure-trait bounds associated with the type
/// * `$wrapper_expr` - Expression that wraps the closure (using `f`)
///
/// # Usage
///
/// ```ignore
/// impl_transformer_common_methods!(
///     BoxTransformer<T, U>,
///     (Fn(&T) -> U + 'static),
///     |f| Box::new(f)
/// );
/// ```
///
/// The generated methods include `new`, `new_with_name`,
/// `new_with_optional_name`, `name`, and `set_name`. For single-input
/// transformers, the macro also generates `identity`.
macro_rules! impl_transformer_common_methods {
    // Single generic parameter - Transformer types
    (
        $struct_name:ident < $t:ident, $u:ident >,
        ($($fn_trait_with_bounds:tt)+),
        |$f:ident| $wrapper_expr:expr
    ) => {
        $crate::transformers::macros::impl_transformer_new_methods!($struct_name<$t, $u>, |$f| $wrapper_expr);

        /// Creates an identity transformer.
        ///
        /// Creates a transformer that returns the input value unchanged. Useful for
        /// default values or placeholder implementations.
        ///
        /// # Returns
        ///
        /// Returns a new transformer instance that returns the input unchanged.
        #[inline]
        pub fn identity() -> $struct_name<$t, $t> {
            $struct_name::<$t, $t>::new(|t: $t| t)
        }

        crate::macros::impl_common_name_methods!("transformer");
    };

    // Two generic parameters - BiTransformer types
    (
        $struct_name:ident < $t:ident, $u:ident, $v:ident >,
        ($($fn_trait_with_bounds:tt)+),
        |$f:ident| $wrapper_expr:expr
    ) => {
        $crate::transformers::macros::impl_transformer_new_methods!($struct_name<$t, $u, $v>, |$f| $wrapper_expr);

        crate::macros::impl_common_name_methods!("bi-transformer");
    };
}

pub(crate) use impl_transformer_common_methods;
pub(crate) use impl_transformer_new_methods;