style: scanner not lexer

.golangci.yml

@@ -48,7 +48,7 @@ linters:
       # More information: https://golangci-lint.run/usage/false-positives/#comments
       #
       # Please uncomment the following line if your code is not using the godoc format
-      # - comments
+      - comments
 
       # Common false positives
       # feel free to remove this if you don't have any false positives
@@ -126,9 +126,6 @@ linters:
         # Blank import should be only in a main or test package, or have a comment justifying it.
         - name: blank-imports
 
-        # Packages should have comments of the form "Package x ...".
-        - name: package-comments
-
         # context.Context() should be the first parameter of a function when provided as argument.
         - name: context-as-argument
           arguments:

Makefile

@@ -1,53 +1,30 @@
 BINARY_NAME=lambda
-TEST=simple
 
-.PHONY: help build run profile explain graph docs test bench lint clean
+.PHONY: help build docs test bench clean
 .DEFAULT_GOAL := help
 .SILENT:
 
 help:
 	echo "Available targets:"
 	echo "  build    - Build the lambda executable"
-	echo "  run      - Build and run the lambda runtime (use TEST=<name> to specify sample)"
-	echo "  profile  - Build and run with CPU profiling enabled"
-	echo "  explain  - Build and run with explanation mode and profiling"
-	echo "  graph    - Generate and open CPU profile visualization"
 	echo "  docs     - Start local godoc server on port 6060"
-	echo "  test     - Run tests for all samples"
-	echo "  bench    - Run benchmarks for all samples"
-	echo "  lint     - Run golangci-lint on all packages"
+	echo "  test     - Run tests"
+	echo "  bench    - Run benchmarks"
 	echo "  clean    - Remove all build artifacts"
 
 build:
 	go build -o ${BINARY_NAME} ./cmd/lambda
 	chmod +x ${BINARY_NAME}
 
-run: build
-	./${BINARY_NAME} -s -f ./tests/$(TEST).test -o program.out
-
-profile: build
-	./${BINARY_NAME} -p profile/cpu.prof -f ./tests/$(TEST).test -o program.out
-
-explain: build
-	./${BINARY_NAME} -x -p profile/cpu.prof -f ./tests/$(TEST).test -o program.out > explain.out
-
-graph:
-	go tool pprof -raw -output=profile/cpu.raw profile/cpu.prof
-	go tool pprof -svg profile/cpu.prof > profile/cpu.svg
-	echo ">>> View at 'file://$(PWD)/profile/cpu.svg'"
-
 docs:
 	echo ">>> View at 'http://localhost:6060/pkg/git.maximhutz.com/max/lambda/'"
 	go run golang.org/x/tools/cmd/godoc@latest -http=:6060
 
 test:
-	go test -v ./cmd/lambda
+	go test -v ./...
 
 bench:
-	go test -bench=. -benchtime=10x -cpu=4 ./cmd/lambda
-
-lint:
-	go run github.com/golangci/golangci-lint/v2/cmd/golangci-lint@latest run ./...
+	go test -bench=. -benchtime=10x -cpu=4 ./...
 
 clean:
 	rm -f ${BINARY_NAME}

cmd/lambda/convert.go

@@ -0,0 +1,30 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var convertCmd = &cobra.Command{
+	Use:   "convert [input] [output]",
+	Short: "Convert between lambda calculus representations",
+	Long: `Convert lambda calculus expressions between different representations.
+
+The format is inferred from file extensions when possible.
+Use --from and --to flags to override format detection.`,
+	Example: `  lambda convert input.sch output.dbi
+  lambda convert input.txt output.txt --from saccharine --to lambda`,
+	Args: cobra.ExactArgs(2),
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Fprintln(os.Stderr, "not implemented")
+		os.Exit(1)
+	},
+}
+
+func init() {
+	convertCmd.Flags().String("from", "", "source format")
+	convertCmd.Flags().String("to", "", "target format")
+	rootCmd.AddCommand(convertCmd)
+}

cmd/lambda/engine.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var engineCmd = &cobra.Command{
+	Use:   "engine",
+	Short: "List available evaluation engines",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Fprintln(os.Stderr, "not implemented")
+		os.Exit(1)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(engineCmd)
+}

cmd/lambda/lambda.go

@@ -1,94 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-
-	"git.maximhutz.com/max/lambda/internal/config"
-	"github.com/spf13/cobra"
-)
-
-func Lambda() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "lambda",
-		Short: "Lambda calculus interpreter",
-		Long:  "A lambda calculus interpreter supporting multiple representations.",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			// Legacy behavior when no subcommand is given.
-			options, err := config.FromArgs()
-			if err != nil {
-				return err
-			}
-
-			logger := options.GetLogger()
-			logger.Info("using program arguments", "args", os.Args)
-			logger.Info("parsed CLI options", "options", options)
-
-			r := GetRegistry()
-
-			// Get input.
-			input, err := options.Source.Extract()
-			if err != nil {
-				return err
-			}
-
-			// Parse code into syntax tree.
-			repr, err := r.Unmarshal(input, "saccharine")
-			if err != nil {
-				return err
-			}
-			logger.Info("parsed syntax tree", "tree", repr)
-
-			// Compile expression to lambda calculus.
-			compiled, err := r.ConvertTo(repr, "lambda")
-			if err != nil {
-				return err
-			}
-			logger.Info("compiled λ expression", "tree", compiled)
-
-			// Create reducer with the compiled expression.
-			engine, err := r.GetDefaultEngine("lambda")
-			if err != nil {
-				return err
-			}
-
-			process := engine.Load()
-			err = process.Set(compiled)
-			if err != nil {
-				return err
-			}
-
-			// Run reduction.
-			for process.Step(1) {
-			}
-
-			// Return the final reduced result.
-			result, err := process.Get()
-			if err != nil {
-				return err
-			}
-
-			output, err := r.Marshal(result)
-			if err != nil {
-				return err
-			}
-
-			return options.Destination.Write(output)
-		},
-	}
-
-	cmd.PersistentFlags().BoolP("verbose", "v", false, "Enable verbose output")
-
-	cmd.AddCommand(LambdaConvert())
-	cmd.AddCommand(LambdaEngine())
-
-	return cmd
-}
-
-func main() {
-	lambda := Lambda()
-	if err := lambda.Execute(); err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		os.Exit(1)
-	}
-}

cmd/lambda/lambda_convert.go

@@ -1,100 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"git.maximhutz.com/max/lambda/internal/cli"
-	"github.com/spf13/cobra"
-	"github.com/spf13/viper"
-)
-
-// inferReprFromPath returns the repr type based on file extension.
-func inferReprFromPath(path string) (string, error) {
-	switch ext := strings.ToLower(filepath.Ext(path)); ext {
-	case ".lam", ".lambda":
-		return "lambda", nil
-	case ".sac", ".saccharine":
-		return "saccharine", nil
-	default:
-		return "", fmt.Errorf("unknown file extension '%s'", ext)
-	}
-}
-
-func LambdaConvert() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "convert <input> <output>",
-		Short: "Convert between lambda calculus representations",
-		Args:  cobra.ExactArgs(2),
-		RunE: func(cmd *cobra.Command, args []string) error {
-			inputPath := args[0]
-			outputPath := args[1]
-
-			// Infer repr types from extensions.
-			inputRepr, err := inferReprFromPath(inputPath)
-			if err != nil {
-				return fmt.Errorf("input file: %w", err)
-			}
-
-			outputRepr, err := inferReprFromPath(outputPath)
-			if err != nil {
-				return fmt.Errorf("output file: %w", err)
-			}
-
-			// Read input file.
-			input, err := os.ReadFile(inputPath)
-			if err != nil {
-				return fmt.Errorf("reading input file: %w", err)
-			}
-
-			r := GetRegistry()
-
-			// Parse input into syntax tree.
-			repr, err := r.Unmarshal(string(input), inputRepr)
-			if err != nil {
-				return fmt.Errorf("parsing input: %w", err)
-			}
-
-			if viper.GetBool("verbose") {
-				fmt.Fprintf(os.Stderr, "Parsed %s from %s\n", inputRepr, inputPath)
-			}
-
-			// Convert to output repr if different.
-			var result cli.Repr
-			if inputRepr != outputRepr {
-				result, err = r.ConvertTo(repr, outputRepr)
-				if err != nil {
-					return fmt.Errorf("converting %s to %s: %w", inputRepr, outputRepr, err)
-				}
-
-				if viper.GetBool("verbose") {
-					fmt.Fprintf(os.Stderr, "Converted to %s\n", outputRepr)
-				}
-			} else {
-				result = repr
-			}
-
-			// Marshal output.
-			output, err := r.Marshal(result)
-			if err != nil {
-				return fmt.Errorf("marshaling output: %w", err)
-			}
-
-			// Write output file.
-			err = os.WriteFile(outputPath, []byte(output), 0644)
-			if err != nil {
-				return fmt.Errorf("writing output file: %w", err)
-			}
-
-			if viper.GetBool("verbose") {
-				fmt.Fprintf(os.Stderr, "Wrote %s to %s\n", outputRepr, outputPath)
-			}
-
-			return nil
-		},
-	}
-
-	return cmd
-}

