nodety 0.1.1

Easy to use library for node editor types, generics, inference and validation
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

//! This module provides the functionality to determine which nodes are suitable for connecting to a certain port.
//! It can be used to tell users which nodes they can use to connect to a certain port.
use crate::{
    nodety::inference::{Flow, Flows, InferenceConfig},
    scope::{Scope, ScopePointer},
    r#type::Type,
    type_expr::ScopedTypeExpr,
};

/// Determines whether or not a connection between an input and output port is valid.
pub fn is_compatible<T: Type>(
    output: &ScopedTypeExpr<T>,
    input: &ScopedTypeExpr<T>,
    output_scope: Scope<T>,
    input_scope: Scope<T>,
) -> bool {
    let output_scope_pointer = ScopePointer::new(output_scope);
    let input_scope_pointer = ScopePointer::new(input_scope);

    let flows = Flows {
        flows: vec![Flow {
            source: output,
            target: input,
            source_scope: ScopePointer::clone(&output_scope_pointer),
            target_scope: ScopePointer::clone(&input_scope_pointer),
        }],
    };

    flows.infer(InferenceConfig::default());

    output_scope_pointer.infer_defaults();
    input_scope_pointer.infer_defaults();

    input.supertype_of(output, &input_scope_pointer, &output_scope_pointer).is_supertype()
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::notation::parse::{expr, scope};

    #[test]
    fn test_is_compatible() {
        assert!(is_compatible(&expr("Any"), &expr("Any"), scope("<>"), scope("<>")));

        assert!(is_compatible(&expr("Integer"), &expr("Any"), scope("<>"), scope("<>")));

        assert!(!is_compatible(&expr("Any"), &expr("Integer"), scope("<>"), scope("<>")));

        assert!(is_compatible(&expr("T"), &expr("T"), scope("<T>"), scope("<T>")));

        assert!(is_compatible(&expr("Array<T>"), &expr("T"), scope("<T>"), scope("<T>")));

        assert!(is_compatible(&expr("Array<T>"), &expr("Array<T>"), scope("<T>"), scope("<T>")));

        assert!(!is_compatible(
            &expr("T"),
            &expr("T"),
            scope("<T extends Array<Integer>>"),
            scope("<T extends Integer>"),
        ));
    }
}