Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/Kwasniok/LambdaCalculus
lambda calculus in haskell
https://github.com/Kwasniok/LambdaCalculus
evaluation haskell lambda-calculus lambda-expressions parse valid
Last synced: 2 months ago
JSON representation
lambda calculus in haskell
- Host: GitHub
- URL: https://github.com/Kwasniok/LambdaCalculus
- Owner: Kwasniok
- License: bsd-3-clause
- Created: 2020-10-20T00:30:42.000Z (over 4 years ago)
- Default Branch: default
- Last Pushed: 2020-11-01T19:55:14.000Z (about 4 years ago)
- Last Synced: 2024-08-10T11:02:55.378Z (6 months ago)
- Topics: evaluation, haskell, lambda-calculus, lambda-expressions, parse, valid
- Language: Haskell
- Homepage:
- Size: 37.1 KB
- Stars: 4
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- License: LICENSE
Awesome Lists containing this project
README
# Lambda Calculus
A small [cabal](https://www.haskell.org/cabal/) package for haskell featuring the basic operations of lambda calculus.
## Feature List
- Representation of objects in lambda calculus as data structures
- IO of lambda expressions
- Validity check of lambda expressions
- Stepwise evaluation of lambda expressions
## Installation
Installation of this library via [cabal](https://www.haskell.org/cabal/) package manager:
```
cabal instal --lib
```
This will register the package for [GHC](https://www.haskell.org/ghc/) as well.
## Usage
After a succeccfull installation all modules are known to and importable from within GHC/GHCI.
### Modules
- `Lambda.Data` contains all data structures representing the lambda calculus and output functions (`show`)
- `Lambda.Parse` contains a parser function for all data structures
- `Lambda.Evaluation` contains functions related to expression evaluation
### Notation
The standard notation ~`λx. λy. x y`~ is represented as `\x. (\y. (x y))` with explicit **parentheses around each function body** if more than one term is present and exactly **one parameter per function**.
Other **term lists** have to be placed **within parentheses** as well: ~`(λx. λy. x y) a b`~ becomes `(\x. (\y. (x y)) a b)`.
## Examples
### Input/Output
Use `parse` to parse a grammatical data structure like `word` (top level structure):
```
> import Lambda.Parse
> parse word "\\a. \\b. (a b)"
Just (\a. (\b. (a b)))
>
```
Printing is implicit for each line but one can use `show` to turn a grammatical data structure into a string as a in:
```
> import Lambda.Parse
> w = parse word "\\a. \\b. (a b)"
> show w
"Just (\a. (\b. (a b)))"
>
```
### Check Validity
To check the validity of a lambda expression use `valid` as in:
```
> import Lambda.Parse
> import Lambda.Evaluate
> import Data.Maybe
> w = w = fromJust (parse word "(\\x. \\y. (x y) \\y. (y z))")
> valid w
True
> w = w = fromJust (parse word "(\\x. \\x. (x y) \\y. (y z))")
> valid w
False
>
```
### Evaluation (Stepwise)
To perform a single evaluation step (for any **valid** lambda expression) use `eval` as in:
```
> import Lambda.Evaluate
> import Lambda.Parse
> import Data.Maybe
> w = fromJust $ parse word "(\\x. \\y. (x y) a b)"
> iterate eval w !! 0
((\x. (\y. (x y))) a b)
> iterate eval w !! 1
((\y. (a y)) b)
> iterate eval w !! 2
(a b)
> iterate eval w !! 3
(a b)
>
```
## Dependencies
- haskell compiler: [ghc](https://www.haskell.org/ghc/) v4.9.0.0 or newer
- archlinux: [ghc package](https://www.archlinux.org/packages/community/x86_64/ghc/) (may require further packages)
- haskell package manager: [cabal](https://www.haskell.org/cabal/) v2.4 or newer