cmd/lambda/lambda_engine.go

@@ -1,19 +0,0 @@
-package main
-
-import (
-	"github.com/spf13/cobra"
-)
-
-func LambdaEngine() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:   "engine",
-		Short: "Information about available engines",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			return cmd.Help()
-		},
-	}
-
-	cmd.AddCommand(LambdaEngineList())
-
-	return cmd
-}

cmd/lambda/lambda_engine_list.go

@@ -1,26 +0,0 @@
-package main
-
-import (
-	"fmt"
-
-	"github.com/spf13/cobra"
-)
-
-func LambdaEngineList() *cobra.Command {
-	cmd := &cobra.Command{
-		Use:     "list",
-		Aliases: []string{"ls"},
-		Short:   "List available engines",
-		RunE: func(cmd *cobra.Command, args []string) error {
-			r := GetRegistry()
-
-			for engine := range r.ListEngines() {
-				fmt.Println(engine.Name())
-			}
-
-			return nil
-		},
-	}
-
-	return cmd
-}

cmd/lambda/registry.go

@@ -1,26 +0,0 @@
-package main
-
-import (
-	"git.maximhutz.com/max/lambda/internal/cli"
-	"git.maximhutz.com/max/lambda/internal/registry"
-	"git.maximhutz.com/max/lambda/pkg/convert"
-	"git.maximhutz.com/max/lambda/pkg/engine/normalorder"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-	"git.maximhutz.com/max/lambda/pkg/saccharine"
-)
-
-func GetRegistry() *registry.Registry {
-	r := registry.New()
-
-	// Codecs
-	r.MustAddConversions(cli.ConvertCodec(convert.Saccharine2Lambda{}, "saccharine", "lambda")...)
-
-	// Engines
-	r.MustAddEngine(cli.ConvertEngine(normalorder.Engine{}, "normalorder", "lambda"))
-
-	// Marshalers
-	r.MustAddMarshaler(cli.ConvertMarshaler(lambda.Marshaler{}, "lambda"))
-	r.MustAddMarshaler(cli.ConvertMarshaler(saccharine.Marshaler{}, "saccharine"))
-
-	return r
-}

cmd/lambda/repl.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var replCmd = &cobra.Command{
+	Use:   "repl",
+	Short: "Start an interactive lambda calculus REPL",
+	Long: `Start an interactive Read-Eval-Print Loop for lambda calculus.
+
+Enter lambda expressions to evaluate them.
+Type 'exit' or 'quit' to leave the REPL.
+Press Ctrl+D to exit.`,
+	Example: `  lambda repl`,
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Fprintln(os.Stderr, "not implemented")
+		os.Exit(1)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(replCmd)
+}

cmd/lambda/repr.go

@@ -0,0 +1,21 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var reprCmd = &cobra.Command{
+	Use:   "repr",
+	Short: "List available representations",
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Fprintln(os.Stderr, "not implemented")
+		os.Exit(1)
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(reprCmd)
+}

cmd/lambda/root.go

@@ -0,0 +1,19 @@
+package main
+
+import (
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var rootCmd = &cobra.Command{
+	Use:   "lambda",
+	Short: "A lambda calculus interpreter and toolkit",
+	Long:  `Lambda is a CLI tool for working with lambda calculus expressions.`,
+}
+
+func main() {
+	if err := rootCmd.Execute(); err != nil {
+		os.Exit(1)
+	}
+}

cmd/lambda/run.go

@@ -0,0 +1,31 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var runCmd = &cobra.Command{
+	Use:   "run [expression]",
+	Short: "Evaluate a lambda calculus expression",
+	Long: `Evaluate a lambda calculus expression and print the result.
+
+The expression can be provided as an argument, read from a file with --file,
+or piped through stdin.`,
+	Example: `  lambda run "\x.x"
+  echo "\x.x" | lambda run
+  lambda run --file program.sch
+  lambda run --file program.sch --engine krivine`,
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Fprintln(os.Stderr, "not implemented")
+		os.Exit(1)
+	},
+}
+
+func init() {
+	runCmd.Flags().StringP("file", "f", "", "read expression from file")
+	runCmd.Flags().StringP("engine", "e", "normal", "evaluation engine to use")
+	rootCmd.AddCommand(runCmd)
+}

cmd/lambda/trace.go

@@ -0,0 +1,28 @@
+package main
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/spf13/cobra"
+)
+
+var traceCmd = &cobra.Command{
+	Use:   "trace [file]",
+	Short: "Trace the evaluation of a lambda calculus expression",
+	Long: `Trace the step-by-step evaluation of a lambda calculus expression.
+
+This command shows each reduction step during evaluation.`,
+	Example: `  lambda trace program.sch
+  lambda trace program.sch --engine krivine`,
+	Args: cobra.ExactArgs(1),
+	Run: func(cmd *cobra.Command, args []string) {
+		fmt.Fprintln(os.Stderr, "not implemented")
+		os.Exit(1)
+	},
+}
+
+func init() {
+	traceCmd.Flags().StringP("engine", "e", "normal", "evaluation engine to use")
+	rootCmd.AddCommand(traceCmd)
+}

go.mod

@@ -6,21 +6,9 @@ require github.com/stretchr/testify v1.11.1
 
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/fsnotify/fsnotify v1.9.0 // indirect
-	github.com/go-viper/mapstructure/v2 v2.4.0 // indirect
 	github.com/inconshreveable/mousetrap v1.1.0 // indirect
-	github.com/pelletier/go-toml/v2 v2.2.4 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	github.com/sagikazarmark/locafero v0.11.0 // indirect
-	github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 // indirect
-	github.com/spf13/afero v1.15.0 // indirect
-	github.com/spf13/cast v1.10.0 // indirect
 	github.com/spf13/cobra v1.10.2 // indirect
-	github.com/spf13/pflag v1.0.10 // indirect
-	github.com/spf13/viper v1.21.0 // indirect
-	github.com/subosito/gotenv v1.6.0 // indirect
-	go.yaml.in/yaml/v3 v3.0.4 // indirect
-	golang.org/x/sys v0.29.0 // indirect
-	golang.org/x/text v0.28.0 // indirect
+	github.com/spf13/pflag v1.0.9 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,42 +1,18 @@
 github.com/cpuguy83/go-md2man/v2 v2.0.6/go.mod h1:oOW0eioCTA6cOiMLiUPZOpcVxMig6NIQQ7OS05n1F4g=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/fsnotify/fsnotify v1.9.0 h1:2Ml+OJNzbYCTzsxtv8vKSFD9PbJjmhYF14k/jKC7S9k=
