feat: add De Bruijn indexed reduction engine

Add a new interpreter option (-i debruijn) that uses De Bruijn indices
for variable representation, eliminating the need for variable renaming
during substitution.

- Add -i flag to select interpreter (lambda or debruijn)
- Create debruijn package with Expression types (Variable with index,
  Abstraction without parameter, Application)
- Implement shift and substitute operations for De Bruijn indices
- Add conversion functions between lambda and De Bruijn representations
- Update CLI to support switching between interpreters
- Add De Bruijn tests to verify all samples pass

Closes #26

pkg/convert/debruijn_to_lambda.go

@@ -0,0 +1,82 @@
+package convert
+
+import (
+	"fmt"
+
+	"git.maximhutz.com/max/lambda/pkg/debruijn"
+	"git.maximhutz.com/max/lambda/pkg/lambda"
+	"git.maximhutz.com/max/lambda/pkg/set"
+)
+
+// DeBruijnToLambda converts a De Bruijn indexed expression back to named lambda calculus.
+func DeBruijnToLambda(expr debruijn.Expression) lambda.Expression {
+	return deBruijnToLambdaWithContext(expr, []string{})
+}
+
+func deBruijnToLambdaWithContext(expr debruijn.Expression, context []string) lambda.Expression {
+	switch e := expr.(type) {
+	case *debruijn.Variable:
+		index := e.Index()
+		if index < len(context) {
+			// Bound variable: look up name in context.
+			name := context[len(context)-1-index]
+			return lambda.NewVariable(name)
+		}
+		// Free variable: use the label if available.
+		if e.Label() != "" {
+			return lambda.NewVariable(e.Label())
+		}
+		// Generate a name for free variables without labels.
+		return lambda.NewVariable(fmt.Sprintf("free%d", index))
+
+	case *debruijn.Abstraction:
+		// Generate a fresh parameter name.
+		used := collectUsedNames(e.Body(), context)
+		paramName := generateFreshName(used)
+		newContext := append(context, paramName)
+		body := deBruijnToLambdaWithContext(e.Body(), newContext)
+		return lambda.NewAbstraction(paramName, body)
+
+	case *debruijn.Application:
+		abs := deBruijnToLambdaWithContext(e.Abstraction(), context)
+		arg := deBruijnToLambdaWithContext(e.Argument(), context)
+		return lambda.NewApplication(abs, arg)
+
+	default:
+		panic("unknown expression type")
+	}
+}
+
+// collectUsedNames gathers all variable labels used in an expression.
+func collectUsedNames(expr debruijn.Expression, context []string) *set.Set[string] {
+	used := set.New[string]()
+	for _, name := range context {
+		used.Add(name)
+	}
+	collectUsedNamesHelper(expr, used)
+	return used
+}
+
+func collectUsedNamesHelper(expr debruijn.Expression, used *set.Set[string]) {
+	switch e := expr.(type) {
+	case *debruijn.Variable:
+		if e.Label() != "" {
+			used.Add(e.Label())
+		}
+	case *debruijn.Abstraction:
+		collectUsedNamesHelper(e.Body(), used)
+	case *debruijn.Application:
+		collectUsedNamesHelper(e.Abstraction(), used)
+		collectUsedNamesHelper(e.Argument(), used)
+	}
+}
+
+// generateFreshName creates a fresh variable name not in the used set.
+func generateFreshName(used *set.Set[string]) string {
+	for i := 0; ; i++ {
+		name := fmt.Sprintf("_%d", i)
+		if !used.Has(name) {
+			return name
+		}
+	}
+}

pkg/convert/lambda_to_debruijn.go

@@ -0,0 +1,44 @@
+package convert
+
+import (
+	"git.maximhutz.com/max/lambda/pkg/debruijn"
+	"git.maximhutz.com/max/lambda/pkg/lambda"
+)
+
+// LambdaToDeBruijn converts a lambda calculus expression to De Bruijn indexed form.
+// The context parameter tracks bound variables from outer abstractions.
+func LambdaToDeBruijn(expr lambda.Expression) debruijn.Expression {
+	return lambdaToDeBruijnWithContext(expr, []string{})
+}
+
+func lambdaToDeBruijnWithContext(expr lambda.Expression, context []string) debruijn.Expression {
+	switch e := expr.(type) {
+	case *lambda.Variable:
+		name := e.Value()
+		// Search for the variable in the context (innermost to outermost).
+		for i := len(context) - 1; i >= 0; i-- {
+			if context[i] == name {
+				index := len(context) - 1 - i
+				return debruijn.NewVariable(index, name)
+			}
+		}
+		// Free variable: use a negative index to mark it.
+		// We encode free variables with index = len(context) + position.
+		// For simplicity, we use a large index that won't conflict.
+		return debruijn.NewVariable(len(context), name)
+
+	case *lambda.Abstraction:
+		// Add the parameter to the context.
+		newContext := append(context, e.Parameter())
+		body := lambdaToDeBruijnWithContext(e.Body(), newContext)
+		return debruijn.NewAbstraction(body)
+
+	case *lambda.Application:
+		abs := lambdaToDeBruijnWithContext(e.Abstraction(), context)
+		arg := lambdaToDeBruijnWithContext(e.Argument(), context)
+		return debruijn.NewApplication(abs, arg)
+
+	default:
+		panic("unknown expression type")
+	}
+}