james
/
ivo
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
ivo/README.md

36 lines
1.6 KiB
Markdown
Raw Normal View History

Make the parser produce a subtly better AST. This is done by requiring applications to be at least 2 terms, and making grouping a syntactic feature instead of a feature of applications. I also made the code a bit more clear by handling whitespace a bit more cleanly; now, each parser is responsible for its own trailing whitespace, and whitespace handling is pushed down to the token level to avoid cluttering high-level definitions with whitespace stuff. This all also had the effect of improving error messages, in part due to me labelling many of the parsers.
2020-11-03 15:52:04 -08:00
# Lambda Calculus
Make the parser more forgiving, re-add `let`, update README.
2020-11-02 15:59:35 -08:00
This is a simple implementation of the untyped lambda calculus
with an emphasis on clear, readable Haskell code.
Initial commit. Some terms are still not evaluated correctly.
2019-08-15 10:42:24 -07:00
## Usage
Type in your expression at the prompt: `>> `.
Make the parser more forgiving, re-add `let`, update README.
2020-11-02 15:59:35 -08:00
The expression will be evaluated to normal form and then printed.
Exit the prompt with `Ctrl-c` (or equivalent).
Added nullary applications and generalized eta reductions.
2019-08-19 15:08:45 -07:00
Added `let`, removed `Nil`, replaced `subst` with `Subst` exprs.
2019-08-21 15:18:25 -07:00
### Example session
Initial commit. Some terms are still not evaluated correctly.
2019-08-15 10:42:24 -07:00
```
Make the printer smarter, separate intermediate AST data type. * The expression printer now knows how to use `let`, multi-argument lambdas and applications, and block arguments when appropriate. * There is a separate type, AbstractSyntax, which separates parsing/printing logic from removing/reintroducing the more advanced syntax described above. * Expression is now its own module because its 'show' depends on AbstractSyntax, and I don't want the ast2expr/expr2ast stuff to be in the same module as the real lambda calculus stuff.
2020-11-03 13:29:59 -08:00
>> let D = \x. x x; F = \f. f (f y) in D (F \x. x)
y y
>> let T = \f x. f (f x) in (\f x. T (T (T (T T))) f x) (\x. x) y
I fixed it! Also deleted some unused code, and refactored a little.
2019-08-15 13:11:17 -07:00
y
Make the parser more forgiving, re-add `let`, update README.
2020-11-02 15:59:35 -08:00
>> (\x y z. x y) y
Make the printer smarter, separate intermediate AST data type. * The expression printer now knows how to use `let`, multi-argument lambdas and applications, and block arguments when appropriate. * There is a separate type, AbstractSyntax, which separates parsing/printing logic from removing/reintroducing the more advanced syntax described above. * Expression is now its own module because its 'show' depends on AbstractSyntax, and I don't want the ast2expr/expr2ast stuff to be in the same module as the real lambda calculus stuff.
2020-11-03 13:29:59 -08:00
λy' z. y y'
Make the parser produce a subtly better AST. This is done by requiring applications to be at least 2 terms, and making grouping a syntactic feature instead of a feature of applications. I also made the code a bit more clear by handling whitespace a bit more cleanly; now, each parser is responsible for its own trailing whitespace, and whitespace handling is pushed down to the token level to avoid cluttering high-level definitions with whitespace stuff. This all also had the effect of improving error messages, in part due to me labelling many of the parsers.
2020-11-03 15:52:04 -08:00
>> let fix = (\x. x x) \fix f x. f (fix fix f) x; S = \n f x. f (n f x); plus = fix \plus x. x S in plus (\f x. f (f (f x))) (\f x. f (f x)) f x
f (f (f (f (f x))))
Added `let`, removed `Nil`, replaced `subst` with `Subst` exprs.
2019-08-21 15:18:25 -07:00
>> ^C
Initial commit. Some terms are still not evaluated correctly.
2019-08-15 10:42:24 -07:00
```
Added `let`, removed `Nil`, replaced `subst` with `Subst` exprs.
2019-08-21 15:18:25 -07:00
## Notation
[Conventional Lambda Calculus notation applies](https://en.wikipedia.org/wiki/Lambda_calculus_definition#Notation),
Make the parser more forgiving, re-add `let`, update README.
2020-11-02 15:59:35 -08:00
with the exception that variable names are multiple characters long,
Make the parser produce a subtly better AST. This is done by requiring applications to be at least 2 terms, and making grouping a syntactic feature instead of a feature of applications. I also made the code a bit more clear by handling whitespace a bit more cleanly; now, each parser is responsible for its own trailing whitespace, and whitespace handling is pushed down to the token level to avoid cluttering high-level definitions with whitespace stuff. This all also had the effect of improving error messages, in part due to me labelling many of the parsers.
2020-11-03 15:52:04 -08:00
`\` is permitted in lieu of `λ` to make it easier to type,
Make the parser more forgiving, re-add `let`, update README.
2020-11-02 15:59:35 -08:00
and spaces are used to separate variables rather than commas.
Added `let`, removed `Nil`, replaced `subst` with `Subst` exprs.
2019-08-21 15:18:25 -07:00
* Variable names are alphanumeric, beginning with a letter.
* Outermost parentheses may be dropped: `M N` is equivalent to `(M N)`.
* Applications are left-associative: `M N P` may be written instead of `((M N) P)`.
Make the parser more forgiving, re-add `let`, update README.
2020-11-02 15:59:35 -08:00
* The body of an abstraction or let expression extends as far right as possible: `\x. M N` means `\x.(M N)` and not `(\x. M) N`.
Added `let`, removed `Nil`, replaced `subst` with `Subst` exprs.
2019-08-21 15:18:25 -07:00
* A sequence of abstractions may be contracted: `\foo. \bar. \baz. N` may be abbreviated as `\foo bar baz. N`.
Allow defining multiple variables with one `let`.
2020-11-03 11:33:35 -08:00
* Variables may be bound using let expressions: `let x = N in M` is syntactic sugar for `(\x. N) M`.
* Multiple variables may be defined in one let expression: `let x = N; y = O in M`