Explicit capture for Oct.

Author: yuechen-li-dev

Language/Functions/FunctionValues/invalid/anonymous_function_not_supported.octfail

@@ -0,0 +1,8 @@
+expect error: "function expects Int, but return is Bool"
+
+package Main
+
+fn Main() -> Int {
+    let bad = fn() -> Int { return true }
+    return bad()
+}

Language/Functions/FunctionValues/invalid/anonymous_wrong_return_type.octfail

@@ -0,0 +1,12 @@
+expect error: "cannot assign to captured value 'count'; captures are immutable snapshots"
+
+package Main
+
+fn Main() -> Int {
+    var outer = 1
+    let f = fn() -> Int with { count: outer } {
+        count = count + 1
+        return count
+    }
+    return f()
+}

Language/Functions/FunctionValues/invalid/capture_assignment.octfail

@@ -0,0 +1,10 @@
+expect error: "capture 'x' conflicts with parameter 'x'"
+
+package Main
+
+fn Main() -> Int {
+    let outer = 1
+    let f = fn(x: Int) -> Int with { x: outer } { return x }
+    return f(2)
+}
+

Language/Functions/FunctionValues/invalid/capture_parameter_collision.octfail

@@ -0,0 +1,9 @@
+expect error: "capture 'value': undefined variable: unknownName"
+
+package Main
+
+fn Main() -> Int {
+    let f = fn() -> Int with { value: unknownName } { return value }
+    return f()
+}
+

Language/Functions/FunctionValues/invalid/capture_unknown_name.octfail

@@ -0,0 +1,11 @@
+expect error: "duplicate capture 'value'"
+
+package Main
+
+fn Main() -> Int {
+    let a = 1
+    let b = 2
+    let f = fn() -> Int with { value: a value: b } { return value }
+    return f()
+}
+

Language/Functions/FunctionValues/invalid/duplicate_capture.octfail

@@ -0,0 +1,10 @@
+expect error: "outer local 'offset' is not captured; add it to 'with { ... }'"
+
+package Main
+
+fn Main() -> Int {
+    let offset = 10
+    let add = fn(x: Int) -> Int { return x + offset }
+    return add(5)
+}
+

Language/Functions/FunctionValues/invalid/function_return_type_not_supported.octfail

@@ -0,0 +1,10 @@
+expect error: "outer local 'offset' is not captured; add it to 'with { ... }'"
+
+package Main
+
+fn Make(offset: Int) -> fn(Int) -> Int {
+    return fn(value: Int) -> Int { return value + offset }
+}
+
+fn Main() -> Int { return 0 }
+

Language/Functions/FunctionValues/invalid/implicit_outer_local_capture.octfail

@@ -0,0 +1,111 @@
+package FunctionValuesValid
+
+fn Apply(f: fn(Int) -> Int, value: Int) -> Int {
+    return f(value)
+}
+
+fn Triple(value: Int) -> Int {
+    return value * 3
+}
+
+fn ApplyFallible(f: fn(Int) -> Int ! Error, value: Int) -> Int ! Error {
+    return f(value)?
+}
+
+template fn MakeIdentity<T>() -> fn(T) -> T {
+    return fn(value: T) -> T { return value }
+}
+
+fn MakeAdder(offset: Int) -> fn(Int) -> Int {
+    return fn(x: Int) -> Int with {
+        offset: offset
+    } {
+        return x + offset
+    }
+}
+
+[Fact]
+fn AnonymousFunctionWithoutCaptures() -> Void {
+    let square = fn(x: Int) -> Int {
+        return x * x
+    }
+    Assert.Equal(25, square(5), "anonymous function is callable")
+}
+
+[Fact]
+fn ExplicitCaptureIsRenamedSnapshot() -> Void {
+    var multiplier = 3
+    let scale = fn(x: Int) -> Int with {
+        factor: multiplier
+    } {
+        return x * factor
+    }
+    multiplier = 10
+    Assert.Equal(12, Apply(scale, 4), "capture is evaluated by value at construction")
+}
+
+[Fact]
+fn ArrayCaptureSnapshotsAtConstruction() -> Void {
+    var factors = [2]
+    let scale = fn(value: Int) -> Int with {
+        factors: factors
+    } {
+        return value * factors[0]
+    }
+    factors[0] = 10
+    Assert.Equal(8, scale(4), "captured arrays are value snapshots, not shared cells")
+}
+
+[Fact]
+fn CapturedFunctionEscapesCreatorScope() -> Void {
+    let add10 = MakeAdder(10)
+    Assert.Equal(15, add10(5), "captured environment outlives creator invocation")
+}
+
+[Fact]
+fn NestedFunctionsCaptureExplicitlyAtEachLevel() -> Void {
+    let factor = 3
+    let outer = fn() -> fn(Int) -> Int with {
+        factor: factor
+    } {
+        return fn(x: Int) -> Int with {
+            factor: factor
+        } {
+            return x * factor
+        }
+    }
+    Assert.Equal(12, outer()(4), "nested environments are independently explicit")
+}
+
+[Fact]
+fn PackageFunctionsDoNotRequireCapture() -> Void {
+    let applyTriple = fn(value: Int) -> Int { return Triple(value) }
+    Assert.Equal(12, applyTriple(4), "package function remains globally resolvable")
+}
+
+[Fact]
+fn FallibleAnonymousFunctionMatchesFallibleFunctionType() -> Void ! Error {
+    let nonnegative = fn(value: Int) -> Int ! Error {
+        if value < 0 { return error("negative") }
+        return value
+    }
+    Assert.Equal(4, ApplyFallible(nonnegative, 4)?, "fallible anonymous function is callable")
+}
+
+[Fact]
+fn TemplateElaborationPreservesAnonymousFunction() -> Void {
+    let identity = MakeIdentity<Int>()
+    Assert.Equal(7, identity(7), "template-generated anonymous function works")
+}
+
+[Fact]
+fn CapturedFunctionWorksWithScientificMatrixCallback() -> Void {
+    let base = 10
+    let entry = fn(row: Int, column: Int) -> Int with {
+        base: base
+    } {
+        return base + row + column
+    }
+    let result = Matrix.tabulate(2, 2, entry)
+    Assert.Equal(12, result[1, 1], "captured callback composes with Matrix.tabulate")
+}