-github.com/fsnotify/fsnotify v1.9.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0=
-github.com/go-viper/mapstructure/v2 v2.4.0 h1:EBsztssimR/CONLSZZ04E8qAkxNYq4Qp9LvH92wZUgs=
-github.com/go-viper/mapstructure/v2 v2.4.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM=
 github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
-github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
-github.com/pelletier/go-toml/v2 v2.2.4/go.mod h1:2gIqNv+qfxSVS7cM2xJQKtLSTLUE9V8t9Stt+h56mCY=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
-github.com/sagikazarmark/locafero v0.11.0 h1:1iurJgmM9G3PA/I+wWYIOw/5SyBtxapeHDcg+AAIFXc=
-github.com/sagikazarmark/locafero v0.11.0/go.mod h1:nVIGvgyzw595SUSUE6tvCp3YYTeHs15MvlmU87WwIik=
-github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8 h1:+jumHNA0Wrelhe64i8F6HNlS8pkoyMv5sreGx2Ry5Rw=
-github.com/sourcegraph/conc v0.3.1-0.20240121214520-5f936abd7ae8/go.mod h1:3n1Cwaq1E1/1lhQhtRK2ts/ZwZEhjcQeJQ1RuC6Q/8U=
-github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
-github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
-github.com/spf13/cast v1.10.0 h1:h2x0u2shc1QuLHfxi+cTJvs30+ZAHOGRic8uyGTDWxY=
-github.com/spf13/cast v1.10.0/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
 github.com/spf13/cobra v1.10.2 h1:DMTTonx5m65Ic0GOoRY2c16WCbHxOOw6xxezuLaBpcU=
 github.com/spf13/cobra v1.10.2/go.mod h1:7C1pvHqHw5A4vrJfjNwvOdzYu0Gml16OCs2GRiTUUS4=
+github.com/spf13/pflag v1.0.9 h1:9exaQaMOCwffKiiiYk6/BndUBv+iRViNW+4lEMi0PvY=
 github.com/spf13/pflag v1.0.9/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/pflag v1.0.10 h1:4EBh2KAYBwaONj6b2Ye1GiHfwjqyROoF4RwYO+vPwFk=
-github.com/spf13/pflag v1.0.10/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/spf13/viper v1.21.0 h1:x5S+0EU27Lbphp4UKm1C+1oQO+rKx36vfCoaVebLFSU=
-github.com/spf13/viper v1.21.0/go.mod h1:P0lhsswPGWD/1lZJ9ny3fYnVqxiegrlNrEmgLjbTCAY=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/subosito/gotenv v1.6.0 h1:9NlTDc1FTs4qu0DDq7AEtTPNw6SVm7uBMsUCUjABIf8=
-github.com/subosito/gotenv v1.6.0/go.mod h1:Dk4QP5c2W3ibzajGcXpNraDfq2IrhjMIvMSWPKKo0FU=
-go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc=
 go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg=
-golang.org/x/sys v0.29.0 h1:TPYlXGxvx1MGTn2GiZDhnjPA9wZzZeGKHHmKhHYvgaU=
-golang.org/x/sys v0.29.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
-golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
-golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/cli/conversion.go

@@ -1,67 +0,0 @@
-package cli
-
-import (
-	"fmt"
-
-	"git.maximhutz.com/max/lambda/pkg/codec"
-)
-
-type Conversion interface {
-	InType() string
-	OutType() string
-
-	Run(Repr) (Repr, error)
-}
-
-type forwardCodec[T, U any] struct {
-	codec           codec.Codec[T, U]
-	inType, outType string
-}
-
-func (c forwardCodec[T, U]) Run(r Repr) (Repr, error) {
-	t, ok := r.Data().(T)
-	if !ok {
-		return nil, fmt.Errorf("could not parse '%v' as '%s'", t, c.outType)
-	}
-
-	u, err := c.codec.Encode(t)
-	if err != nil {
-		return nil, err
-	}
-
-	return NewRepr(c.inType, u), nil
-}
-
-func (c forwardCodec[T, U]) InType() string { return c.inType }
-
-func (c forwardCodec[T, U]) OutType() string { return c.outType }
-
-type backwardCodec[T, U any] struct {
-	codec           codec.Codec[T, U]
-	inType, outType string
-}
-
-func (c backwardCodec[T, U]) Run(r Repr) (Repr, error) {
-	u, ok := r.Data().(U)
-	if !ok {
-		return nil, fmt.Errorf("could not parse '%v' as '%s'", r, c.inType)
-	}
-
-	t, err := c.codec.Decode(u)
-	if err != nil {
-		return nil, err
-	}
-
-	return NewRepr(c.outType, t), nil
-}
-
-func (c backwardCodec[T, U]) InType() string { return c.outType }
-
-func (c backwardCodec[T, U]) OutType() string { return c.inType }
-
-func ConvertCodec[T, U any](e codec.Codec[T, U], inType, outType string) []Conversion {
-	return []Conversion{
-		forwardCodec[T, U]{e, inType, outType},
-		backwardCodec[T, U]{e, inType, outType},
-	}
-}

internal/cli/engine.go

@@ -1,27 +0,0 @@
-package cli
-
-import "git.maximhutz.com/max/lambda/pkg/engine"
-
-type Engine interface {
-	Load() Process
-	Name() string
-	InType() string
-}
-
-type convertedEngine[T any] struct {
-	engine engine.Engine[T]
-	name   string
-	inType string
-}
-
-func (e convertedEngine[T]) InType() string { return e.inType }
-
-func (e convertedEngine[T]) Name() string { return e.name }
-
-func (e convertedEngine[T]) Load() Process {
-	return convertedProcess[T]{e.engine.Load(), e.inType}
-}
-
-func ConvertEngine[T any](e engine.Engine[T], name, inType string) Engine {
-	return &convertedEngine[T]{e, name, inType}
-}

internal/cli/marshaler.go

@@ -1,42 +0,0 @@
-package cli
-
-import (
-	"fmt"
-
-	"git.maximhutz.com/max/lambda/pkg/codec"
-)
-
-type Marshaler interface {
-	codec.Marshaler[Repr]
-
-	InType() string
-}
-
-type convertedMarshaler[T any] struct {
-	codec  codec.Marshaler[T]
-	inType string
-}
-
-func (c convertedMarshaler[T]) Decode(s string) (Repr, error) {
-	t, err := c.codec.Decode(s)
-	if err != nil {
-		return nil, err
-	}
-
-	return NewRepr(c.inType, t), nil
-}
-
-func (c convertedMarshaler[T]) Encode(r Repr) (string, error) {
-	t, ok := r.Data().(T)
-	if !ok {
-		return "", fmt.Errorf("could not parse '%v' as 'string'", t)
-	}
-
-	return c.codec.Encode(t)
-}
-
-func (c convertedMarshaler[T]) InType() string { return c.inType }
-
-func ConvertMarshaler[T any](e codec.Marshaler[T], inType string) Marshaler {
-	return convertedMarshaler[T]{e, inType}
-}

internal/cli/process.go

@@ -1,41 +0,0 @@
-package cli
-
-import (
-	"fmt"
-
-	"git.maximhutz.com/max/lambda/pkg/engine"
-)
-
-type Process interface {
-	engine.Process[Repr]
-
-	InType() string
-}
-
-type convertedProcess[T any] struct {
-	process engine.Process[T]
-	inType  string
-}
-
-func (e convertedProcess[T]) InType() string { return e.inType }
-
-func (b convertedProcess[T]) Get() (Repr, error) {
-	s, err := b.process.Get()
-	if err != nil {
-		return nil, err
-	}
-
-	return NewRepr(b.inType, s), nil
-}
-
-func (b convertedProcess[T]) Set(r Repr) error {
-	if t, ok := r.Data().(T); ok {
-		return b.process.Set(t)
-	}
-
-	return fmt.Errorf("Incorrent format '%s' for engine '%s'.", r.Id(), b.inType)
-}
-
-func (b convertedProcess[T]) Step(i int) bool {
-	return b.process.Step(i)
-}

internal/cli/repr.go

