qubit-function 0.18.0

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

// =============================================================================
//    Copyright (c) 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================
#![cfg(feature = "full")]

//! Tests for public re-exports from the crate root and module roots.

fn assert_type_is_exported<T>(expected_name: &str) {
    let type_name = std::any::type_name::<T>();
    assert!(
        type_name.contains(expected_name),
        "expected `{type_name}` to contain `{expected_name}`"
    );
}

#[test]
fn test_root_exports_conditional_consumer_types() {
    assert_type_is_exported::<qubit_function::BoxConditionalConsumer<i32>>(
        "BoxConditionalConsumer",
    );
    assert_type_is_exported::<qubit_function::RcConditionalConsumer<i32>>(
        "RcConditionalConsumer",
    );
    assert_type_is_exported::<qubit_function::ArcConditionalConsumer<i32>>(
        "ArcConditionalConsumer",
    );
    assert_type_is_exported::<qubit_function::BoxConditionalConsumerOnce<i32>>(
        "BoxConditionalConsumerOnce",
    );
    assert_type_is_exported::<qubit_function::BoxConditionalBiConsumer<i32, i64>>(
        "BoxConditionalBiConsumer",
    );
    assert_type_is_exported::<qubit_function::RcConditionalBiConsumer<i32, i64>>(
        "RcConditionalBiConsumer",
    );
    assert_type_is_exported::<qubit_function::ArcConditionalBiConsumer<i32, i64>>(
        "ArcConditionalBiConsumer",
    );
    assert_type_is_exported::<
        qubit_function::BoxConditionalBiConsumerOnce<i32, i64>,
    >("BoxConditionalBiConsumerOnce");
    assert_type_is_exported::<
        qubit_function::BoxConditionalStatefulConsumer<i32>,
    >("BoxConditionalStatefulConsumer");
    assert_type_is_exported::<qubit_function::RcConditionalStatefulConsumer<i32>>(
        "RcConditionalStatefulConsumer",
    );
    assert_type_is_exported::<
        qubit_function::ArcConditionalStatefulConsumer<i32>,
    >("ArcConditionalStatefulConsumer");
    assert_type_is_exported::<
        qubit_function::BoxConditionalStatefulBiConsumer<i32, i64>,
    >("BoxConditionalStatefulBiConsumer");
    assert_type_is_exported::<
        qubit_function::RcConditionalStatefulBiConsumer<i32, i64>,
    >("RcConditionalStatefulBiConsumer");
    assert_type_is_exported::<
        qubit_function::ArcConditionalStatefulBiConsumer<i32, i64>,
    >("ArcConditionalStatefulBiConsumer");
}

#[test]
fn test_root_exports_conditional_function_types() {
    assert_type_is_exported::<
        qubit_function::BoxConditionalFunctionOnce<i32, i64>,
    >("BoxConditionalFunctionOnce");
    assert_type_is_exported::<
        qubit_function::BoxConditionalBiFunctionOnce<i32, i64, String>,
    >("BoxConditionalBiFunctionOnce");
    assert_type_is_exported::<
        qubit_function::BoxConditionalMutatingFunction<i32, i64>,
    >("BoxConditionalMutatingFunction");
    assert_type_is_exported::<
        qubit_function::RcConditionalMutatingFunction<i32, i64>,
    >("RcConditionalMutatingFunction");
    assert_type_is_exported::<
        qubit_function::ArcConditionalMutatingFunction<i32, i64>,
    >("ArcConditionalMutatingFunction");
    assert_type_is_exported::<
        qubit_function::BoxConditionalMutatingFunctionOnce<i32, i64>,
    >("BoxConditionalMutatingFunctionOnce");
    assert_type_is_exported::<
        qubit_function::BoxConditionalStatefulMutatingFunction<i32, i64>,
    >("BoxConditionalStatefulMutatingFunction");
    assert_type_is_exported::<
        qubit_function::RcConditionalStatefulMutatingFunction<i32, i64>,
    >("RcConditionalStatefulMutatingFunction");
    assert_type_is_exported::<
        qubit_function::ArcConditionalStatefulMutatingFunction<i32, i64>,
    >("ArcConditionalStatefulMutatingFunction");
}

