Merge branch 'master' of https://github.com/rm-dr/lamb

- Added Root node
  - Created node.prepare() method
  - Added "macro show" warning
  - Rewrote TreeWalker & simplified a few methods

.gitignore

@@ -1,7 +1,13 @@
+# Python dev files
 venv
 __pycache__
 
+# Python build files
 *.egg-info
 *.spec
 build
 dist
+
+# Misc
+*.gif
+misc/secrets.sh

.vscode/settings.json

@@ -1,12 +1,18 @@
 {
     "cSpell.words": [
+        "appendleft",
         "autochurch",
+        "delmac",
+        "Endnodes",
         "freevar",
         "mdel",
         "onefile",
         "Packrat",
+        "printables",
         "pyparsing",
+        "rlimit",
         "runstatus",
+        "srange",
         "subvar"
     ],
     "python.analysis.typeCheckingMode": "basic"

README.md

@@ -1,25 +1,119 @@
-# Lamb: A Lambda Calculus Engine
+# 🐑 Lamb: A Lambda Calculus Engine
+
+![Lamb Demo](https://github.com/rm-dr/lamb/assets/96270320/d518e344-e7c8-47ed-89c4-7ce273bf4e2d)
 
 
-## Todo (pre-release):
+
- - $\alpha$-equivalence check
+## :brain: What is lambda calculus?
- - Prettyprint functions (combine args, rename bound variables)
+
- - Write a nice README
+ - [video 1](https://www.youtube.com/watch?v=3VQ382QG-y4): Introduction and boolean logic. The first few minutes are a bit confusing, but it starts to make sense at about [`6:50`](https://youtu.be/3VQ382QG-y4?t=400)
- - Handle or avoid recursion errors
+
- - Fix colors
+ - [video 2](https://www.youtube.com/watch?v=pAnLQ9jwN-E): Continuation of video 1. Features combinators and numerals.
+
+ - [blog](https://www.driverlesscrocodile.com/technology/lambda-calculus-for-people-a-step-behind-me-1): Another introduction. Moves slower than the two videos above and doesn't assume CS knowledge. Four-part series.
+
+ - [handout](https://static.betalupi.com/ormc/Advanced/Lambda%20Calculus.pdf): A handout I've written on lambda calculus.
+
+## :package: Installation
+
+### Method 1: [PyPi](https://pypi.org/project/lamb-engine)
+1. *(Optional but recommended)* make and enter a [venv](https://docs.python.org/3/library/venv.html)
+	- **On Windows, run the following in cmd or powershell:**
+	- `cd Desktop`
+	- `python -m venv lamb`
+	- `.\Scripts\activate`
+2. `pip install lamb-engine`
+3. `lamb`
+
+### Method 2: Git
+1. Clone this repository.
+2. Make and enter a [virtual environment](https://docs.python.org/3/library/venv.html).
+3. ``cd`` into this directory
+4. Run ``pip install .``
+5. Run ``lamb``
+
+-------------------------------------------------
+
+## 📖 Usage
+
+
+Type expressions into the prompt, and Lamb will evaluate them. \
+Use your `\` (backslash) key to type a `λ`. \
+To define macros, use `=`. For example,
+```
+==> T = λab.a
+==> F = λab.a
+==> NOT = λa.a F T
+```
+
+Note that there are spaces in `λa.a F T`. With no spaces, `aFT` will be parsed as one variable. \
+Lambda functions can only take single-letter, lowercase arguments. `λA.A` is not valid syntax. \
+Free variables will be shown with a `'`, like `a'`.
+
+Macros are case-sensitive. If you define a macro `MAC` and accidentally write `mac` in the prompt, `mac` will become a free variable.
+
+Numbers will automatically be converted to Church numerals. For example, the following line will reduce to `T`.
+```
+==> 3 NOT F
+```
+
+If an expression takes too long to evaluate, you may interrupt reduction with `Ctrl-C`. \
+Exit the prompt with `Ctrl-C` or `Ctrl-D`.
+
+There are many useful macros in [macros.lamb](./macros.lamb). Download the file, then load them with the `:load` command:
+```
+==> :load macros.lamb
+```
+
+You can also pass files to lamb directly to have them loaded at startup:
+```
+lamb file1 file2
+```
+
+Use your up/down arrows to recall history.
+
+Have fun!
+
+-------------------------------------------------
+
+## :card_file_box: Commands
+
+Lamb understands many commands. Prefix them with a `:` in the prompt.
+
+`:help` Print a help message
+
+`:clear` Clear the screen
+
+`:rlimit [int | None]` Set maximum reduction limit. `:rlimit none` sets no limit.
+
+`:macros` List macros.
+
+`:mdel [macro]` Delete a macro
+
+`:delmac` Delete all macros
+
+`:step [yes | no]` Enable or disable step-by-step reduction. Toggle if no argument is given. When reducing by steps, the prompt tells you what kind of reduction was done last:
+
+ - `M`: Macro expansion
+ - `C`: Church expansion
+ - `H`: History expansion
+ - `F`: Function application
+
+`:expand [yes | no]` Enable or disable full expansion. Toggle if no argument is given. If full expansion is enabled, ALL macros will be expanded when printing output.
+
+`:save [filename]` \
+`:load [filename]` \
+Save or load macros from a file.
+The lines in a file look exactly the same as regular entries in the prompt, but can only contain macro definitions. See [macros.lamb](./macros.lamb) for an example.
+
+-------------------------------------------------
 
 ## Todo:
- - live syntax check
+ - Prevent macro-chaining recursion
- - Command and macro autocomplete
+ - Cleanup warnings
- - step-by-step reduction
+ - Truncate long expressions in warnings
- - Maybe a better icon?
+ - Loop detection
- - Warn when overwriting macro
+ - Unchurch command: make church numerals human-readable
- - Syntax highlighting: parenthesis, bound variables, macros, etc
+ - Better syntax highlighting
- - Pin header to top of screen
+ - Tab-complete file names and commands
- - PyPi package
+ - Load default macros without manually downloading `macros.lamb` (via `requests`, maybe?)
- - Smart alignment in all printouts
-
-## Mention in Docs
- - lambda functions only work with single-letter arguments
- - church numerals
- - how to install

build_bin.py

@@ -1,10 +0,0 @@
-import PyInstaller.__main__
-
-# Run this file to build a standalone executable.
-# pyinstaller does not build cross-platform.
-
-PyInstaller.__main__.run([
-	"lamb/__main__.py",
-	"--onefile",
-	"--console"
-])

lamb/__main__.py

@@ -1,127 +0,0 @@
-from prompt_toolkit import PromptSession
-from prompt_toolkit.completion import WordCompleter
-from prompt_toolkit import print_formatted_text as printf
-from prompt_toolkit.formatted_text import FormattedText
-from prompt_toolkit.formatted_text import to_plain_text
-from prompt_toolkit.key_binding import KeyBindings
-from prompt_toolkit.lexers import Lexer
-
-from pyparsing import exceptions as ppx
-
-import lamb.runner as runner
-import lamb.runstatus as rs
-import lamb.tokens as tokens
-import lamb.utils as utils
-
-
-# Simple lexer for highlighting.
-# Improve this later.
-class LambdaLexer(Lexer):
-	def lex_document(self, document):
-		def inner(line_no):
-			return [("class:text", str(document.lines[line_no]))]
-		return inner
-
-
-utils.show_greeting()
-
-
-# Replace "\" with pretty "λ"s
-bindings = KeyBindings()
-@bindings.add("\\")
-def _(event):
-	event.current_buffer.insert_text("λ")
-
-
-r = runner.Runner(
-	prompt_session = PromptSession(
-		style = utils.style,
-		lexer = LambdaLexer(),
-		key_bindings = bindings
-	),
-
-	prompt_message = FormattedText([
-		("class:prompt", "~~> ")
-	]),
-)
-
-r.run_lines([
-	"T = λab.a",
-	"F = λab.b",
-	"NOT = λa.(a F T)",
-	"AND = λab.(a F b)",
-	"OR = λab.(a T b)",
-	"XOR = λab.(a (NOT a b) b)",
-	"w = λx.(x x)",
-	"W = w w",
-	"Y = λf.( (λx.(f (x x))) (λx.(f (x x))) )",
-	"PAIR = λabi.( i a b )",
-	"inc = λnfa.(f (n f a))",
-	"zero = λax.x",
-	"one = λfx.(f x)"
-])
-
-
-while True:
-	try:
-		i = r.prompt()
-
-	# Catch Ctrl-C and Ctrl-D
-	except KeyboardInterrupt:
-		printf("\n\nGoodbye.\n")
-		break
-	except EOFError:
-		printf("\n\nGoodbye.\n")
-		break
-
-	# Skip empty lines
-	if i.strip() == "":
-		continue
-
-
-	# Try to run an input line.
-	# Catch parse errors and point them out.
-	try:
-		x = r.run(i)
-	except ppx.ParseException as e:
-		l = len(to_plain_text(r.prompt_session.message))
-		printf(FormattedText([
-			("class:err", " "*(e.loc + l) + "^\n"),
-			("class:err", f"Syntax error at char {e.loc}."),
-			("class:text", "\n")
-		]))
-		continue
-	except tokens.ReductionError as e:
-		printf(FormattedText([
-			("class:err", f"{e.msg}\n")
-		]), style = utils.style)
-		continue
-
-	# If this line defined a macro, print nothing.
-	if isinstance(x, rs.MacroStatus):
-		printf(FormattedText([
-			("class:text", "Set "),
-			("class:syn_macro", x.macro_label),
-			("class:text", " to "),
-			("class:text", str(x.macro_expr))
-		]), style = utils.style)
-
-
-	if isinstance(x, rs.CommandStatus):
-		pass
-
-	# If this line was an expression, print reduction status
-	elif isinstance(x, rs.ReduceStatus):
-		printf(FormattedText([
-			("class:result_header", f"\nExit reason: "),
-			x.stop_reason.value,
-
-			("class:result_header", f"\nReduction count: "),
-			("class:text", str(x.reduction_count)),
-
-
-			("class:result_header", "\n\n    => "),
-			("class:text", str(x.result)),
-		]), style = utils.style)
-
-	printf("")

lamb/commands.py

@@ -1,200 +0,0 @@
-from prompt_toolkit.formatted_text import FormattedText
-from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit import print_formatted_text as printf
-from prompt_toolkit.shortcuts import clear as clear_screen
-
-import os.path
-
-from pyparsing import exceptions as ppx
-import lamb.runstatus as rs
-import lamb.utils as utils
-
-
-
-commands = {}
-help_texts = {}
-
-def lamb_command(*, help_text: str):
-	def inner(func):
-		commands[func.__name__] = func
-		help_texts[func.__name__] = help_text
-	return inner
-
-def run(command, runner) -> None:
-	if command.name not in commands:
-		printf(
-			FormattedText([
-				("class:warn", f"Unknown command \"{command.name}\"")
-			]),
-			style = utils.style
-		)
-	else:
-		commands[command.name](command, runner)
-
-
-@lamb_command(help_text = "Save macros to a file")
-def save(command, runner) -> None:
-	if len(command.args) != 1:
-		printf(
-			HTML(
-				"<err>Command <cmd_code>:save</cmd_code> takes exactly one argument.</err>"
-			),
-			style = utils.style
-		)
-		return
-
-	target = command.args[0]
-	if os.path.exists(target):
-		confirm = runner.prompt_session.prompt(
-			message = FormattedText([
-				("class:warn", "File exists. Overwrite? "),
-				("class:text", "[yes/no]: ")
-			])
-		).lower()
-
-		if confirm != "yes":
-			printf(
-				HTML(
-					"<err>Cancelled.</err>"
-				),
-				style = utils.style
-			)
-			return
-
-	with open(target, "w") as f:
-		f.write("\n".join(
-			[f"{n} = {e}" for n, e in runner.macro_table.items()]
-		))
-
-	printf(
-		HTML(
-			f"Wrote {len(runner.macro_table)} macros to <cmd_code>{target}</cmd_code>"
-		),
-		style = utils.style
-	)
-
-
-@lamb_command(help_text = "Load macros from a file")
-def load(command, runner):
-	if len(command.args) != 1:
-		printf(
-			HTML(
-				"<err>Command <cmd_code>:load</cmd_code> takes exactly one argument.</err>"
-			),
-			style = utils.style
-		)
-		return
-
-	target = command.args[0]
-	if not os.path.exists(target):
-		printf(
-			HTML(
-				f"<err>File {target} doesn't exist.</err>"
-			),
-			style = utils.style
-		)
-		return
-
-	with open(target, "r") as f:
-		lines = [x.strip() for x in f.readlines()]
-
-	for i in range(len(lines)):
-		l = lines[i]
-		try:
-			x = runner.run(l, macro_only = True)
-		except ppx.ParseException as e:
-			printf(
-				FormattedText([
-					("class:warn", f"Syntax error on line {i+1:02}: "),
-					("class:cmd_code", l[:e.loc]),
-					("class:err", l[e.loc]),
-					("class:cmd_code", l[e.loc+1:])
-				]),
-				style = utils.style
-			)
-		except rs.NotAMacro:
-			printf(
-				FormattedText([
-					("class:warn", f"Skipping line {i+1:02}: "),
-					("class:cmd_code", l),
-					("class:warn", f" is not a macro definition.")
-				]),
-				style = utils.style
-			)
-		else:
-			printf(
-				FormattedText([
-					("class:ok", f"Loaded {x.macro_label}: "),
-					("class:cmd_code", str(x.macro_expr))
-				]),
-				style = utils.style
-			)
-
-
-
-@lamb_command(help_text = "Delete a macro")
-def mdel(command, runner) -> None:
-	if len(command.args) != 1:
-		printf(
-			HTML(
-				"<err>Command <cmd_code>:mdel</cmd_code> takes exactly one argument.</err>"
-			),
-			style = utils.style
-		)
-		return
-
-	target = command.args[0]
-	if target not in runner.macro_table:
-		printf(
-			HTML(
-				f"<warn>Macro \"{target}\" is not defined</warn>"
-			),
-			style = utils.style
-		)
-		return
-
-	del runner.macro_table[target]
-
-
-
-@lamb_command(help_text = "Show macros")
-def macros(command, runner) -> None:
-	printf(FormattedText([
-			("class:cmd_h", "\nDefined Macros:\n"),
-		] +
-		[
-			("class:cmd_text", f"\t{name} \t {exp}\n")
-			for name, exp in runner.macro_table.items()
-		]),
-		style = utils.style
-	)
-
-@lamb_command(help_text = "Clear the screen")
-def clear(command, runner) -> None:
-	clear_screen()
-	utils.show_greeting()
-
-
-@lamb_command(help_text = "Print this help")
-def help(command, runner) -> None:
-	printf(
-		HTML(
-			"\n<cmd_text>" +
-			"<cmd_h>Usage:</cmd_h>" +
-			"\n" +
-			"\tWrite lambda expressions using your <cmd_key>\\</cmd_key> key." +
-			"\n" +
-			"\tMacros can be defined using <cmd_key>=</cmd_key>, as in <cmd_code>T = λab.a</cmd_code>" +
-			"\n" +
-			"\tRun commands using <cmd_key>:</cmd_key>, for example <cmd_code>:help</cmd_code>" +
-			"\n\n" +
-			"<cmd_h>Commands:</cmd_h>"+
-			"\n" +
-			"\n".join([
-				f"\t{name} \t {text}"
-				for name, text in help_texts.items()
-			]) +
-			"</cmd_text>"
-		),
-		style = utils.style
-	)

lamb/parser.py

@@ -1,82 +0,0 @@
-import pyparsing as pp
-
-# Packrat gives a MAD speed boost.
-pp.ParserElement.enablePackrat()
-
-import lamb.tokens as tokens
-import lamb.utils as utils
-
-class Parser:
-	lp = pp.Suppress("(")
-	rp = pp.Suppress(")")
-
-	# Simple tokens
-	pp_expr = pp.Forward()
-	pp_macro = pp.Word(pp.alphas + "_")
-	pp_macro.set_parse_action(tokens.macro.from_parse)
-
-	pp_church = pp.Word(pp.nums)
-	pp_church.set_parse_action(utils.autochurch)
-
-	# Function calls.
-	# `tokens.lambda_apply.from_parse` handles chained calls.
-	#
-	# <exp> <exp>
-	# <exp> <exp> <exp>
-	pp_call = pp.Forward()
-	pp_call <<= pp_expr[2, ...]
-	pp_call.set_parse_action(tokens.lambda_apply.from_parse)
-
-	# Function definitions.
-	# Right associative.
-	#
-	# <var> => <exp>
-	pp_lambda_fun = (
-		(pp.Suppress("λ") | pp.Suppress("\\")) +
-		pp.Group(pp.Char(pp.alphas)[1, ...]) +
-		pp.Suppress(".") +
-		(pp_expr ^ pp_call)
-	)
-	pp_lambda_fun.set_parse_action(tokens.lambda_func.from_parse)
-
-	# Assignment.
-	# Can only be found at the start of a line.
-	#
-	# <name> = <exp>
-	pp_macro_def = (
-		pp.line_start() +
-		pp_macro +
-		pp.Suppress("=") +
-		(pp_expr ^ pp_call)
-	)
-	pp_macro_def.set_parse_action(tokens.macro_expression.from_parse)
-
-	pp_expr <<= (
-		pp_church ^
-		pp_lambda_fun ^
-		pp_macro ^
-		(lp + pp_expr + rp) ^
-		(lp + pp_call + rp)
-	)
-
-	pp_command = pp.Suppress(":") + pp.Word(pp.alphas + "_") + pp.Word(pp.alphas + "_")[0, ...]
-	pp_command.set_parse_action(tokens.command.from_parse)
-
-
-	pp_all = (
-		pp_expr ^
-		pp_macro_def ^
-		pp_command ^
-		pp_call
-	)
-
-	@staticmethod
-	def parse_line(line):
-		return Parser.pp_all.parse_string(
-			line,
-			parse_all = True
-		)[0]
-
-	@staticmethod
-	def run_tests(lines):
-		return Parser.pp_all.run_tests(lines)

lamb/runner.py

@@ -1,93 +0,0 @@
-from prompt_toolkit import PromptSession
-
-import lamb.commands as commands
-from lamb.parser import Parser
-import lamb.tokens as tokens
-import lamb.runstatus as rs
-
-
-class Runner:
-	def __init__(self, prompt_session: PromptSession, prompt_message):
-		self.macro_table = {}
-		self.prompt_session = prompt_session
-		self.prompt_message = prompt_message
-
-		# Maximum amount of reductions.
-		# If None, no maximum is enforced.
-		self.reduction_limit: int | None = 300
-
-	def prompt(self):
-		return self.prompt_session.prompt(message = self.prompt_message)
-
-
-	def reduce_expression(self, expr: tokens.LambdaToken) -> rs.ReduceStatus:
-
-		# Reduction Counter.
-		# We also count macro expansions,
-		# and subtract those from the final count.
-		i = 0
-		macro_expansions = 0
-
-		while (self.reduction_limit is None) or (i < self.reduction_limit):
-			r = expr.reduce(self.macro_table)
-			expr = r.output
-
-			# If we can't reduce this expression anymore,
-			# it's in beta-normal form.
-			if not r.was_reduced:
-				return rs.ReduceStatus(
-					reduction_count = i - macro_expansions,
-					stop_reason = rs.StopReason.BETA_NORMAL,
-					result = r.output
-				)
-
-			# Count reductions
-			i += 1
-			if r.reduction_type == tokens.ReductionType.MACRO_EXPAND:
-				macro_expansions += 1
-
-		return rs.ReduceStatus(
-			reduction_count = i - macro_expansions,
-			stop_reason = rs.StopReason.MAX_EXCEEDED,
-			result = r.output # type: ignore
-		)
-
-
-	# Apply a list of definitions
-	def run(self, line: str, *, macro_only = False) -> rs.RunStatus:
-		e = Parser.parse_line(line)
-
-		# If this line is a macro definition, save the macro.
-		if isinstance(e, tokens.macro_expression):
-			was_rewritten = e.label in self.macro_table
-
-			e.exp.bind_variables()
-			self.macro_table[e.label] = e.exp
-
-			return rs.MacroStatus(
-				was_rewritten = was_rewritten,
-				macro_label = e.label,
-				macro_expr = e.exp
-			)
-
-		elif macro_only:
-			raise rs.NotAMacro()
-
-		# If this line is a command, do the command.
-		elif isinstance(e, tokens.command):
-			commands.run(e, self)
-			return rs.CommandStatus(cmd = e.name)
-
-		# If this line is a plain expression, reduce it.
-		elif isinstance(e, tokens.LambdaToken):
-			e.bind_variables()
-			return self.reduce_expression(e)
-
-		# We shouldn't ever get here.
-		else:
-			raise TypeError(f"I don't know what to do with a {type(e)}")
-
-
-	def run_lines(self, lines: list[str]):
-		for l in lines:
-			self.run(l)

lamb/runstatus.py

@@ -1,84 +0,0 @@
-from prompt_toolkit.formatted_text import FormattedText
-from prompt_toolkit.formatted_text import HTML
-import enum
-
-import lamb.tokens as tokens
-
-
-class NotAMacro(Exception):
-	"""
-	Raised when we try to run a non-macro line
-	while enforcing macro_only in Runner.run().
-
-	This should be caught and elegantly presented to the user.
-	"""
-	pass
-
-class RunStatus:
-	"""
-	Base class for run status.
-	These are returned whenever the runner does something.
-	"""
-	pass
-
-class MacroStatus(RunStatus):
-	"""
-	Returned when a macro is defined.
-
-	Values:
-	`was_rewritten`:	If true, an old macro was replaced.
-	`macro_label`:		The name of the macro we just made.
-	`macro_expr`:		The expr of the macro we just made.
-	"""
-
-	def __init__(
-		self,
-		*,
-		was_rewritten: bool,
-		macro_label: str,
-		macro_expr
-	):
-		self.was_rewritten = was_rewritten
-		self.macro_label = macro_label
-		self.macro_expr = macro_expr
-
-
-class StopReason(enum.Enum):
-	BETA_NORMAL		= ("class:text", "β-normal form")
-	LOOP_DETECTED	= ("class:warn", "loop detected")
-	MAX_EXCEEDED	= ("class:err", "too many reductions")
-	INTERRUPT		= ("class:warn", "user interrupt")
-
-
-class ReduceStatus(RunStatus):
-	"""
-	Returned when an expression is reduced.
-
-	Values:
-	`reduction_count`:	How many reductions were made.
-	`stop_reason`:		Why we stopped. See `StopReason`.
-	"""
-
-	def __init__(
-		self,
-		*,
-		reduction_count: int,
-		stop_reason: StopReason,
-		result: tokens.LambdaToken
-	):
-		self.reduction_count = reduction_count
-		self.stop_reason = stop_reason
-		self.result = result
-
-
-class CommandStatus(RunStatus):
-	"""
-	Returned when a command is executed.
-	Doesn't do anything interesting.
-
-	Values:
-	`cmd`: The command that was run, without a colon.
-	"""
-
-	def __init__(self, *, cmd: str):
-		self.cmd = cmd

lamb/tokens.py

@@ -1,530 +0,0 @@
-import enum
-
-class ReductionError(Exception):
-	"""
-	Raised when we encounter an error while reducing.
-
-	These should be caught and elegantly presented to the user.
-	"""
-	def __init__(self, msg: str):
-		self.msg = msg
-
-class ReductionType(enum.Enum):
-	MACRO_EXPAND	= enum.auto()
-	MACRO_TO_FREE	= enum.auto()
-	FUNCTION_APPLY	= enum.auto()
-
-
-class ReductionStatus:
-	"""
-	This object helps organize reduction output.
-	An instance is returned after every reduction step.
-	"""
-
-	def __init__(
-		self,
-		*,
-		output,
-		was_reduced: bool,
-		reduction_type: ReductionType | None = None
-	):
-		# The new expression
-		self.output = output
-
-		# What did we do?
-		# Will be None if was_reduced is false.
-		self.reduction_type = reduction_type
-
-		# Did this reduction change anything?
-		# If we try to reduce an irreducible expression,
-		# this will be false.
-		self.was_reduced = was_reduced
-
-
-class LambdaToken:
-	"""
-	Base class for all lambda tokens.
-	"""
-
-	def bind_variables(self) -> None:
-		pass
-
-	def reduce(self, macro_table) -> ReductionStatus:
-		return ReductionStatus(
-			was_reduced = False,
-			output = self
-		)
-
-class free_variable(LambdaToken):
-	"""
-	Represents a free variable.
-
-	This object does not reduce to
-	anything, since it has no meaning.
-
-	Any name in an expression that isn't
-	a macro or a bound variable is assumed
-	to be a free variable.
-	"""
-
-	def __init__(self, label: str):
-		self.label = label
-
-	def __repr__(self):
-		return f"<freevar {self.label}>"
-
-	def __str__(self):
-		return f"{self.label}"
-
-class command:
-	@staticmethod
-	def from_parse(result):
-		return command(
-			result[0],
-			result[1:]
-		)
-
-	def __init__(self, name, args):
-		self.name = name
-		self.args = args
-
-class macro(LambdaToken):
-	"""
-	Represents a "macro" in lambda calculus,
-	a variable that reduces to an expression.
-
-	These don't have any inherent logic, they
-	just make writing and reading expressions
-	easier.
-
-	These are defined as follows:
-	<macro name> = <expression>
-	"""
-
-	@staticmethod
-	def from_parse(result):
-		return macro(
-			result[0],
-		)
-
-	def __init__(self, name):
-		self.name = name
-	def __repr__(self):
-		return f"<{self.name}>"
-	def __str__(self):
-		return self.name
-
-	def __eq__(self, other):
-		if not isinstance(other, macro):
-			raise TypeError("Can only compare macro with macro")
-		return self.name == other.name
-
-	def reduce(
-			self,
-			macro_table = {},
-			*,
-			# To keep output readable, we avoid expanding macros as often as possible.
-			# Macros are irreducible if force_substitute is false.
-			force_substitute = False,
-
-			# If this is false, error when macros aren't defined instead of
-			# invisibly making a free variable.
-			auto_free_vars = True
-		) -> ReductionStatus:
-
-		if (self.name in macro_table) and force_substitute:
-			if force_substitute: # Only expand macros if we NEED to
-				return ReductionStatus(
-					output = macro_table[self.name],
-					reduction_type = ReductionType.MACRO_EXPAND,
-					was_reduced = True
-				)
-			else: # Otherwise, do nothing.
-				return ReductionStatus(
-					output = self,
-					reduction_type = ReductionType.MACRO_EXPAND,
-					was_reduced = False
-				)
-
-		elif not auto_free_vars:
-			raise ReductionError(f"Macro {self.name} is not defined")
-
-		else:
-			return ReductionStatus(
-				output = free_variable(self.name),
-				reduction_type = ReductionType.MACRO_TO_FREE,
-				was_reduced = True
-			)
-
-class macro_expression:
-	"""
-	Represents a line that looks like
-		<name> = <expression>
-
-	Doesn't do anything particularly interesting,
-	just holds an expression until it is stored
-	in the runner's macro table.
-	"""
-
-	@staticmethod
-	def from_parse(result):
-		return macro_expression(
-			result[0].name,
-			result[1]
-		)
-
-	def __init__(self, label: str, exp: LambdaToken):
-		self.label = label
-		self.exp = exp
-
-	def __repr__(self):
-		return f"<{self.label} := {self.exp!r}>"
-
-	def __str__(self):
-		return f"{self.label} := {self.exp}"
-
-
-bound_variable_counter = 0
-class bound_variable(LambdaToken):
-	def __init__(self, forced_id = None):
-		global bound_variable_counter
-
-		if forced_id is None:
-			self.identifier = bound_variable_counter
-			bound_variable_counter += 1
-		else:
-			self.identifier = forced_id
-
-	def __eq__(self, other):
-		if not isinstance(other, bound_variable):
-			raise TypeError(f"Cannot compare bound_variable with {type(other)}")
-		return self.identifier == other.identifier
-
-	def __repr__(self):
-		return f"<in {self.identifier}>"
-
-class lambda_func(LambdaToken):
-	"""
-	Represents a function.
-		Defined like λa.aa
-
-	After being created by the parser, a function
-	needs to have its variables bound. This cannot
-	happen during parsing, since the parser creates
-	functions "inside-out," and we need all inner
-	functions before we bind variables.
-	"""
-
-	@staticmethod
-	def from_parse(result):
-		if len(result[0]) == 1:
-			return lambda_func(
-				macro(result[0][0]),
-				result[1]
-			)
-		else:
-			return lambda_func(
-				macro(result[0].pop(0)),
-				lambda_func.from_parse(result)
-			)
-
-	def __init__(
-			self,
-			input_var: macro | bound_variable,
-			output: LambdaToken
-		):
-		self.input: macro | bound_variable = input_var
-		self.output: LambdaToken = output
-
-	def __repr__(self) -> str:
-		return f"<{self.input!r} → {self.output!r}>"
-
-	def __str__(self) -> str:
-		return f"λ{self.input}.{self.output}"
-
-	def bind_variables(
-			self,
-			placeholder: macro | None = None,
-			val: bound_variable | None = None,
-			*,
-			binding_self: bool = False
-		) -> None:
-		"""
-		Go through this function and all the functions inside it,
-		and replace the strings generated by the parser with bound
-		variables or free variables.
-
-		If values are passed to `placeholder` and `val,`
-		we're binding the variable of a function containing
-		this one. If they are both none, start the binding
-		chain with this function.
-
-		If only one of those arguments is None, something is very wrong.
-
-		`placeholder` is a macro, NOT A STRING!
-		The parser assumes all names are macros at first, variable
-		binding fixes those that are actually bound variables.
-
-		If `binding_self` is True, don't throw an error on a name conflict
-		and don't bind this function's input variable.
-		This is used when we're calling this method to bind this function's
-		variable.
-		"""
-
-
-		if (placeholder is None) and (val != placeholder):
-			raise Exception(
-				"Error while binding variables: placeholder and val are both None."
-			)
-
-		# We only need to check for collisions if we're
-		# binding another function's variable. If this
-		# function starts the bind chain, skip that step.
-		if not ((placeholder is None) and (val is None)):
-			if not binding_self and isinstance(self.input, macro):
-				if self.input == placeholder:
-					raise ReductionError(f"Variable name conflict: \"{self.input.name}\"")
-
-		# If this function's variables haven't been bound yet,
-		# bind them BEFORE binding the outer function's.
-		#
-		# If we bind inner functions' variables before outer
-		# functions' variables, we won't be able to detect
-		# name conflicts.
-		if isinstance(self.input, macro) and not binding_self:
-			new_bound_var = bound_variable()
-			self.bind_variables(
-				self.input,
-				new_bound_var,
-				binding_self = True
-			)
-			self.input = new_bound_var
-
-
-		# Bind variables inside this function.
-		if isinstance(self.output, macro) and placeholder is not None:
-			if self.output == placeholder:
-				self.output = val # type: ignore
-		elif isinstance(self.output, lambda_func):
-			self.output.bind_variables(placeholder, val)
-		elif isinstance(self.output, lambda_apply):
-			self.output.bind_variables(placeholder, val)
-
-	def reduce(self, macro_table = {}) -> ReductionStatus:
-
-		r = self.output.reduce(macro_table)
-
-		# If a macro becomes a free variable,
-		# reduce twice.
-		if r.reduction_type == ReductionType.MACRO_TO_FREE:
-			self.output = r.output
-			return self.reduce(macro_table)
-
-		return ReductionStatus(
-			was_reduced = r.was_reduced,
-			reduction_type = r.reduction_type,
-			output = lambda_func(
-				self.input,
-				r.output
-			)
-		)
-
-
-	def apply(
-			self,
-			val,
-			*,
-			bound_var: bound_variable | None = None
-		):
-		"""
-		Substitute `bound_var` into all instances of a bound variable `var`.
-		If `bound_var` is none, use this functions bound variable.
-		Returns a new object.
-		"""
-
-		calling_self = False
-		if bound_var is None:
-			calling_self = True
-			bound_var = self.input # type: ignore
-		new_out = self.output
-		if isinstance(self.output, bound_variable):
-			if self.output == bound_var:
-				new_out = val
-		elif isinstance(self.output, lambda_func):
-			new_out = self.output.apply(val, bound_var = bound_var)
-		elif isinstance(self.output, lambda_apply):
-			new_out = self.output.sub_bound_var(val, bound_var = bound_var) # type: ignore
-
-		# If we're applying THIS function,
-		# just give the output
-		if calling_self:
-			return new_out
-
-		# If we're applying another function,
-		# return this one with substitutions
-		else:
-			return lambda_func(
-				self.input,
-				new_out
-			)
-
-
-class lambda_apply(LambdaToken):
-	"""
-	Represents a function application.
-	Has two elements: fn, the function,
-	and arg, the thing it acts upon.
-
-	Parentheses are handled by the parser, and
-	chained functions are handled by from_parse.
-	"""
-
-	@staticmethod
-	def from_parse(result):
-		if len(result) == 2:
-			return lambda_apply(
-				result[0],
-				result[1]
-			)
-		elif len(result) > 2:
-			return lambda_apply.from_parse([
-				lambda_apply(
-					result[0],
-					result[1]
-				)] + result[2:]
-			)
-
-	def __init__(
-			self,
-			fn: LambdaToken,
-			arg: LambdaToken
-		):
-		self.fn: LambdaToken = fn
-		self.arg: LambdaToken = arg
-
-	def __repr__(self) -> str:
-		return f"<{self.fn!r} | {self.arg!r}>"
-
-	def __str__(self) -> str:
-		return f"({self.fn} {self.arg})"
-
-	def bind_variables(
-			self,
-			placeholder: macro | None = None,
-			val: bound_variable | None = None
-		) -> None:
-		"""
-		Does exactly what lambda_func.bind_variables does,
-		but acts on applications instead.
-
-		There will be little documentation in this method,
-		see lambda_func.bind_variables.
-		"""
-
-		if (placeholder is None) and (val != placeholder):
-			raise Exception(
-				"Error while binding variables: placeholder and val are both None."
-			)
-
-		# If val and placeholder are None,
-		# everything below should still work as expected.
-		if isinstance(self.fn, macro) and placeholder is not None:
-			if self.fn == placeholder:
-				self.fn = val # type: ignore
-		elif isinstance(self.fn, lambda_func):
-			self.fn.bind_variables(placeholder, val)
-		elif isinstance(self.fn, lambda_apply):
-			self.fn.bind_variables(placeholder, val)
-
-		if isinstance(self.arg, macro) and placeholder is not None:
-			if self.arg == placeholder:
-				self.arg = val # type: ignore
-		elif isinstance(self.arg, lambda_func):
-			self.arg.bind_variables(placeholder, val)
-		elif isinstance(self.arg, lambda_apply):
-			self.arg.bind_variables(placeholder, val)
-
-	def sub_bound_var(
-		self,
-		val,
-		*,
-		bound_var: bound_variable
-	):
-
-		new_fn = self.fn
-		if isinstance(self.fn, bound_variable):
-			if self.fn == bound_var:
-				new_fn = val
-		elif isinstance(self.fn, lambda_func):
-			new_fn = self.fn.apply(val, bound_var = bound_var)
-		elif isinstance(self.fn, lambda_apply):
-			new_fn = self.fn.sub_bound_var(val, bound_var = bound_var)
-
-		new_arg = self.arg
-		if isinstance(self.arg, bound_variable):
-			if self.arg == bound_var:
-				new_arg = val
-		elif isinstance(self.arg, lambda_func):
-			new_arg = self.arg.apply(val, bound_var = bound_var)
-		elif isinstance(self.arg, lambda_apply):
-			new_arg = self.arg.sub_bound_var(val, bound_var = bound_var)
-
-		return lambda_apply(
-			new_fn,
-			new_arg
-		)
-
-	def reduce(self, macro_table = {}) -> ReductionStatus:
-
-		# If we can directly apply self.fn, do so.
-		if isinstance(self.fn, lambda_func):
-			return ReductionStatus(
-				was_reduced = True,
-				reduction_type = ReductionType.FUNCTION_APPLY,
-				output = self.fn.apply(self.arg)
-			)
-
-		# Otherwise, try to reduce self.fn.
-		# If that is impossible, try to reduce self.arg.
-		else:
-			if isinstance(self.fn, macro):
-				# Macros must be reduced before we apply them as functions.
-				# This is the only place we force substitution.
-				r = self.fn.reduce(
-					macro_table,
-					force_substitute = True
-				)
-			else:
-				r = self.fn.reduce(macro_table)
-
-			# If a macro becomes a free variable,
-			# reduce twice.
-			if r.reduction_type == ReductionType.MACRO_TO_FREE:
-				self.fn = r.output
-				return self.reduce(macro_table)
-
-			if r.was_reduced:
-				return ReductionStatus(
-					was_reduced = True,
-					reduction_type = r.reduction_type,
-					output = lambda_apply(
-						r.output,
-						self.arg
-					)
-				)
-
-			else:
-				r = self.arg.reduce(macro_table)
-
-				if r.reduction_type == ReductionType.MACRO_TO_FREE:
-					self.arg = r.output
-					return self.reduce(macro_table)
-
-				return ReductionStatus(
-					was_reduced = r.was_reduced,
-					reduction_type = r.reduction_type,
-					output = lambda_apply(
-						self.fn,
-						r.output
-					)
-				)

lamb/utils.py

@@ -1,98 +0,0 @@
-from prompt_toolkit.styles import Style
-from prompt_toolkit.formatted_text import HTML
-from prompt_toolkit import print_formatted_text as printf
-from importlib.metadata import version
-
-import lamb.tokens as tokens
-
-
-def autochurch(results):
-	"""
-	Makes a church numeral from an integer.
-	"""
-
-	num = int(results[0])
-
-	f = tokens.bound_variable()
-	a = tokens.bound_variable()
-
-	chain = a
-
-	for i in range(num):
-		chain = tokens.lambda_apply(f, chain)
-
-	return tokens.lambda_func(
-		f,
-		tokens.lambda_func(
-			a,
-			chain
-		)
-	)
-
-
-style = Style.from_dict({
-	# Basic formatting
-	"text": "#FFFFFF",
-	"warn": "#FFFF00",
-	"err": "#FF0000",
-	"prompt": "#00FFFF",
-	"ok": "#B4EC85",
-
-	# Syntax
-	"syn_macro": "#FF00FF",
-	"syn_lambda": "#FF00FF",
-	"syn_bound": "#FF00FF",
-
-	# Titles for reduction results
-	"result_header": "#B4EC85 bold",
-
-	# Command formatting
-	# cmd_h:    section titles
-	# cmd_code: example snippets
-	# cmd_text: regular text
-	# cmd_key:  keyboard keys, usually one character
-	"cmd_h": "#FF6600 bold",
-	"cmd_code": "#AAAAAA italic",
-	"cmd_text": "#FFFFFF",
-	"cmd_key": "#B4EC85 bold",
-
-	# Only used in greeting
-	"_v": "#B4EC85 bold",
-	"_l": "#FF6600 bold",
-	"_s": "#B4EC85 bold",
-	"_p": "#AAAAAA"
-})
-
-
-def show_greeting():
-	#   |  _.._ _.|_
-	#   |_(_|| | ||_)
-	#       0.0.0
-	#
-	#       __  __
-	#    ,-`  ``  `,
-	#   (`   \      )
-	#  (`     \     `)
-	#  (,    / \    _)
-	#   (`  /   \   )
-	#    `'._.--._.'
-	#
-	# A λ calculus engine
-
-	printf(HTML("\n".join([
-		"",
-		"<_h>    |  _.._ _.|_",
-		"    |_(_|| | ||_)</_h>",
-		f"        <_v>{version('lamb')}</_v>",
-		"        __  __",
-		"     ,-`  ``  `,",
-		"    (`   <_l>\\</_l>      )",
-		"   (`     <_l>\\</_l>     `)",
-		"   (,    <_l>/ \\</_l>    _)",
-		"    (`  <_l>/   \\</_l>   )",
-		"     `'._.--._.'",
-		"",
-		"<_s> A λ calculus engine</_s>",
-		"<_p> Type :help for help</_p>",
-		""
-	])), style = style)

lamb_engine/__init__.py

@@ -0,0 +1,8 @@
+from . import utils
+from . import nodes
+from . import parser
+
+from .runner import Runner
+from .runner import StopReason
+
+from .__main__ import main

lamb_engine/__main__.py

@@ -0,0 +1,79 @@
+from prompt_toolkit import PromptSession
+from prompt_toolkit import print_formatted_text as printf
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.formatted_text import to_plain_text
+from pyparsing import exceptions as ppx
+import sys
+
+import lamb_engine
+
+def main():
+
+	lamb_engine.utils.show_greeting()
+
+
+	r = lamb_engine.Runner(
+		prompt_session = PromptSession(
+			style = lamb_engine.utils.style,
+			lexer = lamb_engine.utils.LambdaLexer(),
+			key_bindings = lamb_engine.utils.bindings
+		),
+		prompt_message = FormattedText([
+			("class:prompt", "==> ")
+		])
+	)
+
+	# Load files passed as arguments
+	if len(sys.argv) > 1:
+		for i in range(1, len(sys.argv)):
+			try:
+				printf(FormattedText([
+					("class:warn", "\nLoading file "),
+					("class:code", sys.argv[i]),
+				]), style = lamb_engine.utils.style)
+				r.run(":load " + sys.argv[i])
+			except:
+				printf(FormattedText([
+					("class:err", "Error. Does this file exist?"),
+				]), style = lamb_engine.utils.style)
+
+		print("")
+
+	while True:
+		try:
+			i = r.prompt()
+
+		# Catch Ctrl-C and Ctrl-D
+		except KeyboardInterrupt:
+			printf("\n\nGoodbye.\n")
+			break
+		except EOFError:
+			printf("\n\nGoodbye.\n")
+			break
+
+		# Skip empty lines
+		if i.strip() == "":
+			continue
+
+		# Try to run an input line.
+		# Catch parse errors and point them out.
+		try:
+			x = r.run(i)
+		except ppx.ParseException as e:
+			l = len(to_plain_text(r.prompt_session.message))
+			printf(FormattedText([
+				("class:err", " "*(e.loc + l) + "^\n"),
+				("class:err", f"Syntax error at char {e.loc}."),
+				("class:text", "\n")
+			]), style = lamb_engine.utils.style)
+			continue
+		except lamb_engine.nodes.ReductionError as e:
+			printf(FormattedText([
+				("class:err", f"{e.msg}\n")
+			]), style = lamb_engine.utils.style)
+			continue
+
+		printf("")
+
+if __name__ == "__main__":
+	main()

lamb_engine/nodes/__init__.py

@@ -0,0 +1,3 @@
+from .misc import *
+from .nodes import *
+from .functions import *

lamb_engine/nodes/functions.py

@@ -0,0 +1,287 @@
+import lamb_engine
+import lamb_engine.nodes as lbn
+
+def print_node(node: lbn.Node, *, export: bool = False) -> str:
+	if not isinstance(node, lbn.Node):
+		raise TypeError(f"I don't know how to print a {type(node)}")
+
+	out = ""
+
+	bound_subs = {}
+
+	for s, n in node:
+		if isinstance(n, lbn.EndNode):
+			if isinstance(n, lbn.Bound):
+				out += bound_subs[n.identifier]
+			else:
+				out += n.print_value(export = export)
+
+		elif isinstance(n, lbn.Func):
+			# This should never be true, but
+			# keep this here to silence type checker.
+			if not isinstance(n.input, lbn.Bound):
+				raise Exception("input is macro, something is wrong.")
+
+			if s == lbn.Direction.UP:
+				o = n.input.print_value(export = export)
+				if o in bound_subs.values():
+					i = -1
+					p = o
+					while o in bound_subs.values():
+						o = p + lamb_engine.utils.subscript(i := i + 1)
+					bound_subs[n.input.identifier] = o
+				else:
+					bound_subs[n.input.identifier] = n.input.print_value()
+
+				if isinstance(n.parent, lbn.Call):
+					out += "("
+
+				if isinstance(n.parent, lbn.Func):
+					out += bound_subs[n.input.identifier]
+				else:
+					out += "λ" + bound_subs[n.input.identifier]
+				if not isinstance(n.left, lbn.Func):
+					out += "."
+
+			elif s == lbn.Direction.LEFT:
+				if isinstance(n.parent, lbn.Call):
+					out += ")"
+				del bound_subs[n.input.identifier]
+
+		elif isinstance(n, lbn.Call):
+			if s == lbn.Direction.UP:
+				out += "("
+			elif s == lbn.Direction.LEFT:
+				out += " "
+			elif s == lbn.Direction.RIGHT:
+				out += ")"
+
+	return out
+
+
+def clone(node: lbn.Node):
+	if not isinstance(node, lbn.Node):
+		raise TypeError(f"I don't know what to do with a {type(node)}")
+
+	macro_map = {}
+	if isinstance(node, lbn.Func):
+		c = node.copy()
+		macro_map[node.input.identifier] = c.input.identifier # type: ignore
+	else:
+		c = node.copy()
+
+	out = c
+	out_ptr = out # Stays one step behind ptr, in the new tree.
+	ptr = node
+	from_side = lbn.Direction.UP
+
+
+	if isinstance(node, lbn.EndNode):
+		return out
+
+	# We're not using a TreeWalker here because
+	# we need more control over our pointer when cloning.
+	while True:
+		if isinstance(ptr, lbn.EndNode):
+			from_side, ptr = ptr.go_up()
+			_, out_ptr = out_ptr.go_up()
+		elif isinstance(ptr, lbn.Func) or isinstance(ptr, lbn.Root):
+			if from_side == lbn.Direction.UP:
+				from_side, ptr = ptr.go_left()
+
+				if isinstance(ptr, lbn.Func):
+					c = ptr.copy()
+					macro_map[ptr.input.identifier] = c.input.identifier # type: ignore
+				elif isinstance(ptr, lbn.Bound):
+					c = ptr.copy()
+					if c.identifier in macro_map:
+						c.identifier = macro_map[c.identifier]
+				else:
+					c = ptr.copy()
+				out_ptr.set_side(ptr.parent_side, c)
+
+				_, out_ptr = out_ptr.go_left()
+			elif from_side == lbn.Direction.LEFT:
+				from_side, ptr = ptr.go_up()
+				_, out_ptr = out_ptr.go_up()
+		elif isinstance(ptr, lbn.Call):
+			if from_side == lbn.Direction.UP:
+				from_side, ptr = ptr.go_left()
+
+				if isinstance(ptr, lbn.Func):
+					c = ptr.copy()
+					macro_map[ptr.input.identifier] = c.input.identifier # type: ignore
+				elif isinstance(ptr, lbn.Bound):
+					c = ptr.copy()
+					if c.identifier in macro_map:
+						c.identifier = macro_map[c.identifier]
+				else:
+					c = ptr.copy()
+				out_ptr.set_side(ptr.parent_side, c)
+
+				_, out_ptr = out_ptr.go_left()
+			elif from_side == lbn.Direction.LEFT:
+				from_side, ptr = ptr.go_right()
+
+				if isinstance(ptr, lbn.Func):
+					c = ptr.copy()
+					macro_map[ptr.input.identifier] = c.input.identifier # type: ignore
+				elif isinstance(ptr, lbn.Bound):
+					c = ptr.copy()
+					if c.identifier in macro_map:
+						c.identifier = macro_map[c.identifier]
+				else:
+					c = ptr.copy()
+				out_ptr.set_side(ptr.parent_side, c)
+
+				_, out_ptr = out_ptr.go_right()
+			elif from_side == lbn.Direction.RIGHT:
+				from_side, ptr = ptr.go_up()
+				_, out_ptr = out_ptr.go_up()
+
+		if ptr is node.parent:
+			break
+	return out
+
+def prepare(root: lbn.Root, *, ban_macro_name = None) -> list:
+	"""
+	Prepare an expression for expansion.
+	This will does the following:
+		- Binds variables
+		- Turns unbound macros into free variables
+		- Generates warnings
+	"""
+
+	if not isinstance(root, lbn.Root):
+		raise TypeError(f"I don't know what to do with a {type(root)}")
+
+	bound_variables = {}
+
+	warnings = []
+
+	it = iter(root)
+	for s, n in it:
+		if isinstance(n, lbn.History):
+			if root.runner.history[0] == None:
+				raise lbn.ReductionError("There isn't any history to reference.")
+			else:
+				warnings += [
+					("class:code", "$"),
+					("class:warn", " will be expanded to ")
+				] + lamb_engine.utils.lex_str(str(n.expand()[1]))
+
+		# If this expression is part of a macro,
+		# make sure we don't reference it inside itself.
+		elif isinstance(n, lbn.Macro):
+			if (n.name == ban_macro_name) and (ban_macro_name is not None):
+				raise lbn.ReductionError("Macro cannot reference self")
+
+			# Bind variables
+			if n.name in bound_variables:
+				n.parent.set_side(
+					n.parent_side,
+					clone(bound_variables[n.name])
+				)
+				it.ptr = n.parent.get_side(n.parent_side)
+
+			# Turn undefined macros into free variables
+			elif n.name not in root.runner.macro_table:
+				warnings += [
+					("class:warn", "Name "),
+					("class:code", n.name),
+					("class:warn", " is a free variable\n"),
+				]
+				n.parent.set_side(
+					n.parent_side,
+					n.to_freevar()
+				)
+				it.ptr = n.parent.get_side(n.parent_side)
+
+
+		# Save bound variables when we enter a function's sub-tree,
+		# delete them when we exit it.
+		elif isinstance(n, lbn.Func):
+			if s == lbn.Direction.UP:
+				# Add this function's input to the table of bound variables.
+				# If it is already there, raise an error.
+				if (n.input.name in bound_variables):
+					raise lbn.ReductionError(f"Bound variable name conflict: \"{n.input.name}\"")
+				else:
+					bound_variables[n.input.name] = lbn.Bound(
+						lamb_engine.utils.remove_sub(n.input.name),
+						macro_name = n.input.name
+					)
+					n.input = bound_variables[n.input.name]
+
+			elif s == lbn.Direction.LEFT:
+				del bound_variables[n.input.macro_name] # type: ignore
+
+	return warnings
+
+# Apply a function.
+# Returns the function's output.
+def call_func(fn: lbn.Func, arg: lbn.Node):
+	for s, n in fn:
+		if isinstance(n, lbn.Bound) and (s == lbn.Direction.UP):
+			if n == fn.input:
+				if n.parent is None:
+					raise Exception("Tried to substitute a None bound variable.")
+
+				n.parent.set_side(n.parent_side, clone(arg)) # type: ignore
+	return fn.left
+
+# Do a single reduction step
+def reduce(root: lbn.Root) -> tuple[lbn.ReductionType, lbn.Root]:
+	if not isinstance(root, lbn.Root):
+		raise TypeError(f"I can't reduce a {type(root)}")
+
+	out = root
+	for s, n in out:
+		if isinstance(n, lbn.Call) and (s == lbn.Direction.UP):
+			if isinstance(n.left, lbn.Func):
+				n.parent.set_side(
+					n.parent_side, # type: ignore
+					call_func(n.left, n.right)
+				)
+
+				return lbn.ReductionType.FUNCTION_APPLY, out
+
+			elif isinstance(n.left, lbn.ExpandableEndNode):
+				r, n.left = n.left.expand()
+				return r, out
+	return lbn.ReductionType.NOTHING, out
+
+
+def expand(root: lbn.Root, *, force_all = False) -> tuple[int, lbn.Root]:
+	"""
+	Expands expandable nodes in the given tree.
+
+	If force_all is false, this only expands
+	ExpandableEndnodes that have "always_expand" set to True.
+
+	If force_all is True, this expands ALL
+	ExpandableEndnodes.
+	"""
+
+	if not isinstance(root, lbn.Root):
+		raise TypeError(f"I don't know what to do with a {type(root)}")
+
+	out = root
+	macro_expansions = 0
+
+	it = iter(root)
+	for s, n in it:
+		if (
+				isinstance(n, lbn.ExpandableEndNode) and
+				(force_all or n.always_expand)
+			):
+
+			n.parent.set_side(
+				n.parent_side, # type: ignore
+				n.expand()[1]
+			)
+			it.ptr = n.parent.get_side(
+				n.parent_side # type: ignore
+			)
+			macro_expansions += 1
+	return macro_expansions, out

lamb_engine/nodes/misc.py

@@ -0,0 +1,44 @@
+import enum
+
+class Direction(enum.Enum):
+	UP		= enum.auto()
+	LEFT	= enum.auto()
+	RIGHT	= enum.auto()
+
+
+class ReductionType(enum.Enum):
+	# Nothing happened. This implies that
+	# an expression cannot be reduced further.
+	NOTHING			= enum.auto()
+
+	# We replaced a macro with an expression.
+	MACRO_EXPAND	= enum.auto()
+
+	# We expanded a history reference
+	HIST_EXPAND 	= enum.auto()
+
+	# We turned a church numeral into an expression
+	AUTOCHURCH		= enum.auto()
+
+	# We applied a function.
+	# This is the only type of "formal" reduction step.
+	FUNCTION_APPLY	= enum.auto()
+
+# Pretty, short names for each reduction type.
+# These should all have the same length.
+reduction_text = {
+	ReductionType.NOTHING:			"N",
+	ReductionType.MACRO_EXPAND:		"M",
+	ReductionType.HIST_EXPAND:		"H",
+	ReductionType.AUTOCHURCH:		"C",
+	ReductionType.FUNCTION_APPLY:	"F",
+}
+
+class ReductionError(Exception):
+	"""
+	Raised when we encounter an error while reducing.
+
+	These should be caught and elegantly presented to the user.
+	"""
+	def __init__(self, msg: str):
+		self.msg = msg

lamb_engine/nodes/nodes.py

@@ -0,0 +1,452 @@
+import lamb_engine
+import lamb_engine.nodes as lbn
+
+class TreeWalker:
+	"""
+	An iterator that walks the "outline" of a tree
+	defined by a chain of nodes.
+
+	It returns a tuple: (out_side, out)
+
+	out is the node we moved to,
+	out_side is the direction we came to the node from.
+	"""
+
+	def __init__(self, expr):
+		self.expr = expr
+		self.ptr = expr
+		self.first_step = True
+		self.from_side = lbn.Direction.UP
+
+	def __iter__(self):
+		return self
+
+	def __next__(self):
+		# This could be implemented without checking the node type,
+		# but there's no reason to do that.
+		# Maybe later?
+
+
+		if self.first_step:
+			self.first_step = False
+			return self.from_side, self.ptr
+
+		if isinstance(self.ptr, Root):
+			if self.from_side == lbn.Direction.UP:
+				self.from_side, self.ptr = self.ptr.go_left()
+		elif isinstance(self.ptr, EndNode):
+			self.from_side, self.ptr = self.ptr.go_up()
+		elif isinstance(self.ptr, Func):
+			if self.from_side == lbn.Direction.UP:
+				self.from_side, self.ptr = self.ptr.go_left()
+			elif self.from_side == lbn.Direction.LEFT:
+				self.from_side, self.ptr = self.ptr.go_up()
+		elif isinstance(self.ptr, Call):
+			if self.from_side == lbn.Direction.UP:
+				self.from_side, self.ptr = self.ptr.go_left()
+			elif self.from_side == lbn.Direction.LEFT:
+				self.from_side, self.ptr = self.ptr.go_right()
+			elif self.from_side == lbn.Direction.RIGHT:
+				self.from_side, self.ptr = self.ptr.go_up()
+		else:
+			raise TypeError(f"I don't know how to iterate a {type(self.ptr)}")
+
+		# Stop conditions
+		if isinstance(self.expr, Root):
+			if self.ptr is self.expr:
+				raise StopIteration
+		else:
+			if self.ptr is self.expr.parent:
+				raise StopIteration
+
+		return self.from_side, self.ptr
+
+class Node:
+	"""
+	Generic class for an element of an expression tree.
+	All nodes are subclasses of this.
+	"""
+
+	def __init__(self):
+		# The node this one is connected to.
+		# None if this is the top objects.
+		self.parent: Node = None # type: ignore
+
+		# What direction this is relative to the parent.
+		# Left of Right.
+		self.parent_side: Direction = None # type: ignore
+
+		# Left and right nodes, None if empty
+		self._left = None
+		self._right = None
+
+		# The runner this node is attached to.
+		# Set by Node.set_runner()
+		self.runner: lamb_engine.runner.Runner = None # type: ignore
+
+	def __iter__(self):
+		return TreeWalker(self)
+
+	def _set_parent(self, parent, side):
+		"""
+		Set this node's parent and parent side.
+		This method shouldn't be called explicitly unless
+		there's no other option. Use self.left and self.right instead.
+		"""
+
+		if (parent is not None) and (side is None):
+			raise Exception("If a node has a parent, it must have a lbn.direction.")
+		if (parent is None) and (side is not None):
+			raise Exception("If a node has no parent, it cannot have a lbn.direction.")
+		self.parent = parent
+		self.parent_side = side
+		return self
+
+	@property
+	def left(self):
+		return self._left
+
+	@left.setter
+	def left(self, node):
+		if node is not None:
+			node._set_parent(self, lbn.Direction.LEFT)
+		self._left = node
+
+	@property
+	def right(self):
+		return self._right
+
+	@right.setter
+	def right(self, node):
+		if node is not None:
+			node._set_parent(self, lbn.Direction.RIGHT)
+		self._right = node
+
+
+	def set_side(self, side: lbn.Direction, node):
+		"""
+		A wrapper around Node.left and Node.right that
+		automatically selects a side.
+		"""
+
+		if side == lbn.Direction.LEFT:
+			self.left = node
+		elif side == lbn.Direction.RIGHT:
+			self.right = node
+		else:
+			raise TypeError("Can only set left or right side.")
+
+	def get_side(self, side: lbn.Direction):
+		if side == lbn.Direction.LEFT:
+			return self.left
+		elif side == lbn.Direction.RIGHT:
+			return self.right
+		else:
+			raise TypeError("Can only get left or right side.")
+
+
+	def go_left(self):
+		"""
+		Go down the left branch of this node.
+		Returns a tuple (from_dir, node)
+
+		from_dir is the direction from which we came INTO the next node.
+		node is the node on the left of this one.
+		"""
+
+		if self._left is None:
+			raise Exception("Can't go left when left is None")
+		return lbn.Direction.UP, self._left
+
+	def go_right(self):
+		"""
+		Go down the right branch of this node.
+		Returns a tuple (from_dir, node)
+
+		from_dir is the direction from which we came INTO the next node.
+		node is the node on the right of this one.
+		"""
+		if self._right is None:
+			raise Exception("Can't go right when right is None")
+		return lbn.Direction.UP, self._right
+
+	def go_up(self):
+		"""
+		Go up th the parent of this node.
+		Returns a tuple (from_dir, node)
+
+		from_dir is the direction from which we came INTO the parent.
+		node is the node above of this one.
+		"""
+		return self.parent_side, self.parent
+
+	def copy(self):
+		"""
+		Return a copy of this node.
+		parent, parent_side, left, and right should be left
+		as None, and will be filled later.
+		"""
+		raise NotImplementedError("Nodes MUST provide a `copy` method!")
+
+	def __str__(self) -> str:
+		return lbn.print_node(self)
+
+	def export(self) -> str:
+		"""
+		Convert this tree to a parsable string.
+		"""
+		return lbn.print_node(self, export = True)
+
+	def set_runner(self, runner):
+		for s, n in self:
+			if s == lbn.Direction.UP:
+				n.runner = runner # type: ignore
+		return self
+
+class EndNode(Node):
+	def print_value(self, *, export: bool = False) -> str:
+		raise NotImplementedError("EndNodes MUST provide a `print_value` method!")
+
+class ExpandableEndNode(EndNode):
+	always_expand = False
+	def expand(self) -> tuple[lbn.ReductionType, Node]:
+		raise NotImplementedError("ExpandableEndNodes MUST provide an `expand` method!")
+
+class FreeVar(EndNode):
+	def __init__(self, name: str, *, runner = None):
+		super().__init__()
+		self.name = name
+		self.runner = runner # type: ignore
+
+	def __repr__(self):
+		return f"<freevar {self.name}>"
+
+	def print_value(self, *, export: bool = False) -> str:
+		if export:
+			return f"{self.name}'"
+		else:
+			return f"{self.name}'"
+
+	def copy(self):
+		return FreeVar(self.name)
+
+class Macro(ExpandableEndNode):
+	@staticmethod
+	def from_parse(results):
+		return Macro(results[0])
+
+	def __init__(self, name: str, *, runner = None) -> None:
+		super().__init__()
+		self.name = name
+		self.left = None
+		self.right = None
+		self.runner = runner # type: ignore
+
+	def __repr__(self):
+		return f"<macro {self.name}>"
+
+	def print_value(self, *, export: bool = False) -> str:
+		return self.name
+
+	def expand(self) -> tuple[lbn.ReductionType, Node]:
+		if self.name in self.runner.macro_table:
+			# The element in the macro table will be a Root node,
+			# so we clone its left element.
+			return (
+				lbn.ReductionType.MACRO_EXPAND,
+				lbn.clone(self.runner.macro_table[self.name].left)
+			)
+		else:
+			raise Exception(f"Macro {self.name} is not defined")
+
+	def to_freevar(self):
+		return FreeVar(self.name, runner = self.runner)
+
+	def copy(self):
+		return Macro(self.name, runner = self.runner)
+
+class Church(ExpandableEndNode):
+	@staticmethod
+	def from_parse(results):
+		return Church(int(results[0]))
+
+	def __init__(self, value: int, *, runner = None) -> None:
+		super().__init__()
+		self.value = value
+		self.left = None
+		self.right = None
+		self.runner = runner # type: ignore
+
+	def __repr__(self):
+		return f"<church {self.value}>"
+
+	def print_value(self, *, export: bool = False) -> str:
+		return str(self.value)
+
+	def expand(self) -> tuple[lbn.ReductionType, Node]:
+		f = Bound("f")
+		a = Bound("a")
+		chain = a
+
+		for i in range(self.value):
+			chain = Call(lbn.clone(f), lbn.clone(chain))
+
+		return (
+			lbn.ReductionType.AUTOCHURCH,
+			Func(f, Func(a, chain)).set_runner(self.runner)
+		)
+
+	def copy(self):
+		return Church(self.value, runner = self.runner)
+
+class History(ExpandableEndNode):
+	always_expand = True
+
+	@staticmethod
+	def from_parse(results):
+		return History()
+
+	def __init__(self, *, runner = None) -> None:
+		super().__init__()
+		self.left = None
+		self.right = None
+		self.runner = runner # type: ignore
+
+	def __repr__(self):
+		return f"<$>"
+
+	def print_value(self, *, export: bool = False) -> str:
+		return "$"
+
+	def expand(self) -> tuple[lbn.ReductionType, Node]:
+		# We shouldn't ever get here, prepare()
+		# catches empty history.
+		if self.runner.history[0] == None:
+			raise Exception(f"Tried to expand empty history.")
+		# .left is VERY important!
+		# self.runner.history will contain Root nodes,
+		# and we don't want those *inside* our tree.
+		return lbn.ReductionType.HIST_EXPAND, lbn.clone(self.runner.history[0].left)
+
+	def copy(self):
+		return History(runner = self.runner)
+
+bound_counter = 0
+class Bound(EndNode):
+	def __init__(self, name: str, *, forced_id = None, runner = None, macro_name = None):
+		self.name = name
+		global bound_counter
+		self.runner = runner # type: ignore
+
+		# The name of the macro this bound came from.
+		# Always equal to self.name, unless the macro
+		# this came from had a subscript.
+		self.macro_name = macro_name
+
+		if forced_id is None:
+			self.identifier = bound_counter
+			bound_counter += 1
+		else:
+			self.identifier = forced_id
+
+	def copy(self):
+		return Bound(
+			self.name,
+			forced_id = self.identifier,
+			runner = self.runner
+		)
+
+	def __eq__(self, other):
+		if not isinstance(other, Bound):
+			raise TypeError(f"Cannot compare bound_variable with {type(other)}")
+		return self.identifier == other.identifier
+
+	def __repr__(self):
+		return f"<{self.name} {self.identifier}>"
+
+	def print_value(self, *, export: bool = False) -> str:
+		return self.name
+
+class Func(Node):
+	@staticmethod
+	def from_parse(result):
+		if len(result[0]) == 1:
+			return Func(
+				result[0][0],
+				result[1]
+			)
+		else:
+			return Func(
+				result[0].pop(0),
+				Func.from_parse(result)
+			)
+
+	def __init__(self, input, output: Node, *, runner = None) -> None:
+		super().__init__()
+		self.input = input
+		self.left: Node = output
+		self.right: None = None
+		self.runner = runner # type: ignore
+
+	def __repr__(self):
+		return f"<func {self.input!r} {self.left!r}>"
+
+	def copy(self):
+		return Func(
+			Bound(
+				self.input.name,
+				runner = self.runner
+			),
+			None, # type: ignore
+			runner = self.runner
+		)
+
+class Root(Node):
+	"""
+	Root node.
+	Used at the top of an expression.
+	"""
+
+	def __init__(self, left: Node, *, runner = None) -> None:
+		super().__init__()
+		self.left: Node = left
+		self.runner = runner # type: ignore
+
+	def __repr__(self):
+		return f"<Root {self.left!r}>"
+
+	def copy(self):
+		return Root(None, runner = self.runner) # type: ignore
+
+class Call(Node):
+	@staticmethod
+	def from_parse(results):
+		if len(results) == 2:
+			return Call(
+				results[0],
+				results[1]
+			)
+		else:
+			this = Call(
+				results[0],
+				results[1]
+			)
+
+			return Call.from_parse(
+				[Call(
+					results[0],
+					results[1]
+				)] + results[2:]
+			)
+
+	def __init__(self, fn: Node, arg: Node, *, runner = None) -> None:
+		super().__init__()
+		self.left: Node = fn
+		self.right: Node = arg
+		self.runner = runner # type: ignore
+
+	def __repr__(self):
+		return f"<call {self.left!r} {self.right!r}>"
+
+	def copy(self):
+		return Call(None, None, runner = self.runner) # type: ignore

lamb_engine/parser.py

@@ -0,0 +1,101 @@
+import pyparsing as pp
+
+# Packrat gives a significant speed boost.
+pp.ParserElement.enablePackrat()
+
+class LambdaParser:
+	def make_parser(self):
+		self.lp = pp.Suppress("(")
+		self.rp = pp.Suppress(")")
+		self.pp_expr = pp.Forward()
+
+		# Bound variables are ALWAYS lowercase and single-character.
+		# We still create macro objects from them, they are turned into
+		# bound variables after the expression is built.
+		self.pp_macro = pp.Word(pp.alphas + "_")
+		self.pp_bound = pp.Regex("[a-z][₀₁₂₃₄₅₆₈₉]*")
+		self.pp_name = self.pp_bound ^ self.pp_macro
+		self.pp_church = pp.Word(pp.nums)
+		self.pp_history = pp.Char("$")
+
+		# Function calls.
+		#
+		# <exp> <exp>
+		# <exp> <exp> <exp>
+		self.pp_call = pp.Forward()
+		self.pp_call <<= (self.pp_expr | self.pp_bound | self.pp_history)[2, ...]
+
+		# Function definitions, right associative.
+		# Function args MUST be lowercase.
+		#
+		# <var> => <exp>
+		self.pp_lambda_fun = (
+			(pp.Suppress("λ") | pp.Suppress("\\")) +
+			pp.Group(self.pp_bound[1, ...]) +
+			pp.Suppress(".") +
+			(self.pp_expr ^ self.pp_call)
+		)
+
+		# Assignment.
+		# Can only be found at the start of a line.
+		#
+		# <name> = <exp>
+		self.pp_macro_def = (
+			pp.line_start() +
+			self.pp_macro +
+			pp.Suppress("=") +
+			(self.pp_expr ^ self.pp_call ^ self.pp_history)
+		)
+
+		self.pp_expr <<= (
+			self.pp_church ^
+			self.pp_lambda_fun ^
+			self.pp_name ^
+			(self.lp + self.pp_expr + self.rp) ^
+			(self.lp + self.pp_call + self.rp) ^
+			(self.lp + self.pp_history + self.rp)
+		)
+
+		self.pp_command = pp.Suppress(":") + pp.Word(pp.alphas + "_") + pp.Word(pp.printables)[0, ...]
+
+
+		self.pp_all = (
+			self.pp_expr ^
+			self.pp_macro_def ^
+			self.pp_command ^
+			self.pp_call ^
+			self.pp_history
+		)
+
+	def __init__(
+			self,
+			*,
+			action_command,
+			action_macro_def,
+			action_church,
+			action_func,
+			action_bound,
+			action_macro,
+			action_call,
+			action_history
+		):
+
+		self.make_parser()
+
+		self.pp_command.set_parse_action(action_command)
+		self.pp_macro_def.set_parse_action(action_macro_def)
+		self.pp_church.set_parse_action(action_church)
+		self.pp_lambda_fun.set_parse_action(action_func)
+		self.pp_macro.set_parse_action(action_macro)
+		self.pp_bound.set_parse_action(action_bound)
+		self.pp_call.set_parse_action(action_call)
+		self.pp_history.set_parse_action(action_history)
+
+	def parse_line(self, line: str):
+		return self.pp_all.parse_string(
+			line,
+			parse_all = True
+		)[0]
+
+	def run_tests(self, lines: list[str]):
+		return self.pp_all.run_tests(lines)

lamb_engine/runner/__init__.py

@@ -0,0 +1,2 @@
+from .runner import Runner
+from .runner import StopReason

lamb_engine/runner/commands.py

@@ -0,0 +1,420 @@
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit import print_formatted_text as printf
+from prompt_toolkit.shortcuts import clear as clear_screen
+from prompt_toolkit import prompt
+
+import os.path
+from pyparsing import exceptions as ppx
+
+import lamb_engine
+
+commands = {}
+help_texts = {}
+
+def lamb_command(
+		*,
+		command_name = None,
+		help_text: str
+	):
+	"""
+	A decorator that allows us to easily make commands
+	"""
+
+	def inner(func):
+		name = func.__name__ if command_name is None else command_name
+
+		commands[name] = func
+		help_texts[name] = help_text
+	return inner
+
+@lamb_command(
+	command_name = "step",
+	help_text = "Toggle step-by-step reduction"
+)
+def cmd_step(command, runner) -> None:
+	if len(command.args) > 1:
+		printf(
+			HTML(
+				f"<err>Command <code>:{command.name}</code> takes no more than one argument.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	target = not runner.step_reduction
+	if len(command.args) == 1:
+		if command.args[0].lower() in ("y", "yes"):
+			target = True
+		elif command.args[0].lower() in ("n", "no"):
+			target = False
+		else:
+			printf(
+				HTML(
+					f"<err>Usage: <code>:step [yes|no]</code></err>"
+				),
+				style = lamb_engine.utils.style
+			)
+			return
+
+
+	if target:
+		printf(
+			HTML(
+				f"<warn>Enabled step-by-step reduction.</warn>"
+			),
+			style = lamb_engine.utils.style
+		)
+		runner.step_reduction = True
+	else:
+		printf(
+			HTML(
+				f"<warn>Disabled step-by-step reduction.</warn>"
+			),
+			style = lamb_engine.utils.style
+		)
+		runner.step_reduction = False
+
+@lamb_command(
+	command_name = "expand",
+	help_text = "Toggle full expansion"
+)
+def cmd_expand(command, runner) -> None:
+	if len(command.args) > 1:
+		printf(
+			HTML(
+				f"<err>Command <code>:{command.name}</code> takes no more than one argument.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	target = not runner.full_expansion
+	if len(command.args) == 1:
+		if command.args[0].lower() in ("y", "yes"):
+			target = True
+		elif command.args[0].lower() in ("n", "no"):
+			target = False
+		else:
+			printf(
+				HTML(
+					f"<err>Usage: <code>:expand [yes|no]</code></err>"
+				),
+				style = lamb_engine.utils.style
+			)
+			return
+
+
+	if target:
+		printf(
+			HTML(
+				f"<warn>Enabled complete expansion.</warn>"
+			),
+			style = lamb_engine.utils.style
+		)
+		runner.full_expansion = True
+	else:
+		printf(
+			HTML(
+				f"<warn>Disabled complete expansion.</warn>"
+			),
+			style = lamb_engine.utils.style
+		)
+		runner.full_expansion = False
+
+
+@lamb_command(
+	command_name = "save",
+	help_text = "Save macros to a file"
+)
+def cmd_save(command, runner) -> None:
+	if len(command.args) != 1:
+		printf(
+			HTML(
+				f"<err>Command <code>:{command.name}</code> takes exactly one argument.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	target = command.args[0]
+	if os.path.exists(target):
+		confirm = prompt(
+			message = FormattedText([
+				("class:warn", "File exists. Overwrite? "),
+				("class:text", "[yes/no]: ")
+			]),
+			style = lamb_engine.utils.style
+		).lower()
+
+		if confirm != "yes":
+			printf(
+				HTML(
+					"<err>Cancelled.</err>"
+				),
+				style = lamb_engine.utils.style
+			)
+			return
+
+	with open(target, "w") as f:
+		f.write("\n".join(
+			[f"{n} = {e.export()}" for n, e in runner.macro_table.items()]
+		))
+
+	printf(
+		HTML(
+			f"Wrote {len(runner.macro_table)} macros to <code>{target}</code>"
+		),
+		style = lamb_engine.utils.style
+	)
+
+
+@lamb_command(
+	command_name = "load",
+	help_text = "Load macros from a file"
+)
+def cmd_load(command, runner):
+	if len(command.args) != 1:
+		printf(
+			HTML(
+				f"<err>Command <code>:{command.name}</code> takes exactly one argument.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	target = command.args[0]
+	if not os.path.exists(target):
+		printf(
+			HTML(
+				f"<err>File {target} doesn't exist.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	with open(target, "r") as f:
+		lines = [x.strip() for x in f.readlines()]
+
+	for i in range(len(lines)):
+		l = lines[i].strip()
+
+		# Skip comments and empty lines
+		if l.startswith("#"):
+			continue
+		if l == "":
+			continue
+
+		try:
+			x = runner.parse(l)[0]
+		except ppx.ParseException as e:
+			printf(
+				FormattedText([
+					("class:warn", f"Syntax error on line {i+1:02}: "),
+					("class:code", l[:e.loc]),
+					("class:err", l[e.loc]),
+					("class:code", l[e.loc+1:])
+				]),
+				style = lamb_engine.utils.style
+			)
+			return
+
+		if not isinstance(x, lamb_engine.runner.runner.MacroDef):
+			printf(
+				FormattedText([
+					("class:warn", f"Skipping line {i+1:02}: "),
+					("class:code", l),
+					("class:warn", f" is not a macro definition.")
+				]),
+				style = lamb_engine.utils.style
+			)
+			return
+
+		runner.save_macro(x, silent = True)
+
+		printf(
+			FormattedText([
+				("class:ok", f"Loaded {x.label}: ")
+			] + lamb_engine.utils.lex_str(str(x.expr))),
+			style = lamb_engine.utils.style
+		)
+
+
+@lamb_command(
+	help_text = "Delete a macro"
+)
+def mdel(command, runner) -> None:
+	if len(command.args) != 1:
+		printf(
+			HTML(
+				f"<err>Command <code>:{command.name}</code> takes exactly one argument.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	target = command.args[0]
+	if target not in runner.macro_table:
+		printf(
+			HTML(
+				f"<warn>Macro \"{target}\" is not defined</warn>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	del runner.macro_table[target]
+
+@lamb_command(
+	help_text = "Delete all macros"
+)
+def delmac(command, runner) -> None:
+	confirm = prompt(
+		message = FormattedText([
+			("class:warn", "Are you sure? "),
+			("class:text", "[yes/no]: ")
+		]),
+		style = lamb_engine.utils.style
+	).lower()
+
+	if confirm != "yes":
+		printf(
+			HTML(
+				"<err>Cancelled.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	runner.macro_table = {}
+
+
+@lamb_command(
+	help_text = "Show macros"
+)
+def macros(command, runner) -> None:
+	if len(runner.macro_table) == 0:
+		printf(FormattedText([
+				("class:warn", "No macros are defined."),
+			]),
+			style = lamb_engine.utils.style
+		)
+	else:
+		printf(FormattedText([
+				("class:cmd_h", "\nDefined Macros:\n"),
+			] +
+			[
+				("class:text", f"\t{name} \t {exp}\n")
+				for name, exp in runner.macro_table.items()
+			]),
+			style = lamb_engine.utils.style
+		)
+
+@lamb_command(
+	help_text = "Clear the screen"
+)
+def clear(command, runner) -> None:
+	clear_screen()
+	lamb_engine.utils.show_greeting()
+
+@lamb_command(
+	help_text = "Get or set reduction limit"
+)
+def rlimit(command, runner) -> None:
+	if len(command.args) == 0:
+		if runner.reduction_limit is None:
+			printf(
+				HTML(
+					"<ok>No reduction limit is set</ok>"
+				),
+				style = lamb_engine.utils.style
+			)
+		else:
+			printf(
+				HTML(
+					f"<ok>Reduction limit is {runner.reduction_limit:,}</ok>"
+				),
+				style = lamb_engine.utils.style
+			)
+		return
+
+	elif len(command.args) != 1:
+		printf(
+			HTML(
+				f"<err>Command <code>:{command.name}</code> takes exactly one argument.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	t = command.args[0]
+	if t.lower() == "none":
+		runner.reduction_limit = None
+		printf(
+			HTML(
+				f"<ok>Removed reduction limit</ok>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	try:
+		t = int(t)
+	except ValueError:
+		printf(
+			HTML(
+				"<err>Reduction limit must be a positive integer or \"none\".</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	if 50 > t:
+		printf(
+			HTML(
+				"<err>Reduction limit must be at least 50.</err>"
+			),
+			style = lamb_engine.utils.style
+		)
+		return
+
+	runner.reduction_limit = t
+	printf(
+		HTML(
+			f"<ok>Set reduction limit to {t:,}</ok>"
+		),
+		style = lamb_engine.utils.style
+	)
+
+
+
+@lamb_command(
+	help_text = "Print this help"
+)
+def help(command, runner) -> None:
+	printf(
+		HTML(
+			"\n<text>" +
+
+			"<cmd_h>Usage:</cmd_h>" +
+			"\n" +
+			"\tWrite lambda expressions using your <cmd_key>\\</cmd_key> key." +
+			"\n" +
+			"\tMacros can be defined using <cmd_key>=</cmd_key>, as in <code>T = λab.a</code>" +
+			"\n" +
+			"\tRun commands using <cmd_key>:</cmd_key>, for example <code>:help</code>" +
+			"\n" +
+			"\tHistory can be accessed with <cmd_key>$</cmd_key>, which will expand to the result of the last successful reduction." +
+			"\n\n" +
+			"<cmd_h>Commands:</cmd_h>"+
+			"\n" +
+			"\n".join([
+				f"\t<code>{name}</code> \t {text}"
+				for name, text in help_texts.items()
+			]) +
+			"\n\n"
+			"<muted>Detailed documentation can be found on this project's git page.</muted>" +
+			"</text>"
+		),
+		style = lamb_engine.utils.style
+	)

lamb_engine/runner/misc.py

@@ -0,0 +1,42 @@
+import enum
+import lamb_engine
+
+class StopReason(enum.Enum):
+	BETA_NORMAL		= ("class:text", "β-normal form")
+	LOOP_DETECTED	= ("class:warn", "Loop detected")
+	MAX_EXCEEDED	= ("class:err", "Too many reductions")
+	INTERRUPT		= ("class:warn", "User interrupt")
+	SHOW_MACRO		= ("class:text", "Displaying macro content")
+
+class MacroDef:
+	@staticmethod
+	def from_parse(result):
+		return MacroDef(
+			result[0].name,
+			result[1]
+		)
+
+	def __init__(self, label: str, expr: lamb_engine.nodes.Node):
+		self.label = label
+		self.expr = expr
+
+	def __repr__(self):
+		return f"<{self.label} := {self.expr!r}>"
+
+	def __str__(self):
+		return f"{self.label} := {self.expr}"
+
+	def set_runner(self, runner):
+		return self.expr.set_runner(runner)
+
+class Command:
+	@staticmethod
+	def from_parse(result):
+		return Command(
+			result[0],
+			result[1:]
+		)
+
+	def __init__(self, name, args):
+		self.name = name
+		self.args = args

lamb_engine/runner/runner.py

@@ -0,0 +1,303 @@
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit import prompt
+from prompt_toolkit import print_formatted_text as printf
+import collections
+import math
+import time
+
+import lamb_engine
+
+from lamb_engine.runner.misc import MacroDef
+from lamb_engine.runner.misc import Command
+from lamb_engine.runner.misc import StopReason
+from lamb_engine.runner import commands as cmd
+
+
+# Keybindings for step prompt.
+# Prevents any text from being input.
+step_bindings = KeyBindings()
+@step_bindings.add("<any>")
+def _(event):
+	pass
+
+
+class Runner:
+	def __init__(
+		self,
+		prompt_session: PromptSession,
+		prompt_message
+	):
+		self.macro_table = {}
+		self.prompt_session = prompt_session
+		self.prompt_message = prompt_message
+		self.parser = lamb_engine.parser.LambdaParser(
+			action_func = lamb_engine.nodes.Func.from_parse,
+			action_bound = lamb_engine.nodes.Macro.from_parse,
+			action_macro = lamb_engine.nodes.Macro.from_parse,
+			action_call = lamb_engine.nodes.Call.from_parse,
+			action_church = lamb_engine.nodes.Church.from_parse,
+			action_macro_def = MacroDef.from_parse,
+			action_command = Command.from_parse,
+			action_history = lamb_engine.nodes.History.from_parse
+		)
+
+		# Maximum amount of reductions.
+		# If None, no maximum is enforced.
+		# Must be at least 1.
+		self.reduction_limit = 1_000_000
+
+		# Ensure bound variables are unique.
+		# This is automatically incremented whenever we make
+		# a bound variable.
+		self.bound_variable_counter = 0
+
+		# Update iteration after this many iterations
+		# Make sure every place value has a non-zero digit
+		# so that all digits appear to be changing.
+		self.iter_update = 231
+
+		self.history = collections.deque(
+			[None] * 10,
+			10)
+
+
+		# If true, reduce step-by-step.
+		self.step_reduction = False
+
+		# If true, expand ALL macros when printing output
+		self.full_expansion = False
+
+	def prompt(self):
+		return self.prompt_session.prompt(
+			message = self.prompt_message
+		)
+
+	def parse(self, line): # -> tuple[lamb_engine.nodes.Root | MacroDef | Command, list]
+		e = self.parser.parse_line(line)
+
+		w = []
+		if isinstance(e, MacroDef):
+			e.expr = lamb_engine.nodes.Root(e.expr)
+			e.set_runner(self)
+			w = lamb_engine.nodes.prepare(e.expr, ban_macro_name = e.label)
+		elif isinstance(e, lamb_engine.nodes.Node):
+			e = lamb_engine.nodes.Root(e)
+			e.set_runner(self)
+			w = lamb_engine.nodes.prepare(e)
+
+		return e, w
+
+
+	def reduce(self, node: lamb_engine.nodes.Root, *, warnings = []) -> None:
+
+		# Reduction Counter.
+		# We also count macro (and church) expansions,
+		# and subtract those from the final count.
+		k = 0
+		macro_expansions = 0
+
+		stop_reason = StopReason.MAX_EXCEEDED
+		start_time = time.time()
+		out_text = []
+
+		only_macro = (
+			isinstance(node.left, lamb_engine.nodes.Macro) or
+			isinstance(node.left, lamb_engine.nodes.Church)
+		)
+		if only_macro:
+			stop_reason = StopReason.SHOW_MACRO
+		m, node = lamb_engine.nodes.expand(node, force_all = only_macro)
+		macro_expansions += m
+
+		if len(warnings) != 0:
+			printf(FormattedText(warnings), style = lamb_engine.utils.style)
+
+		if self.step_reduction:
+			printf(FormattedText([
+				("class:warn", "Step-by-step reduction is enabled.\n"),
+				("class:muted", "Press "),
+				("class:cmd_key", "ctrl-c"),
+				("class:muted", " to continue automatically.\n"),
+				("class:muted", "Press "),
+				("class:cmd_key", "enter"),
+				("class:muted", " to step.\n"),
+			]), style = lamb_engine.utils.style)
+
+
+		skip_to_end = False
+		try:
+			while (
+					(
+						(self.reduction_limit is None) or
+						(k < self.reduction_limit)
+					) and not only_macro
+				):
+
+				# Show reduction count
+				if (
+						( (k >= self.iter_update) and (k % self.iter_update == 0) )
+						and not (self.step_reduction and not skip_to_end)
+					):
+					print(f" Reducing... {k:,}", end = "\r")
+
+				# Reduce
+				red_type, node = lamb_engine.nodes.reduce(node)
+
+				# If we can't reduce this expression anymore,
+				# it's in beta-normal form.
+				if red_type == lamb_engine.nodes.ReductionType.NOTHING:
+					stop_reason = StopReason.BETA_NORMAL
+					break
+
+				# Count reductions
+				k += 1
+				if red_type == lamb_engine.nodes.ReductionType.FUNCTION_APPLY:
+					macro_expansions += 1
+
+				# Pause after step if necessary
+				if self.step_reduction and not skip_to_end:
+					try:
+						s = prompt(
+							message = FormattedText([
+								("class:prompt", lamb_engine.nodes.reduction_text[red_type]),
+								("class:prompt", f":{k:03} ")
+							] + lamb_engine.utils.lex_str(str(node))),
+							style = lamb_engine.utils.style,
+							key_bindings = step_bindings
+						)
+					except KeyboardInterrupt or EOFError:
+						skip_to_end = True
+						printf(FormattedText([
+							("class:warn", "Skipping to end."),
+						]), style = lamb_engine.utils.style)
+
+		# Gracefully catch keyboard interrupts
+		except KeyboardInterrupt:
+			stop_reason = StopReason.INTERRUPT
+
+		# Print a space between step messages
+		if self.step_reduction:
+			print("")
+
+		# Clear reduction counter if it was printed
+		if k >= self.iter_update:
+			print(" " * round(14 + math.log10(k)), end = "\r")
+
+		# Expand fully if necessary
+		if self.full_expansion:
+			o, node = lamb_engine.nodes.expand(node, force_all = True)
+			macro_expansions += o
+
+		if only_macro:
+			out_text += [
+				("class:ok", f"Displaying macro content")
+			]
+
+		else:
+			if not self.step_reduction:
+				out_text += [
+					("class:ok", f"Runtime: "),
+					("class:text", f"{time.time() - start_time:.03f} seconds"),
+					("class:text", "\n")
+				]
+
+			out_text += [
+				("class:ok", f"Exit reason: "),
+				stop_reason.value,
+				("class:text", "\n"),
+
+				("class:ok", f"Macro expansions: "),
+				("class:text", f"{macro_expansions:,}"),
+				("class:text", "\n"),
+
+				("class:ok", f"Reductions: "),
+				("class:text", f"{k:,}\t"),
+				("class:muted", f"(Limit: {self.reduction_limit:,})")
+			]
+
+		if self.full_expansion:
+			out_text += [
+				("class:text", "\n"),
+				("class:ok", "All macros have been expanded")
+			]
+
+		if (
+				stop_reason == StopReason.BETA_NORMAL or
+				stop_reason == StopReason.LOOP_DETECTED or
+				only_macro
+		):
+			out_text += [
+				("class:ok", "\n\n    => ")
+			] + lamb_engine.utils.lex_str(str(node))
+
+
+		printf(
+			FormattedText(out_text),
+			style = lamb_engine.utils.style
+		)
+
+		# Save to history
+		# Do this at the end so we don't always fully expand.
+		self.history.appendleft(
+			lamb_engine.nodes.expand( # type: ignore
+				node,
+				force_all = True
+			)[1]
+		)
+
+	def save_macro(
+			self,
+			macro: MacroDef,
+			*,
+			silent = False
+		) -> None:
+		was_rewritten = macro.label in self.macro_table
+		self.macro_table[macro.label] = macro.expr
+
+		if not silent:
+			printf(FormattedText([
+				("class:text", "Set "),
+				("class:code", macro.label),
+				("class:text", " to "),
+				("class:code", str(macro.expr))
+			]), style = lamb_engine.utils.style)
+
+	# Apply a list of definitions
+	def run(
+			self,
+			line: str,
+			*,
+			silent = False
+		) -> None:
+		e, w = self.parse(line)
+
+		# If this line is a macro definition, save the macro.
+		if isinstance(e, MacroDef):
+			self.save_macro(e, silent = silent)
+
+		# If this line is a command, do the command.
+		elif isinstance(e, Command):
+			if e.name not in cmd.commands:
+				printf(
+					FormattedText([
+						("class:warn", f"Unknown command \"{e.name}\"")
+					]),
+					style = lamb_engine.utils.style
+				)
+			else:
+				cmd.commands[e.name](e, self)
+
+		# If this line is a plain expression, reduce it.
+		elif isinstance(e, lamb_engine.nodes.Node):
+			self.reduce(e, warnings = w)
+
+		# We shouldn't ever get here.
+		else:
+			raise TypeError(f"I don't know what to do with a {type(e)}")
+
+
+	def run_lines(self, lines: list[str]):
+		for l in lines:
+			self.run(l, silent = True)

lamb_engine/utils.py

@@ -0,0 +1,165 @@
+from prompt_toolkit.styles import Style
+from prompt_toolkit.formatted_text import HTML
+from prompt_toolkit.lexers import Lexer
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit import print_formatted_text as printf
+from importlib.metadata import version
+from prompt_toolkit.document import Document
+
+import re
+
+
+style = Style.from_dict({ # type: ignore
+	# Basic formatting
+	"text": "#FFFFFF",
+	"warn": "#FFA700",
+	"err": "#FF3809",
+	"prompt": "#05CFFF",
+	"ok": "#00EF7C",
+	"code": "#AAAAAA italic",
+	"muted": "#AAAAAA",
+
+	# Syntax highlighting colors
+	"syn_cmd": "#FFFFFF italic",
+	"syn_lambda": "#AAAAAA",
+	"syn_paren": "#AAAAAA",
+
+	# Command formatting
+	# cmd_h:    section titles
+	# cmd_key:  keyboard keys, usually one character
+	"cmd_h": "#FF3809 bold",
+	"cmd_key": "#00EF7C bold",
+
+	# Only used in greeting
+	"_v": "#00EF7C bold",
+	"_l": "#FF3809 bold",
+	"_s": "#00EF7C bold",
+	"_p": "#AAAAAA"
+})
+
+
+# Replace "\" with pretty "λ"s
+bindings = KeyBindings()
+@bindings.add("\\")
+def _(event):
+	event.current_buffer.insert_text("λ")
+
+# Simple lexer for highlighting.
+# Improve this later.
+class LambdaLexer(Lexer):
+	def lex_document(self, document):
+		def inner(line_no):
+			out = []
+			tmp_str = []
+			d = str(document.lines[line_no])
+
+			if d.startswith(":"):
+				return [
+					("class:syn_cmd", d)
+				]
+
+			for c in d:
+				if c in "\\λ.":
+					if len(tmp_str) != 0:
+						out.append(("class:text", "".join(tmp_str)))
+					out.append(("class:syn_lambda", c))
+					tmp_str = []
+				elif c in "()":
+					if len(tmp_str) != 0:
+						out.append(("class:text", "".join(tmp_str)))
+					out.append(("class:syn_paren", c))
+					tmp_str = []
+				else:
+					tmp_str.append(c)
+
+			if len(tmp_str) != 0:
+				out.append(("class:text", "".join(tmp_str)))
+			return out
+		return inner
+
+
+
+def lex_str(s: str) -> list[tuple[str, str]]:
+	return LambdaLexer().lex_document(Document(s))(0)
+
+def show_greeting():
+	#   |  _.._ _.|_
+	#   |_(_|| | ||_)
+	#       0.0.0
+	#
+	#       __  __
+	#    ,-`  ``  `,
+	#   (`   \      )
+	#  (`     \     `)
+	#  (,    / \    _)
+	#   (`  /   \   )
+	#    `'._.--._.'
+	#
+	# A λ calculus engine
+
+	printf(HTML("\n".join([
+		"",
+		"<_h>    |  _.._ _.|_",
+		"    |_(_|| | ||_)</_h>",
+		f"        <_v>{version('lamb_engine')}</_v>",
+		"        __  __",
+		"     ,-`  ``  `,",
+		"    (`   <_l>\\</_l>      )",
+		"   (`     <_l>\\</_l>     `)",
+		"   (,    <_l>/ \\</_l>    _)",
+		"    (`  <_l>/   \\</_l>   )",
+		"     `'._.--._.'",
+		"",
+		"<_s> A λ calculus engine</_s>",
+		"<_p> Type :help for help</_p>",
+		""
+	])), style = style)
+
+def remove_sub(s: str):
+	return re.sub("[₀₁₂₃₄₅₆₈₉]*", "", s)
+
+def base4(n: int):
+	if n == 0:
+		return [0]
+	digits = []
+	while n:
+		digits.append(n % 4)
+		n //= 4
+	return digits[::-1]
+
+def subscript(num: int):
+
+	# unicode subscripts  ₀₁₂₃ and ₄₅₆₈₉
+	# usually look different,
+	# so we'll use base 4.
+	qb = base4(num)
+
+	sub = {
+		"0": "₀",
+		"1": "₁",
+		"2": "₂",
+		"3": "₃",
+		"4": "₄",
+		"5": "₅",
+		"6": "₆",
+		"7": "₇",
+		"8": "₈",
+		"9": "₉"
+	}
+
+	sup = {
+		"0": "⁰",
+		"1": "¹",
+		"2": "²",
+		"3": "³",
+		"4": "⁴",
+		"5": "⁵",
+		"6": "⁶",
+		"7": "⁷",
+		"8": "⁸",
+		"9": "⁹"
+	}
+
+	return "".join(
+		[sub[str(x)] for x in qb]
+	)

macros.lamb

@@ -0,0 +1,77 @@
+# How to use exported files in lamb:
+#
+# [Syntax Highlighting]
+#	Most languages' syntax highlighters will
+#	highlight this code well. Set it manually
+#	in your editor.
+#
+#	Don't use a language for which you have a
+#	linter installed, you'll get lots of errors.
+#
+#	Choose a language you don't have extenstions for,
+#	and a language that uses # comments.
+#
+# The following worked well in vscode:
+# - Julia
+# - Perl
+# - Coffeescript
+# - R
+
+# [Writing macros]
+#	If you don't have a custom keyboard layout that can
+#	create λs, you may use backslashes instead.
+#	(As in `T = \ab.b`)
+#
+#	This file must only contain macro definitons. Commands will be ignored.
+#	Statements CANNOT be split among multiple lines.
+#	Comments CANNOT be on the same line as macro defintions.
+#	All leading whitespace is ignored.
+
+
+# Misc Combinators
+M = λx.(x x)
+W = (M M)
+Y = λf.( (λx.(f (x x))) (λx.(f (x x))) )
+
+
+# Booleans
+T = λab.a
+F = λab.b
+NOT = λa.(a F T)
+AND = λab.(a b F)
+OR = λab.(a T b)
+XOR = λab.((a (NOT b)) b)
+
+
+# Numbers
+# PAIR: prerequisite for H.
+#	Makes a two-value tuple, indexed with T and F.
+#
+# H: shift-and-add, prerequisite for D
+#
+# S: successor (adds 1)
+#
+# D: predecessor (subtracts 1)
+#
+# Z: tests if a number is zero
+# NZ: equivalent to `NOT Z`
+#
+# ADD: adds two numbers
+#
+# MULT: multiply two numbers
+#
+# FAC:
+#	Recursive factorial. Call with `Y FAC <number>`
+#	Don't call this with numbers bigger than 5 unless you're very patient.
+#
+#	`Y FAC 6` required 867,920 reductions and took 10 minutes to run.
+
+PAIR = λabi.(i a b)
+S = λnfa.(f (n f a))
+H = λp.((PAIR (p F)) (S (p F)))
+D = λn.(n H (PAIR 0 0) T)
+Z = λn.(n (λa.F) T)
+NZ = λn.(n (λa.T) F)
+ADD = λmn.(m S n)
+MULT = λnmf.(n (m f))
+FAC = λyn.(Z n) (1) (MULT n (y (D n)))

misc/demo.tape

@@ -0,0 +1,84 @@
+# See makedemo.sh
+
+#Output lambdemo.mp4
+Output lambdemo.gif
+
+Set FontSize 30
+Set Width 2000
+Set Height 1500
+Set FontFamily "FantasqueSansMono NF"
+Set TypingSpeed 60ms
+Set Framerate 30
+
+# Intro
+Sleep 2000ms
+Type "lamb"
+Sleep 1000ms
+Enter
+Sleep 2000ms
+
+# Demo 1: load
+Type ":load ../macros.lamb"
+Sleep 500ms
+Enter
+Sleep 2000ms
+
+Type "NOT T"
+Sleep 1000ms
+Enter
+Sleep 6s
+
+Type ":clear"
+Sleep 1000ms
+Enter
+Sleep 1500ms
+
+
+# Demo 2: stepping
+Type ":step"
+Sleep 500ms
+Enter
+Sleep 1500ms
+
+Type "NOT T"
+Sleep 100ms
+Enter
+Sleep 1500ms
+Enter
+Sleep 760ms
+Enter
+Sleep 850ms
+Enter
+Sleep 650ms
+Enter
+Sleep 700ms
+Enter
+
+Sleep 3000ms
+
+Type ":step"
+Sleep 500ms
+Enter
+Sleep 6s
+Type ":clear"
+Sleep 1000ms
+Enter
+Sleep 1500ms
+
+# Demo 3: macros
+Type "M = \x.x x"
+Sleep 500ms
+Enter
+Sleep 500ms
+
+Type "M M"
+Sleep 500ms
+Enter
+Sleep 3s
+Ctrl+c
+Sleep 1000ms
+
+Type "Y FAC 3"
+Sleep 500ms
+Enter
+Sleep 6s

misc/makedemo.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Should be run from the misc directory.
+# Will not work with any other root.
+
+# Create this file.
+# Should define two variables:
+# DAV_USER="name:password"
+# DAV_URL="https://site.com/dav-path"
+
+if [[ -f "secrets.sh" ]]; then
+	source secrets.sh
+else
+	echo "Cannot run without secrets.sh"
+	exit
+fi
+
+# Activate venv if not in venv
+if [[ "$VIRTUAL_ENV" == "" ]]; then
+	source ../venv/bin/activate
+fi
+
+# Make sure our venv is running the latest
+# version of lamb.
+pip install --editable ..
+
+
+# Make gif
+vhs < demo.tape
+
+# Upload
+curl \
+	--user $DAV_USER \
+	--url $DAV_URL \
+	--upload-file "lambdemo.gif"

pyproject.toml

@@ -1,16 +1,28 @@
+[build-system]
+requires = [ "setuptools>=61.0" ]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+where = [ "." ]
+include = ["lamb_engine*"]
+namespaces = false
+
+[project.scripts]
+lamb = "lamb_engine:main"
+
+
+
 [project]
-name = "Lamb"
+name = "lamb_engine"
 description = "A lambda calculus engine"
-version = "0.0.0"
+version = "1.1.9"
 dependencies = [
 	"prompt-toolkit==3.0.31",
 	"pyparsing==3.0.9"
 ]
-
 authors = [
 	{ name="Mark", email="mark@betalupi.com" }
 ]
-
 readme = "README.md"
 requires-python = ">=3.7"
 license = {text = "GNU General Public License v3 (GPLv3)"}
@@ -21,20 +33,10 @@ classifiers = [
 	"Environment :: Console"
 ]
 
-
 [project.urls]
 "Homepage" = "https://git.betalupi.com/Mark/lamb"
 
-
+# To build:
-[build-system]
+# pip install build twine
-requires = [ "setuptools>=61.0" ]
+# python -m build
-build-backend = "setuptools.build_meta"
+# twine upload dist/lamb_engine-1.1.6* (change the version)
-
-[tool.setuptools.packages.find]
-where = ["lamb"]
-include = ["lamb*"]
-namespaces = false
-
-[project.optional-dependencies]
-# Used to build a standalone executable
-pyinstaller = [	"pyinstaller==5.5" ]