get closures working

Author: nakajima

Sources/slips/Closure.swift

@@ -0,0 +1,16 @@
+//
+//  Closure.swift
+//  Slips
+//
+//  Created by Pat Nakajima on 7/24/24.
+//
+
+public class Closure {
+	let funcExpr: FuncExpr
+	let environment: Scope
+
+	init(funcExpr: FuncExpr, environment: Scope) {
+		self.funcExpr = funcExpr
+		self.environment = environment
+	}
+}

Sources/slips/Exprs/FuncExpr.swift

@@ -7,7 +7,7 @@
 
 public struct FuncExpr: Expr {
 	public let params: ParamsExpr
-	public let body: [any Expr]
+	public let body: any Expr
 
 	public func accept<V>(_ visitor: V, _ scope: Scope) -> V.Value where V: Visitor {
 		visitor.visit(self, scope)

Sources/slips/Lexer.swift

@@ -15,7 +15,7 @@ public struct Token {
 		case int, float, string, identifier
 
 		// Keywords
-		case def, `true`, `false`, `if`, `in`
+		case def, `true`, `false`, `if`, `in`, call
 
 		case eof
 		case error
@@ -89,6 +89,7 @@ public struct Lexer {
 		case "false": make(.false)
 		case "if": make(.if)
 		case "in": make(.in)
+		case "call": make(.call)
 		default:
 			make(.identifier)
 		}

Sources/slips/Parser.swift

@@ -75,6 +75,10 @@ public struct Parser {
 			return defExpr()
 		}
 
+		if match(.call) {
+			return callExpr()
+		}
+
 		if match(.identifier) {
 			return callOrFuncExpr()
 		}
@@ -117,15 +121,10 @@ public struct Parser {
 	}
 
 	mutating func funcExpr(parameters: [Token]) -> Expr {
-		var exprs: [Expr] = []
-
-		while !check(.rightParen), !check(.eof) {
-			exprs.append(expr())
-		}
-
+		let body = expr()
 		_ = consume(.rightParen)
 
-		return FuncExpr(params: ParamsExpr(names: parameters.map(\.lexeme)), body: exprs)
+		return FuncExpr(params: ParamsExpr(names: parameters.map(\.lexeme)), body: body)
 	}
 
 	mutating func addExpr() -> Expr {

Sources/slips/Scope.swift

@@ -6,7 +6,7 @@
 //
 
 public class Scope {
-	let parent: Scope?
+	var parent: Scope?
 	var locals: [String: Value] = [:]
 
 	init(parent: Scope? = nil) {
@@ -19,6 +19,6 @@ public class Scope {
 	}
 
 	func lookup(_ name: String) -> Value {
-		return locals[name] ?? .none
+		return locals[name] ?? parent?.lookup(name) ?? .none
 	}
 }

Sources/slips/Value.swift

@@ -6,7 +6,7 @@
 //
 
 public enum Value: Equatable {
-	case int(Int), string(String), bool(Bool), none, error(String), fn(FuncExpr)
+	case int(Int), string(String), bool(Bool), none, error(String), fn(Closure)
 
 	public static func == (lhs: Value, rhs: Value) -> Bool {
 		switch lhs {
@@ -32,12 +32,12 @@ public enum Value: Equatable {
 			return false
 		case .error:
 			return false
-		case let .fn(fn):
+		case let .fn(closure):
 			guard case let .fn(rhs) = rhs else {
 				return false
 			}
 
-			return fn.body.map { $0.accept(Formatter(), Scope()) } == rhs.body.map { $0.accept(Formatter(), Scope()) }
+			return closure.funcExpr.body.accept(Formatter(), Scope()) == rhs.funcExpr.body.accept(Formatter(), Scope())
 		}
 	}
 

Sources/slips/Visitors/Compiler.swift

@@ -0,0 +1,18 @@
+//
+//  Compiler.swift
+//
+//
+//  Created by Pat Nakajima on 7/24/24.
+//
+
+public struct Compiler {
+	let source: String
+
+	public init(_ source: String) {
+		self.source = source
+	}
+
+	public func run() -> Value {
+		.none
+	}
+}

Sources/slips/Visitors/Formatter.swift

@@ -20,8 +20,8 @@ public struct Formatter: Visitor {
 
 	public func visit(_ expr: LiteralExpr, _ scope: Scope) -> String {
 		switch expr.value {
-		case let .fn(fn):
-			"fn: \(fn.body.map { $0.accept(self, scope) }.joined(separator: " "))"
+		case let .fn(closure):
+			"fn: \(closure.funcExpr.body.accept(self, scope))"
 		case let .bool(bool):
 			"\(bool)"
 		case let .int(int):
@@ -48,7 +48,7 @@ public struct Formatter: Visitor {
 	}
 
 	public func visit(_ expr: FuncExpr, _ scope: Scope) -> String {
-		"(\(visit(expr.params, scope)) in \(expr.body.map { $0.accept(self, scope) }.joined(separator: " ")))"
+		"(\(visit(expr.params, scope)) in \(expr.body.accept(self, scope)))"
 	}
 
 	public func visit(_ expr: ParamsExpr, _: Scope) -> String {

Sources/slips/Visitors/Interpreter.swift

@@ -51,19 +51,16 @@ public struct Interpreter: Visitor {
 	}
 
 	public func visit(_ expr: CallExpr, _ scope: Scope) -> Value {
-		if case let .fn(fn) = scope.lookup(expr.op.lexeme) {
-			let innerScope = Scope(parent: scope)
-
-			for (i, argument) in expr.args.enumerated() {
-				_ = innerScope.define(fn.params.names[i], argument.accept(self, innerScope))
-			}
-
-			var lastReturn: Value = .none
-			for expr in fn.body {
-				lastReturn = expr.accept(self, innerScope)
+		if expr.op.kind == .call {
+			if case let .fn(closure) = expr.args[0].accept(self, scope) {
+				return call(closure, args: Array(expr.args[1 ..< expr.args.count]), scope)
+			} else {
+				fatalError("\(expr.args[0].accept(self, scope)) is not callable")
 			}
+		}
 
-			return lastReturn
+		if case let .fn(closure) = scope.lookup(expr.op.lexeme) {
+			return call(closure, args: expr.args, scope)
 		} else {
 			fatalError("\(expr.op.lexeme) not callable")
 		}
@@ -82,7 +79,7 @@ public struct Interpreter: Visitor {
 	}
 
 	public func visit(_ expr: VarExpr, _ scope: Scope) -> Value {
-		scope.locals[expr.name] ?? .none
+		scope.lookup(expr.name)
 	}
 
 	public func visit(_ expr: IfExpr, _ scope: Scope) -> Value {
@@ -95,8 +92,8 @@ public struct Interpreter: Visitor {
 		}
 	}
 
-	public func visit(_ expr: FuncExpr, _: Scope) -> Value {
-		.fn(expr)
+	public func visit(_ expr: FuncExpr, _ scope: Scope) -> Value {
+		.fn(Closure(funcExpr: expr, environment: scope))
 	}
 
 	public func visit(_: ParamsExpr, _: Scope) -> Value {
@@ -105,6 +102,20 @@ public struct Interpreter: Visitor {
 
 	private
 
+	func call(_ closure: Closure, args: [any Expr], _ scope: Scope) -> Value {
+		let innerScope = Scope(parent: scope)
+
+		for (name, value) in closure.environment.locals {
+			_ = innerScope.define(name, value)
+		}
+
+		for (i, argument) in args.enumerated() {
+			_ = innerScope.define(closure.funcExpr.params.names[i], argument.accept(self, innerScope))
+		}
+
+		return closure.funcExpr.body.accept(self, innerScope)
+	}
+
 	func runtimeError(_ err: String) {
 		fatalError(err)
 	}

Tests/SlipsTests/CompilerTests.swift

@@ -0,0 +1,48 @@
+//
+//  CompilerTests.swift
+//
+//
+//  Created by Pat Nakajima on 7/22/24.
+//
+
+import Slips
+import Testing
+
+struct CompilerTests {
+	@Test("Compiles literals") func literals() {
+		#expect(Compiler("1").run() == .int(1))
+		#expect(Compiler("(2)").run() == .int(2))
+	}
+
+	@Test("Compiles strings") func strings() {
+		#expect(Compiler("'sup'").run() == .string("sup"))
+		#expect(Compiler("('sup')").run() == .string("sup"))
+	}
+
+	@Test("Compiles add") func add() {
+		#expect(Compiler("(+ 1 2)").run() == .int(3))
+		#expect(Compiler("(+ 'fizz' 'buzz')").run() == .string("fizzbuzz"))
+	}
+
+	@Test("Compiles multiple") func multiple() {
+		#expect(Compiler("""
+		(def a 1)
+		(def b 2)
+		(+ a b)
+		""").run() == .int(3))
+	}
+
+	@Test("Compiles if") func ifEval() {
+		#expect(Compiler("""
+		(if true (def a 1) (def b 2))
+		a
+		""").run() == .int(1))
+	}
+
+	@Test("Compiles functions") func functions() {
+		#expect(Compiler("""
+		(def addtwo (x in (+ x 2)))
+		(addtwo 2)
+		""").run() == .int(4))
+	}
+}