dol 0.8.1

DOL (Design Ontology Language) - A declarative specification language for ontology-first development
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

// Effect System Test: Transitive Linear Chain
// ============================================
//
// What this test validates:
//   - Effects propagate through a linear chain of function calls
//   - A pure function calling an effectful function becomes effectful
//   - Effect propagation works through multiple levels of indirection
//
// Expected effect inference results:
//   - level_0_pure() -> Pure
//   - level_1_calls_pure() -> Pure
//   - level_2_calls_pure() -> Pure
//   - base_effectful() -> Effectful(IO)
//   - level_1_calls_effectful() -> Effectful(IO)
//   - level_2_calls_effectful() -> Effectful(IO)
//   - level_3_calls_effectful() -> Effectful(IO)

gene Chain.Pure @0.1.0 {
    """
    A chain of pure functions calling other pure functions.
    The entire chain remains pure.
    """

    // Level 0: base pure function
    fn level_0_pure(x: Int) -> Int {
        x * 2
    }

    // Level 1: calls level 0 (pure) -> remains pure
    fn level_1_calls_pure(x: Int) -> Int {
        level_0_pure(x) + 1
    }

    // Level 2: calls level 1 (pure) -> remains pure
    fn level_2_calls_pure(x: Int) -> Int {
        level_1_calls_pure(x) + level_1_calls_pure(x)
    }

    // Level 3: calls level 2 (pure) -> remains pure
    fn level_3_calls_pure(x: Int) -> Int {
        level_2_calls_pure(x) * level_2_calls_pure(x)
    }

    // Level 4: calls level 3 (pure) -> remains pure
    fn level_4_calls_pure(x: Int) -> Int {
        level_3_calls_pure(x) - level_0_pure(x)
    }
}

gene Chain.Effectful @0.1.0 {
    """
    A chain where the base function is effectful.
    All callers become effectful through transitive propagation.
    """

    // Level 0: base effectful function (IO)
    fn base_effectful(x: Int) -> Int {
        @io.println("Computing with: " + @fmt.int(x));
        x * 2
    }

    // Level 1: calls base_effectful -> becomes effectful
    fn level_1_calls_effectful(x: Int) -> Int {
        base_effectful(x) + 1
    }

    // Level 2: calls level 1 -> becomes effectful (transitive)
    fn level_2_calls_effectful(x: Int) -> Int {
        level_1_calls_effectful(x) + level_1_calls_effectful(x)
    }

    // Level 3: calls level 2 -> becomes effectful (transitive)
    fn level_3_calls_effectful(x: Int) -> Int {
        level_2_calls_effectful(x) * 2
    }

    // Level 4: calls level 3 -> becomes effectful (transitive)
    fn level_4_calls_effectful(x: Int) -> Int {
        level_3_calls_effectful(x) - x
    }

    // Level 5: calls level 4 -> becomes effectful (transitive)
    fn level_5_calls_effectful(x: Int) -> Int {
        level_4_calls_effectful(x) / 2
    }
}

gene Chain.Mixed @0.1.0 {
    """
    A chain that starts pure but introduces effects at some level.
    Functions above the effect introduction point remain pure,
    functions at or below become effectful.
    """

    // Pure: no effects
    fn pure_helper(x: Int) -> Int {
        x + 100
    }

    // Pure: calls pure_helper
    fn another_pure(x: Int) -> Int {
        pure_helper(x) * 2
    }

    // Effectful: introduces IO effect mid-chain
    fn introduces_effect(x: Int) -> Int {
        let intermediate = another_pure(x);
        @io.println("Intermediate: " + @fmt.int(intermediate));
        intermediate
    }

    // Effectful: calls introduces_effect
    fn after_effect_1(x: Int) -> Int {
        introduces_effect(x) + 1
    }

    // Effectful: calls after_effect_1
    fn after_effect_2(x: Int) -> Int {
        after_effect_1(x) + after_effect_1(x + 1)
    }
}

// Test assertions for effect inference
test effects {
    // Pure chain remains pure
    assert_pure(Chain.Pure.level_0_pure);
    assert_pure(Chain.Pure.level_1_calls_pure);
    assert_pure(Chain.Pure.level_2_calls_pure);
    assert_pure(Chain.Pure.level_3_calls_pure);
    assert_pure(Chain.Pure.level_4_calls_pure);

    // Effectful chain - effects propagate
    assert_effectful(Chain.Effectful.base_effectful, IO);
    assert_effectful(Chain.Effectful.level_1_calls_effectful, IO);
    assert_effectful(Chain.Effectful.level_2_calls_effectful, IO);
    assert_effectful(Chain.Effectful.level_3_calls_effectful, IO);
    assert_effectful(Chain.Effectful.level_4_calls_effectful, IO);
    assert_effectful(Chain.Effectful.level_5_calls_effectful, IO);

    // Mixed chain - effects start at introduction point
    assert_pure(Chain.Mixed.pure_helper);
    assert_pure(Chain.Mixed.another_pure);
    assert_effectful(Chain.Mixed.introduces_effect, IO);
    assert_effectful(Chain.Mixed.after_effect_1, IO);
    assert_effectful(Chain.Mixed.after_effect_2, IO);
}