Merge pull request #61 from DanexCodr/copilot/implement-lambda-recursion-syntax

Enforce ALL_CAPS constant semantics and add `<~CONST(...)` self-call level support

Author: DanexCodr

source_.jar

@@ -0,0 +1,14 @@
+unit test
+
+share AutoCurrying {
+    share main() {
+        sum := [1, 2, 3, 4].reduce(\(acc) \(value) acc + value, 0)
+        out("sum=" + sum)
+
+        withIndex := [5, 6, 7].reduce(\(acc) \(value) \(idx) acc + value + idx, 0)
+        out("withIndex=" + withIndex)
+
+        classic := [1, 2, 3, 4].reduce(\(acc, value) acc + value, 0)
+        out("classic=" + classic)
+    }
+}

src/main/cod/src/main/test/AutoCurrying.cod

@@ -0,0 +1,9 @@
+unit test
+
+share ConstantReassignmentInvalid {
+    share main() {
+        LIMIT := 5
+        LIMIT = 6
+        out(LIMIT)
+    }
+}

src/main/cod/src/main/test/ConstantReassignmentInvalid.cod

@@ -0,0 +1,8 @@
+unit test
+
+share ConstantRequiresInitializerInvalid {
+    share main() {
+        LIMIT: int
+        out(LIMIT)
+    }
+}

src/main/cod/src/main/test/ConstantRequiresInitializerInvalid.cod

@@ -0,0 +1,11 @@
+unit test
+
+share SelfCallInvalidNoParentheses {
+    local bad(n: int) :: result: int {
+        ~> result: <~ + n
+    }
+
+    share main() {
+        out([result]:bad(1))
+    }
+}

src/main/cod/src/main/test/SelfCallInvalidNoParentheses.cod

@@ -0,0 +1,16 @@
+unit test
+
+share SelfCallLambda {
+    share main() {
+        n := 6
+        recursiveResult := 0
+        recursiveResult = [result]:\(n: int) :: result: int {
+            if n <= 1 {
+                ~> result: 1
+            }
+            ~> result: n * <~(n - 1)
+        }
+
+        out("lambda=" + recursiveResult)
+    }
+}

src/main/cod/src/main/test/SelfCallLambda.cod

@@ -0,0 +1,32 @@
+unit test
+
+share SelfCallLambdaConstantLevel {
+    share main() {
+        SELF := 0
+        PARENT := 1
+
+        a := 2
+        result := 0
+        result = [result]:\(a: int) :: result: int {
+            if a <= 0 {
+                ~> result: 0
+            }
+
+            b := a
+            inner := 0
+            inner = [result]:\(b: int) :: result: int {
+                if b <= 0 {
+                    ~> result: 0
+                }
+
+                same := <~SELF(b - 1)
+                up := <~PARENT(b - 1)
+                ~> result: b + same + up
+            }
+
+            ~> result: inner
+        }
+
+        out("const-level=" + result)
+    }
+}

src/main/cod/src/main/test/SelfCallLambdaConstantLevel.cod

@@ -0,0 +1,42 @@
+unit test
+
+share SelfCallLambdaLevels {
+    share main() {
+        a := 2
+        levels := 0
+        levels = [result]:\(a: int) :: result: int {
+            if a <= 0 {
+                ~> result: 0
+            }
+
+            b := a
+            mid := 0
+            mid = [result]:\(b: int) :: result: int {
+                if b <= 0 {
+                    ~> result: 0
+                }
+
+                c := b
+                inner := 0
+                inner = [result]:\(c: int) :: result: int {
+                    if c <= 0 {
+                        ~> result: 0
+                    }
+
+                    selfShortcut := <~(c - 1)
+                    selfExplicit := <~0(c - 1)
+                    parent := <~1(c - 1)
+                    grandparent := <~2(c - 1)
+
+                    ~> result: c + selfShortcut + selfExplicit + parent + grandparent
+                }
+
+                ~> result: inner
+            }
+
+            ~> result: mid
+        }
+
+        out("levels=" + levels)
+    }
+}

src/main/cod/src/main/test/SelfCallLambdaLevels.cod

@@ -0,0 +1,15 @@
+unit test
+
+share SelfCallLevelConstantInMethodInvalid {
+    local bad(n: int) :: result: int {
+        LEVEL := 0
+        if n < 2 {
+            ~> result: 1
+        }
+        ~> result: n * <~LEVEL(n - 1)
+    }
+
+    share main() {
+        out([result]:bad(4))
+    }
+}

src/main/cod/src/main/test/SelfCallLevelConstantInMethodInvalid.cod

@@ -0,0 +1,14 @@
+unit test
+
+share SelfCallLevelInMethodInvalid {
+    local bad(n: int) :: result: int {
+        if n < 2 {
+            ~> result: 1
+        }
+        ~> result: n * <~0(n - 1)
+    }
+
+    share main() {
+        out([result]:bad(4))
+    }
+}