oxilean_kernel/match_compile/
functions.rs

1//! Auto-generated module
2//!
3//! 🤖 Generated with [SplitRS](https://github.com/cool-japan/splitrs)
4
5use crate::{Expr, Name};
6use std::collections::HashMap;
7
8use super::types::{
9    CompileResult, ConfigNode, ConstructorInfo, DecisionNode, DecisionTree, Either2,
10    FlatSubstitution, FocusStack, LabelSet, MatchArm, MatchCompiler, MatchStats, NonEmptyVec,
11    PathBuf, Pattern, PatternStats, RewriteRule, RewriteRuleSet, SimpleDag, SlidingSum, SmallMap,
12    SparseVec, StackCalc, StatSummary, Stopwatch, StringPool, TokenBucket, TransformStat,
13    TransitiveClosure, VersionedRecord, WindowIterator, WriteOnce,
14};
15
16#[cfg(test)]
17mod tests {
18    use super::*;
19    #[test]
20    fn test_fresh_var() {
21        let mut compiler = MatchCompiler::new();
22        let v1 = compiler.fresh_var();
23        let v2 = compiler.fresh_var();
24        assert_ne!(v1, v2);
25    }
26    #[test]
27    fn test_check_exhaustive_wildcard() {
28        let mut compiler = MatchCompiler::new();
29        compiler.register_constructors(
30            Name::str("Bool"),
31            vec![
32                ConstructorInfo {
33                    name: Name::str("true"),
34                    num_fields: 0,
35                    inductive: Name::str("Bool"),
36                },
37                ConstructorInfo {
38                    name: Name::str("false"),
39                    num_fields: 0,
40                    inductive: Name::str("Bool"),
41                },
42            ],
43        );
44        assert!(compiler
45            .check_exhaustive(&[Pattern::Wildcard], &Name::str("Bool"))
46            .is_ok());
47    }
48    #[test]
49    fn test_check_exhaustive_all_ctors() {
50        let mut compiler = MatchCompiler::new();
51        compiler.register_constructors(
52            Name::str("Bool"),
53            vec![
54                ConstructorInfo {
55                    name: Name::str("true"),
56                    num_fields: 0,
57                    inductive: Name::str("Bool"),
58                },
59                ConstructorInfo {
60                    name: Name::str("false"),
61                    num_fields: 0,
62                    inductive: Name::str("Bool"),
63                },
64            ],
65        );
66        let patterns = vec![
67            Pattern::Constructor(Name::str("true"), vec![]),
68            Pattern::Constructor(Name::str("false"), vec![]),
69        ];
70        assert!(compiler
71            .check_exhaustive(&patterns, &Name::str("Bool"))
72            .is_ok());
73    }
74    #[test]
75    fn test_check_exhaustive_missing() {
76        let mut compiler = MatchCompiler::new();
77        compiler.register_constructors(
78            Name::str("Bool"),
79            vec![
80                ConstructorInfo {
81                    name: Name::str("true"),
82                    num_fields: 0,
83                    inductive: Name::str("Bool"),
84                },
85                ConstructorInfo {
86                    name: Name::str("false"),
87                    num_fields: 0,
88                    inductive: Name::str("Bool"),
89                },
90            ],
91        );
92        let patterns = vec![Pattern::Constructor(Name::str("true"), vec![])];
93        assert!(compiler
94            .check_exhaustive(&patterns, &Name::str("Bool"))
95            .is_err());
96    }
97    #[test]
98    fn test_check_redundant() {
99        let compiler = MatchCompiler::new();
100        let patterns = vec![
101            Pattern::Constructor(Name::str("true"), vec![]),
102            Pattern::Constructor(Name::str("true"), vec![]),
103            Pattern::Constructor(Name::str("false"), vec![]),
104        ];
105        let redundant = compiler.check_redundant(&patterns);
106        assert_eq!(redundant, vec![1]);
107    }
108    #[test]
109    fn test_check_redundant_after_wildcard() {
110        let compiler = MatchCompiler::new();
111        let patterns = vec![
112            Pattern::Wildcard,
113            Pattern::Constructor(Name::str("true"), vec![]),
114        ];
115        let redundant = compiler.check_redundant(&patterns);
116        assert_eq!(redundant, vec![1]);
117    }
118    #[test]
119    fn test_compile_simple_match() {
120        let mut compiler = MatchCompiler::new();
121        compiler.register_constructors(
122            Name::str("Bool"),
123            vec![
124                ConstructorInfo {
125                    name: Name::str("true"),
126                    num_fields: 0,
127                    inductive: Name::str("Bool"),
128                },
129                ConstructorInfo {
130                    name: Name::str("false"),
131                    num_fields: 0,
132                    inductive: Name::str("Bool"),
133                },
134            ],
135        );
136        let scrutinee = Expr::BVar(0);
137        let arms = vec![
138            MatchArm {
139                patterns: vec![Pattern::Constructor(Name::str("true"), vec![])],
140                rhs: Expr::Lit(crate::Literal::Nat(1)),
141                guard: None,
142            },
143            MatchArm {
144                patterns: vec![Pattern::Constructor(Name::str("false"), vec![])],
145                rhs: Expr::Lit(crate::Literal::Nat(0)),
146                guard: None,
147            },
148        ];
149        let result = compiler
150            .compile_match(&[scrutinee], &arms)
151            .expect("result should be present");
152        assert!(result.unreachable_arms.is_empty());
153        assert!(result.missing_patterns.is_empty());
154    }
155    #[test]
156    fn test_compile_wildcard_match() {
157        let mut compiler = MatchCompiler::new();
158        let scrutinee = Expr::BVar(0);
159        let arms = vec![MatchArm {
160            patterns: vec![Pattern::Wildcard],
161            rhs: Expr::Lit(crate::Literal::Nat(42)),
162            guard: None,
163        }];
164        let result = compiler
165            .compile_match(&[scrutinee], &arms)
166            .expect("result should be present");
167        assert!(result.unreachable_arms.is_empty());
168    }
169    #[test]
170    fn test_pattern_eq() {
171        assert_eq!(Pattern::Wildcard, Pattern::Wildcard);
172        assert_ne!(Pattern::Var(Name::str("x")), Pattern::Var(Name::str("y")));
173        assert_eq!(
174            Pattern::Constructor(Name::str("C"), vec![]),
175            Pattern::Constructor(Name::str("C"), vec![])
176        );
177    }
178}
179/// Compute statistics for a compile result.
180pub fn compute_match_stats(result: &CompileResult, num_arms: usize) -> MatchStats {
181    let referenced: std::collections::HashSet<usize> = referenced_arm_indices(&result.tree);
182    let reachable_arms: Vec<usize> = (0..num_arms).filter(|i| referenced.contains(i)).collect();
183    let unreachable_arms: Vec<usize> = (0..num_arms).filter(|i| !referenced.contains(i)).collect();
184    MatchStats {
185        num_arms,
186        reachable_arms,
187        unreachable_arms: unreachable_arms.clone(),
188        is_exhaustive: result.unreachable_arms.is_empty(),
189        tree_depth: decision_tree_depth(&result.tree),
190    }
191}
192/// Compute the depth of a decision tree.
193pub fn decision_tree_depth(tree: &DecisionTree) -> usize {
194    match tree {
195        DecisionTree::Leaf { .. } => 0,
196        DecisionTree::Failure => 0,
197        DecisionTree::Switch {
198            branches, default, ..
199        } => {
200            let max_case = branches
201                .iter()
202                .map(|(_, _, t)| decision_tree_depth(t))
203                .max()
204                .unwrap_or(0);
205            let default_depth = default
206                .as_ref()
207                .map(|t| decision_tree_depth(t))
208                .unwrap_or(0);
209            1 + max_case.max(default_depth)
210        }
211    }
212}
213/// Count the number of leaf nodes in a decision tree.
214pub fn count_decision_tree_leaves(tree: &DecisionTree) -> usize {
215    match tree {
216        DecisionTree::Leaf { .. } | DecisionTree::Failure => 1,
217        DecisionTree::Switch {
218            branches, default, ..
219        } => {
220            let case_leaves: usize = branches
221                .iter()
222                .map(|(_, _, t)| count_decision_tree_leaves(t))
223                .sum();
224            let default_leaves = default
225                .as_ref()
226                .map(|t| count_decision_tree_leaves(t))
227                .unwrap_or(0);
228            case_leaves + default_leaves
229        }
230    }
231}
232/// Collect all arm indices referenced in a decision tree.
233pub fn referenced_arm_indices(tree: &DecisionTree) -> std::collections::HashSet<usize> {
234    let mut out = std::collections::HashSet::new();
235    collect_refs(tree, &mut out);
236    out
237}
238pub(super) fn collect_refs(tree: &DecisionTree, out: &mut std::collections::HashSet<usize>) {
239    match tree {
240        DecisionTree::Leaf { arm_idx, .. } => {
241            out.insert(*arm_idx);
242        }
243        DecisionTree::Failure => {}
244        DecisionTree::Switch {
245            branches, default, ..
246        } => {
247            for (_, _, t) in branches {
248                collect_refs(t, out);
249            }
250            if let Some(d) = default {
251                collect_refs(d, out);
252            }
253        }
254    }
255}
256/// Check if a pattern is irrefutable (always matches).
257pub fn is_irrefutable_pattern(p: &Pattern) -> bool {
258    match p {
259        Pattern::Wildcard | Pattern::Var(_) => true,
260        Pattern::Constructor(_, sub) => sub.iter().all(is_irrefutable_pattern),
261        Pattern::Literal(_) => false,
262        Pattern::Or(alts) => alts.iter().any(is_irrefutable_pattern),
263        Pattern::As(_, inner) => is_irrefutable_pattern(inner),
264        Pattern::Inaccessible(_) => true,
265    }
266}
267/// Get the constructor name from a pattern (if it is a constructor pattern).
268pub fn pattern_constructor(p: &Pattern) -> Option<&Name> {
269    if let Pattern::Constructor(name, _) = p {
270        Some(name)
271    } else {
272        None
273    }
274}
275/// Get the sub-patterns of a constructor pattern.
276pub fn pattern_subpatterns(p: &Pattern) -> Option<&[Pattern]> {
277    if let Pattern::Constructor(_, sub) = p {
278        Some(sub)
279    } else {
280        None
281    }
282}
283/// Count the number of variable bindings in a pattern.
284pub fn count_pattern_bindings(p: &Pattern) -> usize {
285    match p {
286        Pattern::Var(_) => 1,
287        Pattern::Wildcard | Pattern::Literal(_) | Pattern::Inaccessible(_) => 0,
288        Pattern::Constructor(_, sub) => sub.iter().map(count_pattern_bindings).sum(),
289        Pattern::Or(alts) => alts.iter().map(count_pattern_bindings).min().unwrap_or(0),
290        Pattern::As(_, inner) => 1 + count_pattern_bindings(inner),
291    }
292}
293/// Flatten Or patterns into a flat list of alternatives.
294pub fn flatten_or_patterns(p: &Pattern) -> Vec<&Pattern> {
295    if let Pattern::Or(alts) = p {
296        alts.iter().flat_map(|a| flatten_or_patterns(a)).collect()
297    } else {
298        vec![p]
299    }
300}
301#[cfg(test)]
302mod extended_tests {
303    use super::*;
304    #[test]
305    fn test_is_irrefutable_wildcard() {
306        assert!(is_irrefutable_pattern(&Pattern::Wildcard));
307    }
308    #[test]
309    fn test_is_irrefutable_var() {
310        assert!(is_irrefutable_pattern(&Pattern::Var(Name::str("x"))));
311    }
312    #[test]
313    fn test_is_irrefutable_ctor_false() {
314        let p = Pattern::Constructor(Name::str("Nat.succ"), vec![Pattern::Wildcard]);
315        assert!(is_irrefutable_pattern(&p));
316        let p2 = Pattern::Constructor(
317            Name::str("Nat.succ"),
318            vec![Pattern::Literal(crate::Literal::Nat(0))],
319        );
320        assert!(!is_irrefutable_pattern(&p2));
321    }
322    #[test]
323    fn test_pattern_constructor() {
324        let p = Pattern::Constructor(Name::str("Foo"), vec![]);
325        assert_eq!(pattern_constructor(&p), Some(&Name::str("Foo")));
326        assert_eq!(pattern_constructor(&Pattern::Wildcard), None);
327    }
328    #[test]
329    fn test_pattern_subpatterns() {
330        let sub = vec![Pattern::Wildcard, Pattern::Wildcard];
331        let p = Pattern::Constructor(Name::str("Pair"), sub.clone());
332        assert_eq!(pattern_subpatterns(&p).map(|s| s.len()), Some(2));
333        assert!(pattern_subpatterns(&Pattern::Wildcard).is_none());
334    }
335    #[test]
336    fn test_count_pattern_bindings_var() {
337        assert_eq!(count_pattern_bindings(&Pattern::Var(Name::str("x"))), 1);
338    }
339    #[test]
340    fn test_count_pattern_bindings_ctor() {
341        let p = Pattern::Constructor(
342            Name::str("Pair"),
343            vec![Pattern::Var(Name::str("a")), Pattern::Var(Name::str("b"))],
344        );
345        assert_eq!(count_pattern_bindings(&p), 2);
346    }
347    #[test]
348    fn test_flatten_or_patterns() {
349        let p = Pattern::Or(vec![Pattern::Var(Name::str("x")), Pattern::Wildcard]);
350        let flat = flatten_or_patterns(&p);
351        assert_eq!(flat.len(), 2);
352    }
353    #[test]
354    fn test_decision_tree_depth_leaf() {
355        let tree = DecisionTree::Leaf {
356            arm_idx: 0,
357            bindings: vec![],
358        };
359        assert_eq!(decision_tree_depth(&tree), 0);
360    }
361    #[test]
362    fn test_decision_tree_depth_switch() {
363        let tree = DecisionTree::Switch {
364            scrutinee: crate::Expr::BVar(0),
365            branches: vec![
366                (
367                    Name::str("Nat.zero"),
368                    vec![],
369                    DecisionTree::Leaf {
370                        arm_idx: 0,
371                        bindings: vec![],
372                    },
373                ),
374                (
375                    Name::str("Nat.succ"),
376                    vec![],
377                    DecisionTree::Leaf {
378                        arm_idx: 1,
379                        bindings: vec![],
380                    },
381                ),
382            ],
383            default: None,
384        };
385        assert_eq!(decision_tree_depth(&tree), 1);
386    }
387    #[test]
388    fn test_count_decision_tree_leaves() {
389        let tree = DecisionTree::Switch {
390            scrutinee: crate::Expr::BVar(0),
391            branches: vec![
392                (
393                    Name::str("A"),
394                    vec![],
395                    DecisionTree::Leaf {
396                        arm_idx: 0,
397                        bindings: vec![],
398                    },
399                ),
400                (
401                    Name::str("B"),
402                    vec![],
403                    DecisionTree::Leaf {
404                        arm_idx: 1,
405                        bindings: vec![],
406                    },
407                ),
408            ],
409            default: Some(Box::new(DecisionTree::Failure)),
410        };
411        assert_eq!(count_decision_tree_leaves(&tree), 3);
412    }
413    #[test]
414    fn test_referenced_arm_indices() {
415        let tree = DecisionTree::Switch {
416            scrutinee: crate::Expr::BVar(0),
417            branches: vec![
418                (
419                    Name::str("A"),
420                    vec![],
421                    DecisionTree::Leaf {
422                        arm_idx: 0,
423                        bindings: vec![],
424                    },
425                ),
426                (
427                    Name::str("B"),
428                    vec![],
429                    DecisionTree::Leaf {
430                        arm_idx: 2,
431                        bindings: vec![],
432                    },
433                ),
434            ],
435            default: None,
436        };
437        let refs = referenced_arm_indices(&tree);
438        assert!(refs.contains(&0));
439        assert!(refs.contains(&2));
440        assert!(!refs.contains(&1));
441    }
442}
443/// Check if a pattern is irrefutable (always matches).
444pub fn is_irrefutable(p: &Pattern) -> bool {
445    match p {
446        Pattern::Wildcard | Pattern::Var(_) => true,
447        Pattern::As(_, inner) => is_irrefutable(inner),
448        _ => false,
449    }
450}
451/// Collect all variable names bound in a pattern.
452pub fn pattern_binders(p: &Pattern) -> Vec<Name> {
453    let mut vars = Vec::new();
454    collect_binders(p, &mut vars);
455    vars
456}
457pub(super) fn collect_binders(p: &Pattern, vars: &mut Vec<Name>) {
458    match p {
459        Pattern::Var(n) => vars.push(n.clone()),
460        Pattern::As(n, inner) => {
461            vars.push(n.clone());
462            collect_binders(inner, vars);
463        }
464        Pattern::Constructor(_, pats) | Pattern::Or(pats) => {
465            for sub in pats {
466                collect_binders(sub, vars);
467            }
468        }
469        Pattern::Wildcard | Pattern::Literal(_) | Pattern::Inaccessible(_) => {}
470    }
471}
472/// Count the maximum nesting depth of a pattern.
473pub fn pattern_depth(p: &Pattern) -> usize {
474    match p {
475        Pattern::Wildcard | Pattern::Var(_) | Pattern::Literal(_) | Pattern::Inaccessible(_) => 0,
476        Pattern::As(_, inner) => 1 + pattern_depth(inner),
477        Pattern::Constructor(_, pats) | Pattern::Or(pats) => {
478            1 + pats.iter().map(pattern_depth).max().unwrap_or(0)
479        }
480    }
481}
482#[cfg(test)]
483mod match_compile_extra_tests {
484    use super::*;
485    fn mk_ctor(name: &str, fields: Vec<Pattern>) -> Pattern {
486        Pattern::Constructor(Name::str(name), fields)
487    }
488    #[test]
489    fn test_pattern_stats_wildcards() {
490        let pats = vec![Pattern::Wildcard, Pattern::Var(Name::str("x"))];
491        let stats = PatternStats::from_patterns(&pats);
492        assert_eq!(stats.wildcards, 2);
493        assert_eq!(stats.constructors, 0);
494    }
495    #[test]
496    fn test_pattern_stats_constructors() {
497        let pats = vec![
498            mk_ctor("Nat.zero", vec![]),
499            mk_ctor("Nat.succ", vec![Pattern::Wildcard]),
500        ];
501        let stats = PatternStats::from_patterns(&pats);
502        assert_eq!(stats.constructors, 2);
503        assert_eq!(stats.wildcards, 1);
504    }
505    #[test]
506    fn test_pattern_stats_display() {
507        let stats = PatternStats {
508            total_patterns: 3,
509            wildcards: 1,
510            constructors: 2,
511            ..PatternStats::default()
512        };
513        let txt = format!("{}", stats);
514        assert!(txt.contains("total: 3"));
515    }
516    #[test]
517    fn test_is_irrefutable_wildcard() {
518        assert!(is_irrefutable(&Pattern::Wildcard));
519    }
520    #[test]
521    fn test_is_irrefutable_var() {
522        assert!(is_irrefutable(&Pattern::Var(Name::str("x"))));
523    }
524    #[test]
525    fn test_is_irrefutable_constructor() {
526        assert!(!is_irrefutable(&mk_ctor("C", vec![])));
527    }
528    #[test]
529    fn test_is_irrefutable_as_wildcard() {
530        let p = Pattern::As(Name::str("x"), Box::new(Pattern::Wildcard));
531        assert!(is_irrefutable(&p));
532    }
533    #[test]
534    fn test_pattern_binders_var() {
535        let p = Pattern::Var(Name::str("x"));
536        let binders = pattern_binders(&p);
537        assert_eq!(binders.len(), 1);
538        assert_eq!(binders[0], Name::str("x"));
539    }
540    #[test]
541    fn test_pattern_binders_constructor() {
542        let p = mk_ctor(
543            "Pair",
544            vec![Pattern::Var(Name::str("a")), Pattern::Var(Name::str("b"))],
545        );
546        let binders = pattern_binders(&p);
547        assert_eq!(binders.len(), 2);
548    }
549    #[test]
550    fn test_pattern_depth_wildcard() {
551        assert_eq!(pattern_depth(&Pattern::Wildcard), 0);
552    }
553    #[test]
554    fn test_pattern_depth_constructor() {
555        let p = mk_ctor("C", vec![mk_ctor("D", vec![Pattern::Wildcard])]);
556        assert_eq!(pattern_depth(&p), 2);
557    }
558}
559#[cfg(test)]
560mod tests_padding_infra {
561    use super::*;
562    #[test]
563    fn test_stat_summary() {
564        let mut ss = StatSummary::new();
565        ss.record(10.0);
566        ss.record(20.0);
567        ss.record(30.0);
568        assert_eq!(ss.count(), 3);
569        assert!((ss.mean().expect("mean should succeed") - 20.0).abs() < 1e-9);
570        assert_eq!(ss.min().expect("min should succeed") as i64, 10);
571        assert_eq!(ss.max().expect("max should succeed") as i64, 30);
572    }
573    #[test]
574    fn test_transform_stat() {
575        let mut ts = TransformStat::new();
576        ts.record_before(100.0);
577        ts.record_after(80.0);
578        let ratio = ts.mean_ratio().expect("ratio should be present");
579        assert!((ratio - 0.8).abs() < 1e-9);
580    }
581    #[test]
582    fn test_small_map() {
583        let mut m: SmallMap<u32, &str> = SmallMap::new();
584        m.insert(3, "three");
585        m.insert(1, "one");
586        m.insert(2, "two");
587        assert_eq!(m.get(&2), Some(&"two"));
588        assert_eq!(m.len(), 3);
589        let keys = m.keys();
590        assert_eq!(*keys[0], 1);
591        assert_eq!(*keys[2], 3);
592    }
593    #[test]
594    fn test_label_set() {
595        let mut ls = LabelSet::new();
596        ls.add("foo");
597        ls.add("bar");
598        ls.add("foo");
599        assert_eq!(ls.count(), 2);
600        assert!(ls.has("bar"));
601        assert!(!ls.has("baz"));
602    }
603    #[test]
604    fn test_config_node() {
605        let mut root = ConfigNode::section("root");
606        let child = ConfigNode::leaf("key", "value");
607        root.add_child(child);
608        assert_eq!(root.num_children(), 1);
609    }
610    #[test]
611    fn test_versioned_record() {
612        let mut vr = VersionedRecord::new(0u32);
613        vr.update(1);
614        vr.update(2);
615        assert_eq!(*vr.current(), 2);
616        assert_eq!(vr.version(), 2);
617        assert!(vr.has_history());
618        assert_eq!(*vr.at_version(0).expect("value should be present"), 0);
619    }
620    #[test]
621    fn test_simple_dag() {
622        let mut dag = SimpleDag::new(4);
623        dag.add_edge(0, 1);
624        dag.add_edge(1, 2);
625        dag.add_edge(2, 3);
626        assert!(dag.can_reach(0, 3));
627        assert!(!dag.can_reach(3, 0));
628        let order = dag.topological_sort().expect("order should be present");
629        assert_eq!(order, vec![0, 1, 2, 3]);
630    }
631    #[test]
632    fn test_focus_stack() {
633        let mut fs: FocusStack<&str> = FocusStack::new();
634        fs.focus("a");
635        fs.focus("b");
636        assert_eq!(fs.current(), Some(&"b"));
637        assert_eq!(fs.depth(), 2);
638        fs.blur();
639        assert_eq!(fs.current(), Some(&"a"));
640    }
641}
642#[cfg(test)]
643mod tests_extra_iterators {
644    use super::*;
645    #[test]
646    fn test_window_iterator() {
647        let data = vec![1u32, 2, 3, 4, 5];
648        let windows: Vec<_> = WindowIterator::new(&data, 3).collect();
649        assert_eq!(windows.len(), 3);
650        assert_eq!(windows[0], &[1, 2, 3]);
651        assert_eq!(windows[2], &[3, 4, 5]);
652    }
653    #[test]
654    fn test_non_empty_vec() {
655        let mut nev = NonEmptyVec::singleton(10u32);
656        nev.push(20);
657        nev.push(30);
658        assert_eq!(nev.len(), 3);
659        assert_eq!(*nev.first(), 10);
660        assert_eq!(*nev.last(), 30);
661    }
662}
663#[cfg(test)]
664mod tests_padding2 {
665    use super::*;
666    #[test]
667    fn test_sliding_sum() {
668        let mut ss = SlidingSum::new(3);
669        ss.push(1.0);
670        ss.push(2.0);
671        ss.push(3.0);
672        assert!((ss.sum() - 6.0).abs() < 1e-9);
673        ss.push(4.0);
674        assert!((ss.sum() - 9.0).abs() < 1e-9);
675        assert_eq!(ss.count(), 3);
676    }
677    #[test]
678    fn test_path_buf() {
679        let mut pb = PathBuf::new();
680        pb.push("src");
681        pb.push("main");
682        assert_eq!(pb.as_str(), "src/main");
683        assert_eq!(pb.depth(), 2);
684        pb.pop();
685        assert_eq!(pb.as_str(), "src");
686    }
687    #[test]
688    fn test_string_pool() {
689        let mut pool = StringPool::new();
690        let s = pool.take();
691        assert!(s.is_empty());
692        pool.give("hello".to_string());
693        let s2 = pool.take();
694        assert!(s2.is_empty());
695        assert_eq!(pool.free_count(), 0);
696    }
697    #[test]
698    fn test_transitive_closure() {
699        let mut tc = TransitiveClosure::new(4);
700        tc.add_edge(0, 1);
701        tc.add_edge(1, 2);
702        tc.add_edge(2, 3);
703        assert!(tc.can_reach(0, 3));
704        assert!(!tc.can_reach(3, 0));
705        let r = tc.reachable_from(0);
706        assert_eq!(r.len(), 4);
707    }
708    #[test]
709    fn test_token_bucket() {
710        let mut tb = TokenBucket::new(100, 10);
711        assert_eq!(tb.available(), 100);
712        assert!(tb.try_consume(50));
713        assert_eq!(tb.available(), 50);
714        assert!(!tb.try_consume(60));
715        assert_eq!(tb.capacity(), 100);
716    }
717    #[test]
718    fn test_rewrite_rule_set() {
719        let mut rrs = RewriteRuleSet::new();
720        rrs.add(RewriteRule::unconditional(
721            "beta",
722            "App(Lam(x, b), v)",
723            "b[x:=v]",
724        ));
725        rrs.add(RewriteRule::conditional("comm", "a + b", "b + a"));
726        assert_eq!(rrs.len(), 2);
727        assert_eq!(rrs.unconditional_rules().len(), 1);
728        assert_eq!(rrs.conditional_rules().len(), 1);
729        assert!(rrs.get("beta").is_some());
730        let disp = rrs
731            .get("beta")
732            .expect("element at \'beta\' should exist")
733            .display();
734        assert!(disp.contains("→"));
735    }
736}
737#[cfg(test)]
738mod tests_padding3 {
739    use super::*;
740    #[test]
741    fn test_decision_node() {
742        let tree = DecisionNode::Branch {
743            key: "x".into(),
744            val: "1".into(),
745            yes_branch: Box::new(DecisionNode::Leaf("yes".into())),
746            no_branch: Box::new(DecisionNode::Leaf("no".into())),
747        };
748        let mut ctx = std::collections::HashMap::new();
749        ctx.insert("x".into(), "1".into());
750        assert_eq!(tree.evaluate(&ctx), "yes");
751        ctx.insert("x".into(), "2".into());
752        assert_eq!(tree.evaluate(&ctx), "no");
753        assert_eq!(tree.depth(), 1);
754    }
755    #[test]
756    fn test_flat_substitution() {
757        let mut sub = FlatSubstitution::new();
758        sub.add("foo", "bar");
759        sub.add("baz", "qux");
760        assert_eq!(sub.apply("foo and baz"), "bar and qux");
761        assert_eq!(sub.len(), 2);
762    }
763    #[test]
764    fn test_stopwatch() {
765        let mut sw = Stopwatch::start();
766        sw.split();
767        sw.split();
768        assert_eq!(sw.num_splits(), 2);
769        assert!(sw.elapsed_ms() >= 0.0);
770        for &s in sw.splits() {
771            assert!(s >= 0.0);
772        }
773    }
774    #[test]
775    fn test_either2() {
776        let e: Either2<i32, &str> = Either2::First(42);
777        assert!(e.is_first());
778        let mapped = e.map_first(|x| x * 2);
779        assert_eq!(mapped.first(), Some(84));
780        let e2: Either2<i32, &str> = Either2::Second("hello");
781        assert!(e2.is_second());
782        assert_eq!(e2.second(), Some("hello"));
783    }
784    #[test]
785    fn test_write_once() {
786        let wo: WriteOnce<u32> = WriteOnce::new();
787        assert!(!wo.is_written());
788        assert!(wo.write(42));
789        assert!(!wo.write(99));
790        assert_eq!(wo.read(), Some(42));
791    }
792    #[test]
793    fn test_sparse_vec() {
794        let mut sv: SparseVec<i32> = SparseVec::new(100);
795        sv.set(5, 10);
796        sv.set(50, 20);
797        assert_eq!(*sv.get(5), 10);
798        assert_eq!(*sv.get(50), 20);
799        assert_eq!(*sv.get(0), 0);
800        assert_eq!(sv.nnz(), 2);
801        sv.set(5, 0);
802        assert_eq!(sv.nnz(), 1);
803    }
804    #[test]
805    fn test_stack_calc() {
806        let mut calc = StackCalc::new();
807        calc.push(3);
808        calc.push(4);
809        calc.add();
810        assert_eq!(calc.peek(), Some(7));
811        calc.push(2);
812        calc.mul();
813        assert_eq!(calc.peek(), Some(14));
814    }
815}
oxilean_kernel/match_compile/functions.rs

oxilean_kernel/match_compile/
functions.rs
