qubit-function 0.15.0

Functional programming traits and Box/Rc/Arc adapters for Rust, inspired by Java functional interfaces
Documentation 
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

/*******************************************************************************
 *
 *    Copyright (c) 2026 Haixing Hu.
 *
 *    SPDX-License-Identifier: Apache-2.0
 *
 *    Licensed under the Apache License, Version 2.0.
 *
 ******************************************************************************/

//! 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");
}