ucg 0.8.0

A configuration generation grammar.
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

// The list of base types for a UCG value.
let base_types = [
    "int",
    "float",
    "str",
    "bool",
    "null",
    "tuple",
    "list",
    "func",
    "module",
];

// Computes the base type of a value.
let base_type_of = func (val) => reduce(func (acc, f) => select ((acc.val is f), f) => {
    true = acc{typ = f},
    false = acc,
}, {val=val, typ="null"}, base_types).typ;

// Turns any schema check module into a compile failure.
// The module must export the computed value as the result field.
let must = func (m, msg) => select (m, fail msg) => {
    true = m,
};

// All does a boolean match against all of set of allowed shapes for a type.
// This module uses the shape module below so the same rules for checking
// the types against the source value apply for each example in the list.
//
// This module does partial matches for the shapes.
let all = module {
    // The source value to check.
    val=NULL,
    // The set of allowed type shapes it can be.
    types=[],
} => (result) {
    let schema = mod.pkg();

    let reducer = func (acc, t) => acc{
        ok = acc.ok && (schema.shaped{val=acc.val, shape=t, partial=true}),
    };
    let any = func (val, types) => reduce(reducer, {ok=true, val=val}, types);

    let result = any(mod.val, mod.types).ok;
};

// Any does a boolean match against a set of allowed shapes for a type.
// This module uses the shape module below so the same rules for checking
// the types against the source value apply for each example in the list.
//
// This module does not do partial matches for the shapes by default.
let any = module {
    // The source value to check.
    val=NULL,
    // The set of allowed type shapes it can be.
    types=[],
    // Whether to do partial matches for the shapes
    partial=false
} => (result) {
    let schema = mod.pkg();

    let reducer = func (acc, t) => acc{
        ok = acc.ok || (schema.shaped{val=acc.val, shape=t, partial=mod.partial}),
    };
    let any = func (val, types) => reduce(reducer, {ok=false, val=val}, types);

    let result = any(mod.val, mod.types).ok;
};

// Compares a value against an example schema value. compares the "shape" of the
// value to see if it matches. The base type must be the same as the base type
// of the shape. For tuples any field in the shape tuple must be present in the 
// source value and must be of the same base type and shape. This module will
// recurse into nested tuples.
// 
// Lists are must contain types from the list shape they are compared against.
// and empty list shape means the list val can have any types it wants inside.
//
// We do not check that functions or modules have the same argument lengths or types
// nor we check that they output the same types.
let shaped = module {
    // The source value to validate
    val = NULL,
    
    // The shape to validate it against.
    shape = NULL,
    
    // Whether partial matches are accepted.
    // When set to true then the source value can have
    // fields in tuples that are not present in the
    // shape it is compared with.
    partial = true,
} => (result) {
    let schema = mod.pkg();
    let this = mod.this;

    let simple_handler = func (val, shape) => val is schema.base_type_of(shape);

    let tuple_handler = func (acc, name, value) => acc{
        ok = select ((name) in acc.shape, mod.partial) => {
            true = this{val=value, shape=acc.shape.(name), partial=mod.partial},
        },
    };

    let shape_tuple_handler = func (acc, field_name, value) => acc{
        ok = select ((field_name) in acc.val, false) => {
            true = this{val=value, shape=acc.val.(field_name), partial=false},
        },
    };

    let match_shape_fields = func(val, shape) => reduce(
        shape_tuple_handler, {val=val, ok=false}, shape).ok;
 
    let match_tuple_fields = func(val, shape) =>
        reduce(tuple_handler, {shape=shape, ok=false}, val).ok;

    let list_handler = func(acc, value) => acc{
        ok = acc.ok && schema.any{val=value, types=acc.shape},
    };

    let result = select (schema.base_type_of(mod.val), false) => {
        str = simple_handler(mod.val, mod.shape),
        int = simple_handler(mod.val, mod.shape),
        float = simple_handler(mod.val, mod.shape),
        bool = simple_handler(mod.val, mod.shape),
        null = simple_handler(mod.val, mod.shape), 
        tuple = (mod.shape is "tuple") &&
                match_shape_fields(mod.val, mod.shape) &&
                match_tuple_fields(mod.val, mod.shape), 
        list = (mod.shape is "list") && select (mod.shape == [], true) => {
            false = reduce(list_handler, {shape=mod.shape, ok=true}, mod.val).ok,
        },
        func = simple_handler(mod.val, mod.shape),
        module = simple_handler(mod.val, mod.shape),
    };
};