@@ -1,21 +0,0 @@
-package cli
-
-type Repr interface {
-	// Id returns to name of the objects underlying representation. If is
-	// assumed that if two Repr objects have the same Id(), they share the same
-	// representation.
-	Id() string
-
-	Data() any
-}
-
-type baseRepr struct {
-	id   string
-	data any
-}
-
-func (r baseRepr) Id() string { return r.id }
-
-func (r baseRepr) Data() any { return r.data }
-
-func NewRepr(id string, data any) Repr { return baseRepr{id, data} }

internal/config/config.go

@@ -1,12 +0,0 @@
-// Package "config" parses ad handles the user settings given to the program.
-package config
-
-// Configuration settings for the program.
-type Config struct {
-	Source      Source      // The source code given to the program.
-	Destination Destination // The destination for the final result.
-	Verbose     bool        // Whether or not to print debug logs.
-	Explanation bool        // Whether or not to print an explanation of the reduction.
-	Profile     string      // If not nil, print a CPU profile during execution.
-	Statistics  bool        // Whether or not to print statistics.
-}

internal/config/destination.go

@@ -1,27 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"os"
-)
-
-// A method of writing output to the user.
-type Destination interface {
-	// Write data to this destination.
-	Write(data string) error
-}
-
-// A destination writing to stdout.
-type StdoutDestination struct{}
-
-func (d StdoutDestination) Write(data string) error {
-	fmt.Println(data)
-	return nil
-}
-
-// A destination writing to a file.
-type FileDestination struct{ Path string }
-
-func (d FileDestination) Write(data string) error {
-	return os.WriteFile(d.Path, []byte(data+"\n"), 0644)
-}

internal/config/get_logger.go

@@ -1,23 +0,0 @@
-package config
-
-import (
-	"log/slog"
-	"os"
-)
-
-// Returns a structured logger with the appropriate configurations.
-func (c Config) GetLogger() *slog.Logger {
-	// By default, only print out errors.
-	level := slog.LevelError
-
-	// If the user set the output to be "VERBOSE", return the debug logs.
-	if c.Verbose {
-		level = slog.LevelInfo
-	}
-
-	return slog.New(
-		slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{
-			Level: level,
-		}),
-	)
-}

internal/config/parse_from_args.go

@@ -1,56 +0,0 @@
-package config
-
-import (
-	"flag"
-	"fmt"
-)
-
-// Extract the program configuration from the command-line arguments.
-func FromArgs() (*Config, error) {
-	// Relevant flags.
-	verbose := flag.Bool("v", false, "Verbosity. If set, the program will print logs.")
-	explanation := flag.Bool("x", false, "Explanation. Whether or not to show all reduction steps.")
-	statistics := flag.Bool("s", false, "Statistics. If set, the process will print various statistics about the run.")
-	profile := flag.String("p", "", "CPU profiling. If an output file is defined, the program will profile its execution and dump its results into it.")
-	file := flag.String("f", "", "File. If set, read source from the specified file.")
-	output := flag.String("o", "", "Output. If set, write result to the specified file. Use '-' for stdout (default).")
-	flag.Parse()
-
-	// Parse source type.
-	var source Source
-	if *file != "" {
-		// File flag takes precedence.
-		if flag.NArg() > 0 {
-			return nil, fmt.Errorf("cannot specify both -f flag and positional argument")
-		}
-		source = FileSource{Path: *file}
-	} else if flag.NArg() == 0 {
-		return nil, fmt.Errorf("no input given")
-	} else if flag.NArg() > 1 {
-		return nil, fmt.Errorf("more than 1 command-line argument")
-	} else {
-		// Positional argument.
-		if flag.Arg(0) == "-" {
-			source = StdinSource{}
-		} else {
-			source = StringSource{Data: flag.Arg(0)}
-		}
-	}
-
-	// Parse destination type.
-	var destination Destination
-	if *output == "" || *output == "-" {
-		destination = StdoutDestination{}
-	} else {
-		destination = FileDestination{Path: *output}
-	}
-
-	return &Config{
-		Source:      source,
-		Destination: destination,
-		Verbose:     *verbose,
-		Explanation: *explanation,
-		Profile:     *profile,
-		Statistics:  *statistics,
-	}, nil
-}

internal/config/source.go

@@ -1,41 +0,0 @@
-package config
-
-import (
-	"io"
-	"os"
-)
-
-// A method of extracting input from the user.
-type Source interface {
-	// Fetch data from this source.
-	Extract() (string, error)
-}
-
-// A source defined by a string.
-type StringSource struct{ Data string }
-
-func (s StringSource) Extract() (string, error) { return s.Data, nil }
-
-// A source pulling from standard input.
-type StdinSource struct{}
-
-func (s StdinSource) Extract() (string, error) {
-	data, err := io.ReadAll(os.Stdin)
-	if err != nil {
-		return "", err
-	}
-
-	return string(data), nil
-}
-
-// A source reading from a file.
-type FileSource struct{ Path string }
-
-func (s FileSource) Extract() (string, error) {
-	data, err := os.ReadFile(s.Path)
-	if err != nil {
-		return "", err
-	}
-
-	return string(data), nil
-}

internal/registry/converter.go

@@ -1,27 +0,0 @@
-package registry
-
-import (
-	"git.maximhutz.com/max/lambda/internal/cli"
-)
-
-type Converter struct {
-	data map[string][]cli.Conversion
-}
-
-func NewConverter() *Converter {
-	return &Converter{data: map[string][]cli.Conversion{}}
-}
-
-func (g *Converter) Add(c cli.Conversion) {
-	conversionsFromIn, ok := g.data[c.InType()]
-	if !ok {
-		conversionsFromIn = []cli.Conversion{}
-	}
-
-	conversionsFromIn = append(conversionsFromIn, c)
-	g.data[c.InType()] = conversionsFromIn
-}
-
-func (g *Converter) ConversionsFrom(t string) []cli.Conversion {
-	return g.data[t]
-}

internal/registry/registry.go

