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)))
```