seq-compiler 5.6.2

Compiler for the Seq programming language
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

use super::*;
use crate::types::{Effect, StackType, Type};

fn make_stack(types: &[Type]) -> StackType {
    let mut stack = StackType::Empty;
    for t in types {
        stack = StackType::Cons {
            rest: Box::new(stack),
            top: t.clone(),
        };
    }
    stack
}

fn make_effect(inputs: &[Type], outputs: &[Type]) -> Effect {
    Effect {
        inputs: make_stack(inputs),
        outputs: make_stack(outputs),
        effects: Vec::new(),
    }
}

#[test]
fn test_extract_empty_stack() {
    let types = extract_concrete_types(&StackType::Empty);
    assert!(types.is_empty());
}

#[test]
fn test_extract_single_type() {
    let stack = make_stack(&[Type::Int]);
    let types = extract_concrete_types(&stack);
    assert_eq!(types, vec![Type::Int]);
}

#[test]
fn test_extract_multiple_types() {
    let stack = make_stack(&[Type::Int, Type::String, Type::Bool]);
    let types = extract_concrete_types(&stack);
    assert_eq!(types, vec![Type::Int, Type::String, Type::Bool]);
}

#[test]
fn test_calculate_no_captures() {
    // Body needs (Int -- Int), call provides (Int -- Int)
    let body = make_effect(&[Type::Int], &[Type::Int]);
    let call = make_effect(&[Type::Int], &[Type::Int]);

    let captures = calculate_captures(&body, &call).unwrap();
    assert!(captures.is_empty());
}

#[test]
fn test_calculate_one_capture() {
    // Body needs (Int Int -- Int), call provides (Int -- Int)
    // Should capture one Int
    let body = make_effect(&[Type::Int, Type::Int], &[Type::Int]);
    let call = make_effect(&[Type::Int], &[Type::Int]);

    let captures = calculate_captures(&body, &call).unwrap();
    assert_eq!(captures, vec![Type::Int]);
}

#[test]
fn test_calculate_multiple_captures() {
    // Body needs (Int String Bool -- Bool), call provides (Bool -- Bool)
    // Should capture [Int, String] (bottom to top)
    let body = make_effect(&[Type::Int, Type::String, Type::Bool], &[Type::Bool]);
    let call = make_effect(&[Type::Bool], &[Type::Bool]);

    let captures = calculate_captures(&body, &call).unwrap();
    assert_eq!(captures, vec![Type::Int, Type::String]);
}

#[test]
fn test_calculate_all_captured() {
    // Body needs (Int String -- Int), call provides ( -- Int)
    // Should capture [Int, String]
    let body = make_effect(&[Type::Int, Type::String], &[Type::Int]);
    let call = make_effect(&[], &[Type::Int]);

    let captures = calculate_captures(&body, &call).unwrap();
    assert_eq!(captures, vec![Type::Int, Type::String]);
}

#[test]
fn test_calculate_error_too_many_call_inputs() {
    // Body needs (Int -- Int), call provides (Int Int -- Int)
    // Error: call provides more than body needs
    let body = make_effect(&[Type::Int], &[Type::Int]);
    let call = make_effect(&[Type::Int, Type::Int], &[Type::Int]);

    let result = calculate_captures(&body, &call);
    assert!(result.is_err());
    assert!(
        result
            .unwrap_err()
            .contains("provides 2 values but body only needs 1")
    );
}