@@ -1,173 +0,0 @@
-package registry
-
-import (
-	"fmt"
-	"iter"
-	"maps"
-
-	"git.maximhutz.com/max/lambda/internal/cli"
-)
-
-type Registry struct {
-	marshalers map[string]cli.Marshaler
-	converter  *Converter
-	engines    map[string]cli.Engine
-}
-
-func New() *Registry {
-	return &Registry{
-		marshalers: map[string]cli.Marshaler{},
-		converter:  NewConverter(),
-		engines:    map[string]cli.Engine{},
-	}
-}
-
-func (r *Registry) AddConversions(conversions ...cli.Conversion) error {
-	for _, conversion := range conversions {
-		r.converter.Add(conversion)
-	}
-
-	return nil
-}
-func (r *Registry) MustAddConversions(conversions ...cli.Conversion) {
-	if err := r.AddConversions(conversions...); err != nil {
-		panic(err)
-	}
-}
-
-func (r *Registry) AddMarshaler(c cli.Marshaler) error {
-	if _, ok := r.marshalers[c.InType()]; ok {
-		return fmt.Errorf("marshaler for '%s' already registered", c.InType())
-	}
-
-	r.marshalers[c.InType()] = c
-	return nil
-}
-
-func (r *Registry) MustAddMarshaler(c cli.Marshaler) {
-	if err := r.AddMarshaler(c); err != nil {
-		panic(err)
-	}
-}
-
-func (r *Registry) AddEngine(e cli.Engine) error {
-	if _, ok := r.engines[e.Name()]; ok {
-		return fmt.Errorf("engine '%s' already registered", e.Name())
-	}
-
-	r.engines[e.Name()] = e
-	return nil
-}
-
-func (r *Registry) MustAddEngine(e cli.Engine) {
-	if err := r.AddEngine(e); err != nil {
-		panic(err)
-	}
-}
-
-func (r Registry) GetEngine(name string) (cli.Engine, error) {
-	e, ok := r.engines[name]
-	if !ok {
-		return nil, fmt.Errorf("engine '%s' not found", name)
-	}
-
-	return e, nil
-}
-
-func (r Registry) ListEngines() iter.Seq[cli.Engine] {
-	return maps.Values(r.engines)
-}
-
-func (r *Registry) GetDefaultEngine(id string) (cli.Engine, error) {
-	for _, engine := range r.engines {
-		if engine.InType() == id {
-			return engine, nil
-		}
-	}
-
-	return nil, fmt.Errorf("no engine for '%s'", id)
-}
-
-func (r *Registry) ConvertTo(repr cli.Repr, outType string) (cli.Repr, error) {
-	path, err := r.ConversionPath(repr.Id(), outType)
-	if err != nil {
-		return nil, err
-	}
-
-	result := repr
-	for _, conversion := range path {
-		result, err = conversion.Run(result)
-		if err != nil {
-			return nil, fmt.Errorf("converting '%s' to '%s': %w", conversion.InType(), conversion.OutType(), err)
-		}
-	}
-
-	return result, err
-}
-
-func (r *Registry) Marshal(repr cli.Repr) (string, error) {
-	m, ok := r.marshalers[repr.Id()]
-	if !ok {
-		return "", fmt.Errorf("no marshaler for '%s'", repr.Id())
-	}
-
-	return m.Encode(repr)
-}
-
-func (r *Registry) Unmarshal(s string, outType string) (cli.Repr, error) {
-	m, ok := r.marshalers[outType]
-	if !ok {
-		return nil, fmt.Errorf("no marshaler for '%s'", outType)
-	}
-
-	return m.Decode(s)
-}
-
-func reverse[T any](list []T) []T {
-	if list == nil {
-		return list
-	}
-
-	reversed := []T{}
-
-	for i := len(list) - 1; i >= 0; i-- {
-		reversed = append(reversed, list[i])
-	}
-
-	return reversed
-}
-
-func (r *Registry) ConversionPath(from, to string) ([]cli.Conversion, error) {
-	backtrack := map[string]cli.Conversion{}
-	iteration := []string{from}
-	for len(iteration) > 0 {
-		nextIteration := []string{}
-
-		for _, item := range iteration {
-			for _, conversion := range r.converter.ConversionsFrom(item) {
-				if _, ok := backtrack[conversion.OutType()]; ok {
-					continue
-				}
-
-				nextIteration = append(nextIteration, conversion.OutType())
-				backtrack[conversion.OutType()] = conversion
-			}
-		}
-
-		iteration = nextIteration
-	}
-
-	reversedPath := []cli.Conversion{}
-	current := to
-	for current != from {
-		conversion, ok := backtrack[current]
-		if !ok {
-			return nil, fmt.Errorf("no valid conversion from '%s' to '%s'", from, to)
-		}
-
-		reversedPath = append(reversedPath, conversion)
-		current = conversion.InType()
-	}
-
-	return reverse(reversedPath), nil
-}

pkg/codec/codec.go

@@ -1,8 +0,0 @@
-package codec
-
-type Codec[T, U any] interface {
-	Encode(T) (U, error)
-	Decode(U) (T, error)
-}
-
-type Marshaler[T any] = Codec[T, string]

pkg/convert/saccharine_to_lambda.go

@@ -3,17 +3,16 @@ package convert
 import (
 	"fmt"
 
-	"git.maximhutz.com/max/lambda/pkg/codec"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-	"git.maximhutz.com/max/lambda/pkg/saccharine"
+	"git.maximhutz.com/max/lambda/pkg/repr/lambda"
+	"git.maximhutz.com/max/lambda/pkg/repr/saccharine"
 )
 
