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

// Effect System Test: Pure Recursive Functions
// =============================================
//
// What this test validates:
//   - Recursive pure functions are correctly inferred as pure
//   - Self-recursion maintains purity
//   - Mutual recursion between pure functions maintains purity
//   - Base cases and recursive cases both pure -> function is pure
//
// Expected effect inference results:
//   - factorial(n) -> Pure
//   - fibonacci(n) -> Pure
//   - gcd(a, b) -> Pure (Euclidean algorithm)
//   - is_even(n) -> Pure (mutual recursion)
//   - is_odd(n) -> Pure (mutual recursion)
//   - sum_range(start, end) -> Pure

gene Math.Recursive @0.1.0 {
    """
    Recursive pure functions demonstrating that recursion
    does not introduce effects when the function body is pure.
    """

    // Pure: classic factorial with recursion
    // Base case and recursive case both pure
    fn factorial(n: Int) -> Int {
        if n <= 1 {
            1
        } else {
            n * factorial(n - 1)
        }
    }

    // Pure: Fibonacci sequence
    // Multiple recursive calls, still pure
    fn fibonacci(n: Int) -> Int {
        if n <= 0 {
            0
        } else if n == 1 {
            1
        } else {
            fibonacci(n - 1) + fibonacci(n - 2)
        }
    }

    // Pure: Greatest Common Divisor (Euclidean algorithm)
    // Recursive with modulo operation
    fn gcd(a: Int, b: Int) -> Int {
        if b == 0 {
            a
        } else {
            gcd(b, a % b)
        }
    }

    // Pure: Mutual recursion - is_even
    fn is_even(n: Int) -> Bool {
        if n == 0 {
            true
        } else {
            is_odd(n - 1)
        }
    }

    // Pure: Mutual recursion - is_odd
    fn is_odd(n: Int) -> Bool {
        if n == 0 {
            false
        } else {
            is_even(n - 1)
        }
    }

    // Pure: Sum of range [start, end)
    fn sum_range(start: Int, end: Int) -> Int {
        if start >= end {
            0
        } else {
            start + sum_range(start + 1, end)
        }
    }

    // Pure: Ackermann function (deeply recursive)
    fn ackermann(m: Int, n: Int) -> Int {
        if m == 0 {
            n + 1
        } else if n == 0 {
            ackermann(m - 1, 1)
        } else {
            ackermann(m - 1, ackermann(m, n - 1))
        }
    }
}

// Test assertions for effect inference
test effects {
    assert_pure(Math.Recursive.factorial);
    assert_pure(Math.Recursive.fibonacci);
    assert_pure(Math.Recursive.gcd);
    assert_pure(Math.Recursive.is_even);
    assert_pure(Math.Recursive.is_odd);
    assert_pure(Math.Recursive.sum_range);
    assert_pure(Math.Recursive.ackermann);
}