hascal-1.3: A minimal, extensible and precise calculator

Safe HaskellSafe-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:

>>> hascal 1+2
>>> 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.:

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

>>> 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:

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

That's why this might not work:

>>> hascal 1 * 2
Error. :(

But you could do this instead:

>>> hascal 1*2

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



Just re-exporting the Complex data-type for simplicity and comfort.

data Complex a

Complex numbers are an algebraic type.

For a complex number z, abs z is a number with the magnitude of z, but oriented in the positive real direction, whereas signum z has the phase of z, but unit magnitude.


Typeable1 Complex 
Eq a => Eq (Complex a) 
RealFloat a => Floating (Complex a) 
RealFloat a => Fractional (Complex a) 
Data a => Data (Complex a) 
RealFloat a => Num (Complex a) 
Read a => Read (Complex a) 
Show a => Show (Complex a) 



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)




:: (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.

hascal :: (Read t, RealFloat t) => String -> Maybe (Complex t)Source

hascal is the default evaluator:

 hascal = eval operators

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.