-func encodeAtom(n *saccharine.Atom) lambda.Expression {
+func convertAtom(n *saccharine.Variable) lambda.Expression {
 	return lambda.NewVariable(n.Name)
 }
 
-func encodeAbstraction(n *saccharine.Abstraction) lambda.Expression {
-	result := encodeExpression(n.Body)
+func convertAbstraction(n *saccharine.Abstraction) lambda.Expression {
+	result := SaccharineToLambda(n.Body)
 
 	parameters := n.Parameters
 
@@ -32,13 +31,13 @@ func encodeAbstraction(n *saccharine.Abstraction) lambda.Expression {
 	return result
 }
 
-func encodeApplication(n *saccharine.Application) lambda.Expression {
-	result := encodeExpression(n.Abstraction)
+func convertApplication(n *saccharine.Application) lambda.Expression {
+	result := SaccharineToLambda(n.Abstraction)
 
 	arguments := []lambda.Expression{}
 	for _, argument := range n.Arguments {
-		encodeedArgument := encodeExpression(argument)
-		arguments = append(arguments, encodeedArgument)
+		convertedArgument := SaccharineToLambda(argument)
+		arguments = append(arguments, convertedArgument)
 	}
 
 	for _, argument := range arguments {
@@ -52,9 +51,9 @@ func reduceLet(s *saccharine.LetStatement, e lambda.Expression) lambda.Expressio
 	var value lambda.Expression
 
 	if len(s.Parameters) == 0 {
-		value = encodeExpression(s.Body)
+		value = SaccharineToLambda(s.Body)
 	} else {
-		value = encodeAbstraction(saccharine.NewAbstraction(s.Parameters, s.Body))
+		value = convertAbstraction(saccharine.NewAbstraction(s.Parameters, s.Body))
 	}
 
 	return lambda.NewApplication(
@@ -68,7 +67,7 @@ func reduceDeclare(s *saccharine.DeclareStatement, e lambda.Expression) lambda.E
 
 	return lambda.NewApplication(
 		lambda.NewAbstraction(freshVar, e),
-		encodeExpression(s.Value),
+		SaccharineToLambda(s.Value),
 	)
 }
 
@@ -83,8 +82,8 @@ func reduceStatement(s saccharine.Statement, e lambda.Expression) lambda.Express
 	}
 }
 
-func encodeClause(n *saccharine.Clause) lambda.Expression {
-	result := encodeExpression(n.Returns)
+func convertClause(n *saccharine.Clause) lambda.Expression {
+	result := SaccharineToLambda(n.Returns)
 
 	for i := len(n.Statements) - 1; i >= 0; i-- {
 		result = reduceStatement(n.Statements[i], result)
@@ -93,46 +92,17 @@ func encodeClause(n *saccharine.Clause) lambda.Expression {
 	return result
 }
 
-func encodeExpression(s saccharine.Expression) lambda.Expression {
-	switch s := s.(type) {
-	case *saccharine.Atom:
-		return encodeAtom(s)
+func SaccharineToLambda(n saccharine.Expression) lambda.Expression {
+	switch n := n.(type) {
+	case *saccharine.Variable:
+		return convertAtom(n)
 	case *saccharine.Abstraction:
-		return encodeAbstraction(s)
+		return convertAbstraction(n)
 	case *saccharine.Application:
-		return encodeApplication(s)
+		return convertApplication(n)
 	case *saccharine.Clause:
-		return encodeClause(s)
+		return convertClause(n)
 	default:
-		panic(fmt.Errorf("unknown expression type: %T", s))
+		panic(fmt.Errorf("unknown expression type: %T", n))
 	}
 }
-
-func decodeExression(l lambda.Expression) saccharine.Expression {
-	switch l := l.(type) {
-	case lambda.Variable:
-		return saccharine.NewAtom(l.Name())
-	case lambda.Abstraction:
-		return saccharine.NewAbstraction(
-			[]string{l.Parameter()},
-			decodeExression(l.Body()))
-	case lambda.Application:
-		return saccharine.NewApplication(
-			decodeExression(l.Abstraction()),
-			[]saccharine.Expression{decodeExression(l.Argument())})
-	default:
-		panic(fmt.Errorf("unknown expression type: %T", l))
-	}
-}
-
-type Saccharine2Lambda struct{}
-
-func (c Saccharine2Lambda) Decode(l lambda.Expression) (saccharine.Expression, error) {
-	return decodeExression(l), nil
-}
-
-func (c Saccharine2Lambda) Encode(s saccharine.Expression) (lambda.Expression, error) {
-	return encodeExpression(s), nil
-}
-
-var _ codec.Codec[saccharine.Expression, lambda.Expression] = (*Saccharine2Lambda)(nil)

pkg/emitter/emitter.go

@@ -1,46 +0,0 @@
-package emitter
-
-import "git.maximhutz.com/max/lambda/pkg/set"
-
-type Emitter[E comparable] interface {
-	On(E, func()) Listener[E]
-	Off(Listener[E])
-	Emit(E)
-}
-
-type BaseEmitter[E comparable] struct {
-	listeners map[E]set.Set[Listener[E]]
-}
-
-func (e *BaseEmitter[E]) On(kind E, fn func()) Listener[E] {
-	if e.listeners[kind] == nil {
-		e.listeners[kind] = set.New[Listener[E]]()
-	}
-
-	listener := &BaseListener[E]{kind, fn}
-	e.listeners[kind].Add(listener)
-	return listener
-}
-
-func (e *BaseEmitter[E]) Off(listener Listener[E]) {
-	kind := listener.Kind()
-	if e.listeners[kind] != nil {
-		e.listeners[kind].Remove(listener)
-	}
-}
-
-func (e *BaseEmitter[E]) Emit(event E) {
-	if e.listeners[event] == nil {
-		e.listeners[event] = set.New[Listener[E]]()
-	}
-
-	for listener := range e.listeners[event].Items() {
-		listener.Run()
-	}
-}
-
-func New[E comparable]() *BaseEmitter[E] {
-	return &BaseEmitter[E]{
-		listeners: map[E]set.Set[Listener[E]]{},
-	}
-}

pkg/emitter/listener.go

@@ -1,19 +0,0 @@
-package emitter
-
-type Listener[E comparable] interface {
-	Kind() E
-	Run()
-}
-
-type BaseListener[E comparable] struct {
-	kind E
-	fn   func()
-}
-
-func (l BaseListener[E]) Kind() E {
-	return l.kind
-}
-
-func (l BaseListener[E]) Run() {
-	l.fn()
-}

pkg/engine/engine.go

@@ -1,11 +1,23 @@
 package engine
 
-type Engine[T any] interface {
-	Load() Process[T]
+import (
+	"fmt"
+
+	"git.maximhutz.com/max/lambda/pkg/repr"
+)
+
+type Engine[R repr.Repr] interface {
+	Run(trace bool, count int) (Trace, bool)
+	Step() uint64
+	State() (repr.Repr, error)
+
+	fmt.Stringer
 }
 
-type Process[T any] interface {
-	Get() (T, error)
-	Set(T) error
-	Step(int) bool
+type Trace interface {
+	Before() string
+	After() string
+	Step() uint64
+	TransitionName() string
+	TransitionNodes() string
 }

pkg/engine/normalorder/engine.go

@@ -1,42 +0,0 @@
-package normalorder
-
-import (
-	"git.maximhutz.com/max/lambda/pkg/engine"
-	"git.maximhutz.com/max/lambda/pkg/lambda"
-)
-
-type Process struct {
-	expr lambda.Expression
-}
-
-func (e Process) Get() (lambda.Expression, error) {
-	return e.expr, nil
-}
-
-func (e *Process) Set(l lambda.Expression) error {
-	e.expr = l
-	return nil
-}
-
-func (e *Process) Step(i int) bool {
-	for range i {
-		next, reduced := ReduceOnce(e.expr)
-		if !reduced {
-			return false
-		}
-
-		e.expr = next
-	}
-
-	return true
-}
-
-type Engine struct {
-}
-
-func (e Engine) Load() engine.Process[lambda.Expression] {
-	return &Process{}
-}
-
-var _ engine.Process[lambda.Expression] = (*Process)(nil)
-var _ engine.Engine[lambda.Expression] = (*Engine)(nil)

pkg/engine/normalorder/reduce_one.go

@@ -1,34 +0,0 @@
-package normalorder
-
-import "git.maximhutz.com/max/lambda/pkg/lambda"
-
-func ReduceOnce(e lambda.Expression) (lambda.Expression, bool) {
-	switch e := e.(type) {
-	case lambda.Abstraction:
-		body, reduced := ReduceOnce(e.Body())
-		if reduced {
-			return lambda.NewAbstraction(e.Parameter(), body), true
-		}
-		return e, false
-
-	case lambda.Application:
-		if fn, fnOk := e.Abstraction().(lambda.Abstraction); fnOk {
-			return fn.Body().Substitute(fn.Parameter(), e.Argument()), true
-		}
-
-		abs, reduced := ReduceOnce(e.Abstraction())
-		if reduced {
-			return lambda.NewApplication(abs, e.Argument()), true
-		}
-
-		arg, reduced := ReduceOnce(e.Argument())
-		if reduced {
-			return lambda.NewApplication(e.Abstraction(), arg), true
-		}
-
-		return e, false
-
-	default:
-		return e, false
-	}
-}

pkg/lambda/marshaler.go

@@ -1,19 +0,0 @@
-package lambda
-
-import (
-	"fmt"
-
-	"git.maximhutz.com/max/lambda/pkg/codec"
-)
-
-type Marshaler struct{}
-
-func (m Marshaler) Decode(string) (Expression, error) {
-	return nil, fmt.Errorf("unimplemented")
-}
-
-func (m Marshaler) Encode(e Expression) (string, error) {
-	return e.String(), nil
-}
-
-var _ codec.Marshaler[Expression] = (*Marshaler)(nil)

pkg/repr/lambda/expression.go

@@ -1,15 +1,14 @@
 package lambda
 
 import (
-	"fmt"
-
+	"git.maximhutz.com/max/lambda/pkg/repr"
 	"git.maximhutz.com/max/lambda/pkg/set"
 )
 
 // Expression is the interface for all lambda calculus expression types.
 // It embeds the general expr.Expression interface for cross-mode compatibility.
 type Expression interface {
-	fmt.Stringer
+	repr.Repr
 
 	// Substitute replaces all free occurrences of the target variable with the
 	// replacement expression. Alpha-renaming is performed automatically to
@@ -29,6 +28,12 @@ type Expression interface {
 	IsFree(n string) bool
 }
 
+var (
+	_ Expression = Abstraction{}
+	_ Expression = Application{}
+	_ Expression = Variable{}
+)
+
 /** ------------------------------------------------------------------------- */
 
 type Abstraction struct {
@@ -36,8 +41,6 @@ type Abstraction struct {
 	body      Expression
 }
 
-var _ Expression = Abstraction{}
-
 func (a Abstraction) Parameter() string {
 	return a.parameter
 }
@@ -46,10 +49,6 @@ func (a Abstraction) Body() Expression {
 	return a.body
 }
 
-func (a Abstraction) String() string {
-	return "\\" + a.parameter + "." + a.body.String()
-}
-
 func NewAbstraction(parameter string, body Expression) Abstraction {
 	return Abstraction{parameter, body}
 }
@@ -61,8 +60,6 @@ type Application struct {
 	argument    Expression
 }
 
-var _ Expression = Application{}
-
 func (a Application) Abstraction() Expression {
 	return a.abstraction
 }
@@ -71,10 +68,6 @@ func (a Application) Argument() Expression {
 	return a.argument
 }
 
-func (a Application) String() string {
-	return "(" + a.abstraction.String() + " " + a.argument.String() + ")"
-}
-
 func NewApplication(abstraction Expression, argument Expression) Application {
 	return Application{abstraction, argument}
 }
@@ -85,16 +78,10 @@ type Variable struct {
 	name string
 }
 
-var _ Expression = Variable{}
-
 func (v Variable) Name() string {
 	return v.name
 }
 
-func (v Variable) String() string {
-	return v.name
-}
-
 func NewVariable(name string) Variable {
 	return Variable{name}
 }

pkg/repr/repr.go

@@ -0,0 +1,4 @@
+package repr
+
+type Repr interface {
+}

pkg/repr/saccharine/expression.go

@@ -1,9 +1,20 @@
 package saccharine
 
+import (
+	"git.maximhutz.com/max/lambda/pkg/repr"
+)
+
 type Expression interface {
-	IsExpression()
+	repr.Repr
 }
 
+var (
+	_ Expression = Abstraction{}
+	_ Expression = Application{}
+	_ Expression = Variable{}
+	_ Expression = Clause{}
+)
+
 /** ------------------------------------------------------------------------- */
 
 type Abstraction struct {
@@ -11,37 +22,36 @@ type Abstraction struct {
 	Body       Expression
 }
 
-type Application struct {
-	Abstraction Expression
-	Arguments   []Expression
+func NewAbstraction(parameter []string, body Expression) *Abstraction {
+	return &Abstraction{Parameters: parameter, Body: body}
 }
 
-type Atom struct {
-	Name string
-}
-
-type Clause struct {
-	Statements []Statement
-	Returns    Expression
-}
-
-func (Abstraction) IsExpression() {}
-func (Application) IsExpression() {}
-func (Atom) IsExpression()        {}
-func (Clause) IsExpression()      {}
-
 /** ------------------------------------------------------------------------- */
 
-func NewAbstraction(parameter []string, body Expression) *Abstraction {
-	return &Abstraction{Parameters: parameter, Body: body}
+type Application struct {
+	Abstraction Expression
+	Arguments   []Expression
 }
 
 func NewApplication(abstraction Expression, arguments []Expression) *Application {
 	return &Application{Abstraction: abstraction, Arguments: arguments}
 }
 
-func NewAtom(name string) *Atom {
-	return &Atom{Name: name}
+/** ------------------------------------------------------------------------- */
+
+type Variable struct {
+	Name string
+}
+
+func NewVariable(name string) *Variable {
+	return &Variable{Name: name}
+}
+
+/** ------------------------------------------------------------------------- */
+
+type Clause struct {
+	Statements []Statement
+	Returns    Expression
 }
 
 func NewClause(statements []Statement, returns Expression) *Clause {

pkg/repr/saccharine/parse.go

@@ -10,12 +10,12 @@ import (
 
 type TokenIterator = iterator.Iterator[Token]
 
-func parseRawToken(i *TokenIterator, expected TokenType) (*Token, error) {
+func parseRawToken(i *TokenIterator, expected Type) (*Token, error) {
 	return iterator.Do(i, func(i *TokenIterator) (*Token, error) {
 		if tok, err := i.Next(); err != nil {
 			return nil, err
 		} else if tok.Type != expected {
-			return nil, fmt.Errorf("expected token %v, got %v'", expected.Name(), tok.Value)
+			return nil, fmt.Errorf("expected token %v, got %v'", Name(expected), tok.Value)
 		} else {
 			return &tok, nil
 		}
@@ -30,7 +30,7 @@ func passSoftBreaks(i *TokenIterator) {
 	}
 }
 
-func parseToken(i *TokenIterator, expected TokenType, ignoreSoftBreaks bool) (*Token, error) {
+func parseToken(i *TokenIterator, expected Type, ignoreSoftBreaks bool) (*Token, error) {
 	return iterator.Do(i, func(i *TokenIterator) (*Token, error) {
 		if ignoreSoftBreaks {
 			passSoftBreaks(i)
@@ -103,11 +103,11 @@ func parseApplication(i *TokenIterator) (*Application, error) {
 	})
 }
 
-func parseAtom(i *TokenIterator) (*Atom, error) {
+func parseAtom(i *TokenIterator) (*Variable, error) {
 	if tok, err := parseToken(i, TokenAtom, true); err != nil {
 		return nil, trace.Wrap(err, "no variable (col %d)", i.Index())
 	} else {
-		return NewAtom(tok.Value), nil
+		return NewVariable(tok.Value), nil
 	}
 }
 
@@ -225,3 +225,13 @@ func parse(tokens []Token) (Expression, error) {
 
 	return exp, nil
 }
+
+// Convert a piece of valid saccharine code into an expression.
+func Parse(code string) (Expression, error) {
+	tokens, err := Scan(code)
+	if err != nil {
+		return nil, err
+	}
+
+	return parse(tokens)
+}

pkg/repr/saccharine/scan.go

@@ -56,27 +56,27 @@ func scanToken(i *iterator.Iterator[rune]) (*Token, error) {
 
 	switch {
 	case letter == '(':
-		return NewTokenOpenParen(index), nil
+		return NewOpenParen(index), nil
 	case letter == ')':
-		return NewTokenCloseParen(index), nil
+		return NewCloseParen(index), nil
 	case letter == '.':
-		return NewTokenDot(index), nil
+		return NewDot(index), nil
 	case letter == '\\':
-		return NewTokenSlash(index), nil
+		return NewSlash(index), nil
 	case letter == '\n':
-		return NewTokenSoftBreak(index), nil
+		return NewSoftBreak(index), nil
 	case letter == '{':
-		return NewTokenOpenBrace(index), nil
+		return NewOpenBrace(index), nil
 	case letter == '}':
-		return NewTokenCloseBrace(index), nil
+		return NewCloseBrace(index), nil
 	case letter == ':':
 		if _, err := scanCharacter(i, '='); err != nil {
 			return nil, err
 		} else {
-			return NewTokenAssign(index), nil
+			return NewAssign(index), nil
 		}
 	case letter == ';':
-		return NewTokenHardBreak(index), nil
+		return NewHardBreak(index), nil
 	case letter == '#':
 		// Skip everything until the next newline or EOF.
 		for !i.Done() {
@@ -105,14 +105,14 @@ func scanToken(i *iterator.Iterator[rune]) (*Token, error) {
 			}
 		}
 
-		return NewTokenAtom(string(atom), index), nil
+		return NewAtom(string(atom), index), nil
 	}
 
 	return nil, fmt.Errorf("unknown character '%v'", string(letter))
 }
 
-// scan a string into tokens.
-func scan(input string) ([]Token, error) {
+// Parse a string into tokens.
+func Scan(input string) ([]Token, error) {
 	i := iterator.Of([]rune(input))
 	tokens := []Token{}
 	errorList := []error{}

pkg/repr/saccharine/statement.go

@@ -1,7 +1,11 @@
 package saccharine
 
+import (
+	"git.maximhutz.com/max/lambda/pkg/repr"
+)
+
 type Statement interface {
-	IsStatement()
+	repr.Repr
 }
 
 /** ------------------------------------------------------------------------- */
@@ -12,17 +16,14 @@ type LetStatement struct {
 	Body       Expression
 }
 
-type DeclareStatement struct {
-	Value Expression
+func NewLet(name string, parameters []string, body Expression) *LetStatement {
+	return &LetStatement{Name: name, Parameters: parameters, Body: body}
 }
 
-func (LetStatement) IsStatement()     {}
-func (DeclareStatement) IsStatement() {}
-
 /** ------------------------------------------------------------------------- */
 
-func NewLet(name string, parameters []string, body Expression) *LetStatement {
-	return &LetStatement{Name: name, Parameters: parameters, Body: body}
+type DeclareStatement struct {
+	Value Expression
 }
 
 func NewDeclare(value Expression) *DeclareStatement {

pkg/repr/saccharine/stringify.go

@@ -5,30 +5,30 @@ import (
 	"strings"
 )
 
-func stringifyAtom(n *Atom) string {
+func stringifyAtom(n *Variable) string {
 	return n.Name
 }
 
 func stringifyAbstraction(n *Abstraction) string {
-	return "\\" + strings.Join(n.Parameters, " ") + "." + stringifyExpression(n.Body)
+	return "\\" + strings.Join(n.Parameters, " ") + "." + Stringify(n.Body)
 }
 
 func stringifyApplication(n *Application) string {
-	arguments := []string{stringifyExpression(n.Abstraction)}
+	arguments := []string{Stringify(n.Abstraction)}
 
 	for _, argument := range n.Arguments {
-		arguments = append(arguments, stringifyExpression(argument))
+		arguments = append(arguments, Stringify(argument))
 	}
 
 	return "(" + strings.Join(arguments, " ") + ")"
 }
 
 func stringifyLet(s *LetStatement) string {
-	return s.Name + " " + strings.Join(s.Parameters, " ") + " := " + stringifyExpression(s.Body)
+	return s.Name + " " + strings.Join(s.Parameters, " ") + " := " + Stringify(s.Body)
 }
 
 func stringifyDeclare(s *DeclareStatement) string {
-	return stringifyExpression(s.Value)
+	return Stringify(s.Value)
 }
 
 func stringifyStatement(s Statement) string {
@@ -49,13 +49,13 @@ func stringifyClause(n *Clause) string {
 		stmts += stringifyStatement(statement) + "; "
 	}
 
-	return "{ " + stmts + stringifyExpression(n.Returns) + " }"
+	return "{ " + stmts + Stringify(n.Returns) + " }"
 }
 
 // Convert an expression back into valid source code.
-func stringifyExpression(n Expression) string {
+func Stringify(n Expression) string {
 	switch n := n.(type) {
-	case *Atom:
+	case *Variable:
 		return stringifyAtom(n)
 	case *Abstraction:
 		return stringifyAbstraction(n)

pkg/repr/saccharine/token.go

@@ -0,0 +1,91 @@
+package saccharine
+
+import "fmt"
+
+// All tokens in the pseudo-lambda language.
+type Type int
+
+const (
+	TokenOpenParen  Type = iota // Denotes the '(' token.
+	TokenCloseParen             // Denotes the ')' token.
+	TokenOpenBrace              // Denotes the '{' token.
+	TokenCloseBrace             // Denotes the '}' token.
+	TokenHardBreak              // Denotes the ';' token.
+	TokenAssign                 // Denotes the ':=' token.
+	TokenAtom                   // Denotes an alpha-numeric variable.
+	TokenSlash                  // Denotes the '/' token.
+	TokenDot                    // Denotes the '.' token.
+	TokenSoftBreak              // Denotes a new-line.
+)
+
+// A representation of a token in source code.
+type Token struct {
+	Column int    // Where the token begins in the source text.
+	Type   Type   // What type the token is.
+	Value  string // The value of the token.
+}
+
+func NewOpenParen(column int) *Token {
+	return &Token{Type: TokenOpenParen, Column: column, Value: "("}
+}
+
+func NewCloseParen(column int) *Token {
+	return &Token{Type: TokenCloseParen, Column: column, Value: ")"}
+}
+
+func NewOpenBrace(column int) *Token {
+	return &Token{Type: TokenOpenBrace, Column: column, Value: "{"}
+}
+
+func NewCloseBrace(column int) *Token {
+	return &Token{Type: TokenCloseBrace, Column: column, Value: "}"}
+}
+
+func NewDot(column int) *Token {
+	return &Token{Type: TokenDot, Column: column, Value: "."}
+}
+
+func NewHardBreak(column int) *Token {
+	return &Token{Type: TokenHardBreak, Column: column, Value: ";"}
+}
+
+func NewAssign(column int) *Token {
+	return &Token{Type: TokenAssign, Column: column, Value: ":="}
+}
+
+func NewSlash(column int) *Token {
+	return &Token{Type: TokenSlash, Column: column, Value: "\\"}
+}
+
+func NewAtom(name string, column int) *Token {
+	return &Token{Type: TokenAtom, Column: column, Value: name}
+}
+
+func NewSoftBreak(column int) *Token {
+	return &Token{Type: TokenSoftBreak, Column: column, Value: "\\n"}
+}
+
+func Name(typ Type) string {
+	switch typ {
+	case TokenOpenParen:
+		return "("
+	case TokenCloseParen:
+		return ")"
+	case TokenSlash:
+		return "\\"
+	case TokenDot:
+		return "."
+	case TokenAtom:
+		return "ATOM"
+	case TokenSoftBreak:
+		return "\\n"
+	case TokenHardBreak:
+		return ";"
+	default:
+		panic(fmt.Errorf("unknown token type %v", typ))
+	}
+}
+
+func (t Token) Name() string {
+	return Name(t.Type)
+}

pkg/saccharine/marshaler.go

@@ -1,24 +0,0 @@
-// Package "saccharine" provides a simple language built on top of λ-calculus,
-// to facilitate productive coding using it.
-package saccharine
-
-import (
-	"git.maximhutz.com/max/lambda/pkg/codec"
-)
-
-type Marshaler struct{}
-
-func (m Marshaler) Decode(s string) (Expression, error) {
-	tokens, err := scan(s)
-	if err != nil {
-		return nil, err
-	}
-
-	return parse(tokens)
-}
-
-func (m Marshaler) Encode(e Expression) (string, error) {
-	return stringifyExpression(e), nil
-}
-
-var _ codec.Marshaler[Expression] = (*Marshaler)(nil)

pkg/saccharine/token.go

@@ -1,91 +0,0 @@
-package saccharine
-
-import "fmt"
-
-// All tokens in the pseudo-lambda language.
-type TokenType int
-
-const (
-	TokenOpenParen  TokenType = iota // Denotes the '(' token.
-	TokenCloseParen                  // Denotes the ')' token.
-	TokenOpenBrace                   // Denotes the '{' token.
-	TokenCloseBrace                  // Denotes the '}' token.
-	TokenHardBreak                   // Denotes the ';' token.
-	TokenAssign                      // Denotes the ':=' token.
-	TokenAtom                        // Denotes an alpha-numeric variable.
-	TokenSlash                       // Denotes the '/' token.
-	TokenDot                         // Denotes the '.' token.
-	TokenSoftBreak                   // Denotes a new-line.
-)
-
-// A representation of a token in source code.
-type Token struct {
-	Column int       // Where the token begins in the source text.
-	Type   TokenType // What type the token is.
-	Value  string    // The value of the token.
-}
-
-func NewTokenOpenParen(column int) *Token {
-	return &Token{Type: TokenOpenParen, Column: column, Value: "("}
-}
-
-func NewTokenCloseParen(column int) *Token {
-	return &Token{Type: TokenCloseParen, Column: column, Value: ")"}
-}
-
-func NewTokenOpenBrace(column int) *Token {
-	return &Token{Type: TokenOpenBrace, Column: column, Value: "{"}
-}
-
-func NewTokenCloseBrace(column int) *Token {
-	return &Token{Type: TokenCloseBrace, Column: column, Value: "}"}
-}
-
-func NewTokenDot(column int) *Token {
-	return &Token{Type: TokenDot, Column: column, Value: "."}
-}
-
-func NewTokenHardBreak(column int) *Token {
-	return &Token{Type: TokenHardBreak, Column: column, Value: ";"}
-}
-
-func NewTokenAssign(column int) *Token {
-	return &Token{Type: TokenAssign, Column: column, Value: ":="}
-}
-
-func NewTokenSlash(column int) *Token {
-	return &Token{Type: TokenSlash, Column: column, Value: "\\"}
-}
-
-func NewTokenAtom(name string, column int) *Token {
-	return &Token{Type: TokenAtom, Column: column, Value: name}
-}
-
-func NewTokenSoftBreak(column int) *Token {
-	return &Token{Type: TokenSoftBreak, Column: column, Value: "\\n"}
-}
-
-func (t TokenType) Name() string {
-	switch t {
-	case TokenOpenParen:
-		return "("
-	case TokenCloseParen:
-		return ")"
-	case TokenSlash:
-		return "\\"
-	case TokenDot:
-		return "."
-	case TokenAtom:
-		return "ATOM"
-	case TokenSoftBreak:
-		return "\\n"
-	case TokenHardBreak:
-		return ";"
-	default:
-		panic(fmt.Errorf("unknown token type %v", t))
-	}
-}
-
-func (t Token) Name() string {
-	return t.Type.Name()
-}