Safe Haskell | Safe-Infered |
---|

Hascal is both a simple but extendable calculator library for Haskell and a command-line program using it.

Also, its source code is a nice example for a minimalistic Haskell project.

Some examples for the usage of the command-line program:

`>>>`

3.0`hascal 1+2`

`>>>`

6.99989796959493929190898887868584838281807978777676`hascal 1+2*3-4/198^2`

Also, preceding exclamation marks mean that the following number is imaginary, that is, you have to multiply it with i. E.g.:

`>>>`

!1.0`hascal _1 ^ 0.5`

And as you can see, negative numbers are preceded by a underscore.

Although hascal itself doesn't understand brackets, you can use your shell to get that functionality, like this (using bash):

`>>>`

-1.0`hascal e ^ $(hascal i*pi)`

Speaking of shells, you should consider that your shell might extend an asterisk (*) to the files at the current directory, like here:

`>>>`

_darcs dist hascal.cabal Hascal.hs LICENSE Main.hs README.org Setup.hs`echo *`

That's why this might not work:

`>>>`

Error. :(`hascal 1 * 2`

But you could do this instead:

`>>>`

2`hascal 1*2`

Yeah, that's it. Hascal is really minimalistic. And I'm not planning to extend it much.

- data Complex a
- operators :: RealFloat t => [(Char, Complex t -> Complex t -> Complex t)]
- eval :: (Read t, RealFloat t) => [(Char, Complex t -> Complex t -> Complex t)] -> String -> Maybe (Complex t)
- hascal :: (Read t, RealFloat t) => String -> Maybe (Complex t)
- prettyPrint :: (Show t, RealFloat t) => Complex t -> String

# Types

Just re-exporting the `Complex`

data-type for simplicity and comfort.

data Complex a

# Functions

## Operators

operators :: RealFloat t => [(Char, Complex t -> Complex t -> Complex t)]Source

`operators`

is the default list of operators.

An operator consists of one character and a function with of type
`Number -> Number -> Number`

.

`operators`

includes:

- addition, represented by
`'+'`

, - subtraction, represented by
`'-'`

, - multiplication, represented by
`'c'`

, - division, represented by
`'/'`

, - exponentiation, represented by
`'^'`

, and - logarithming (with flipped arguments, see below), represented by
`'?'`

,

such that these laws are held:

(a - b == c) == (a == b + c) (a / b == c) == (a == b * c) (a ? b == c) == (a == b ^ c)

## Evaluators

:: (Read t, RealFloat t) | |

=> [(Char, Complex t -> Complex t -> Complex t)] | list of operators |

-> String | string containing term |

-> Maybe (Complex t) | just result, or nothing |

`eval`

gets a list of operators and a string containing a mathematical
expression/term which only uses those operators listed in the first
argument, and returns the result of that term.

## Pretty Printers

prettyPrint :: (Show t, RealFloat t) => Complex t -> StringSource

`prettyPrint`

prints a number nicely.
E.g., it doesn't show the real or imaginary part of the number if it's `0`

.