lambda/cmd/lambda/lambda_reduce.go

package main

import (
	"fmt"

	"github.com/spf13/cobra"

	"git.maximhutz.com/max/lambda/internal/cli"
	"git.maximhutz.com/max/lambda/internal/registry"
)

func LambdaReduce() *cobra.Command {
	var inputReprFlag string
	var engineFlag string

	cmd := &cobra.Command{
		Use:          "reduce <input-file>",
		Short:        "Reduce a lambda calculus expression",
		SilenceUsage: true,
		Aliases:      []string{"run"},
		RunE: func(cmd *cobra.Command, args []string) error {
			var err error
			if len(args) != 1 {
				return cmd.Help()
			}

			inputPath := args[0]

			// Get input source.
			var source cli.Source
			if inputPath == "-" {
				source = cli.StdinSource{}
			} else {
				source = cli.FileSource{Path: inputPath}
			}

			destination := cli.StdoutDestination{}

			r := GetRegistry()

			// Get input.
			input, err := source.Extract()
			if err != nil {
				return err
			}

			// Use flag if provided, otherwise infer from extension.
			inputRepr := inputReprFlag
			if inputRepr == "" {
				if inputRepr, err = inferReprFromPath(inputPath); err != nil {
					return fmt.Errorf("input file: %w", err)
				}
			}

			// Find engine.
			var engine registry.Engine
			if engineFlag == "" {
				if engine, err = r.GetDefaultEngine(inputRepr); err != nil {
					return err
				}
			} else {
				if engine, err = r.GetEngine(engineFlag); err != nil {
					return err
				}
			}

			// Parse code into syntax tree.
			repr, err := r.Unmarshal(input, inputRepr)
			if err != nil {
				return err
			}

			// Compile expression to lambda calculus.
			compiled, err := r.ConvertTo(repr, "lambda")
			if err != nil {
				return err
			}

			// Create process.
			process, err := engine.Load(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 destination.Write(output)
		},
	}

	cmd.Flags().StringVarP(&inputReprFlag, "input", "i", "", "Input representation (inferred from extension if unset)")
	cmd.Flags().StringVarP(&engineFlag, "engine", "e", "", "Reduction engine (inferred from '--input' if unset)")

	return cmd
}