WeberLogic
=========
Logic interpreter and parsing library
## Install ##
```sh
cabal update
cabal install WeberLogic
```
## Interpreter ##
```
$ ./WeberLogic
Enter Command
> truthTable: a&b+c->~a&b
'a' 'b' 'c' | (((a&b)+c)->(~a&b))
True True True | False
True True False | False
True False True | False
True False False | True
False True True | True
False True False | True
False False True | False
False False False | True
Enter Command
> toNand: a&b->c
(((((a|b)|(a|b))|((a|b)|(a|b)))|(((a|b)|(a|b))|((a|b)|(a|b))))|(c|c))
Enter Command
> toNor: a&b->c
(((((a/a)/(b/b))/((a/a)/(b/b)))/c)/((((a/a)/(b/b))/((a/a)/(b/b)))/c))
```
## Library ##
The library contains two modules.
1. `WeberLogic.Parser`
2. `WeberLogic.Actions`
### WeberLogic.Parser ###
The `WeberLogic.Parser` provides functions which read stings and return
an abstract syntax tree (AST). The AST in implement with a data type
called `LogicExp` and `Letter`.
* Data Types
* `LogicExp` - A recursively defined data type which implements as
abstract syntax tree. It provides the following type constructors
which function as nodes in the AST: `Not`, `And`, `Or`, `Implies`,
`Iff`, `Nand`, and `Nor`. The `Predicate` type constructor
functions as the AST leaves.
```haskell
> import WeberLogic.Parser
> Predicate 'A' [(Variable 'x', Name 'a')]
> Not (Predicate 'A' [(Variable 'x', Name 'a')])
> And (Predicate 'A' [(Variable 'x', Name 'a')]) (Predicate 'B' [])
```
* `Letter` - This Data Constructor provies two Type constructors
`Variable` and `Name`. They are used in the construction of
`Predicate` which requires a list of type `Letter`
```haskell
> import WeberLogic.Parser
> Predicate 'A' [(Variable 'x', Name 'a')]
```
* Functions
* `parseExp`
```haskell
> import WeberLogic.Parser
> a = parseExp "Axa"
> b = parseExp "~Axa"
> c = parseExp "Axa&B"
```
* `parseArg`
```haskell
> import WeberLogic.Parser
> a = parseExp "|- Axa"
> b = parseExp "~Axa, B |- Cax"
> c = parseExp "Axa&B, B, C |- Ax->By"
```
### WeberLogic.Actions ###
The `WeberLogic.Actions` modules provides functions which manipulate the
`LogicExp` AST.
```haskell
> import WeberLogic.Parser
> import WeberLogic.Actions
> mapM_ putStrLn $ truthTableStr $ readExp "A&B"
'a' 'b' | (a&~b)
True True | False
True False | True
False True | False
False False | False
> toNand $ readExp "A&~B"
((a|(b|b))|(a|(b|b)))
> toNor $ readExp "A&~B"
((a/a)/((b/b)/(b/b)))
```