#[test]
fn test_root_exports_conditional_transformer_types() {
    assert_type_is_exported::<
        qubit_function::BoxConditionalBiTransformer<i32, i64, String>,
    >("BoxConditionalBiTransformer");
    assert_type_is_exported::<
        qubit_function::RcConditionalBiTransformer<i32, i64, String>,
    >("RcConditionalBiTransformer");
    assert_type_is_exported::<
        qubit_function::ArcConditionalBiTransformer<i32, i64, String>,
    >("ArcConditionalBiTransformer");
    assert_type_is_exported::<
        qubit_function::BoxConditionalBiTransformerOnce<i32, i64, String>,
    >("BoxConditionalBiTransformerOnce");
}

#[test]
fn test_module_roots_export_conditional_types() {
    assert_type_is_exported::<
        qubit_function::consumers::BoxConditionalConsumer<i32>,
    >("BoxConditionalConsumer");
    assert_type_is_exported::<
        qubit_function::consumers::ArcConditionalStatefulBiConsumer<i32, i64>,
    >("ArcConditionalStatefulBiConsumer");
    assert_type_is_exported::<
        qubit_function::functions::BoxConditionalFunctionOnce<i32, i64>,
    >("BoxConditionalFunctionOnce");
    assert_type_is_exported::<
        qubit_function::functions::ArcConditionalStatefulMutatingFunction<
            i32,
            i64,
        >,
    >("ArcConditionalStatefulMutatingFunction");
    assert_type_is_exported::<
        qubit_function::transformers::BoxConditionalBiTransformerOnce<
            i32,
            i64,
            String,
        >,
    >("BoxConditionalBiTransformerOnce");
    assert_type_is_exported::<
        qubit_function::transformers::RcConditionalBiTransformer<
            i32,
            i64,
            String,
        >,
    >("RcConditionalBiTransformer");
}

#[test]
fn test_root_exports_stateful_bi_predicate_types() {
    assert_type_is_exported::<qubit_function::BoxStatefulBiPredicate<i32, i64>>(
        "BoxStatefulBiPredicate",
    );
    assert_type_is_exported::<qubit_function::RcStatefulBiPredicate<i32, i64>>(
        "RcStatefulBiPredicate",
    );
    assert_type_is_exported::<qubit_function::ArcStatefulBiPredicate<i32, i64>>(
        "ArcStatefulBiPredicate",
    );
}

#[test]
fn test_root_exports_tester_types() {
    fn assert_tester<T: qubit_function::Tester>() {}

    assert_tester::<qubit_function::BoxTester>();
    assert_tester::<qubit_function::RcTester>();
    assert_tester::<qubit_function::ArcTester>();
    assert_type_is_exported::<qubit_function::BoxTester>("BoxTester");
    assert_type_is_exported::<qubit_function::RcTester>("RcTester");
    assert_type_is_exported::<qubit_function::ArcTester>("ArcTester");
}

#[test]
fn test_root_exports_stateful_tester_types() {
    fn assert_stateful_tester<T: qubit_function::StatefulTester>() {}

    assert_stateful_tester::<qubit_function::BoxStatefulTester>();
    assert_stateful_tester::<qubit_function::RcStatefulTester>();
    assert_stateful_tester::<qubit_function::ArcStatefulTester>();
    assert_type_is_exported::<qubit_function::BoxStatefulTester>(
        "BoxStatefulTester",
    );
    assert_type_is_exported::<qubit_function::RcStatefulTester>(
        "RcStatefulTester",
    );
    assert_type_is_exported::<qubit_function::ArcStatefulTester>(
        "ArcStatefulTester",
    );
}