hascal-3.0.1: tiny calculator library and command-line program

Safe HaskellNone
LanguageHaskell98

Hascal

Description

Hascal is a simple, minimalistic, tiny calculator library and program.

  • Hascal only understands single-character operators.
  • Hascal only understands infix operators.
  • Hascal does not understand parantheses.
  • _ is hard-coded as single prefix for negating numbers.
  • By default, Hascal understands the operators +, -, *, /, ^, and ? (logarithm).
  • By default, Hascal understands the constants pi, e, and i.
  • Using Hascal as a library, you can add new operators and new constants using a configuration data type.

The hascal executable program is easy to use. In a shell, type:

>>> hascal 1+2-3*4/5^6?7
-1.7263530417152033

Given a configuration, the hascal function similarly evaluates an expression of type String. In a Haskell interpreter like GHCI, type:

>>> hascal def "1+2-3*4/5^6?7"
Right (0.2736469582847967 :+ 0.0)
>>> hascal def "1++2"
Left "Error at \"\"."

Synopsis

Documentation

data Config t Source #

A configuration. def is the default configuration.

Constructors

Config 

Fields

  • operators :: [Operator t]

    A list of operators. The order in this list also determines the order of evaluation.

  • constants :: [Constant t]

    A list of constants.

Instances

(Read t, RealFloat t) => Default (Config t) Source # 

Methods

def :: Config t #

class Default a where #

A class for types with a default value.

Methods

def :: a #

The default value for this type.

Instances

Default Double 

Methods

def :: Double #

Default Float 

Methods

def :: Float #

Default Int 

Methods

def :: Int #

Default Int8 

Methods

def :: Int8 #

Default Int16 

Methods

def :: Int16 #

Default Int32 

Methods

def :: Int32 #

Default Int64 

Methods

def :: Int64 #

Default Integer 

Methods

def :: Integer #

Default Ordering 

Methods

def :: Ordering #

Default Word 

Methods

def :: Word #

Default Word8 

Methods

def :: Word8 #

Default Word16 

Methods

def :: Word16 #

Default Word32 

Methods

def :: Word32 #

Default Word64 

Methods

def :: Word64 #

Default () 

Methods

def :: () #

Default CShort 

Methods

def :: CShort #

Default CUShort 

Methods

def :: CUShort #

Default CInt 

Methods

def :: CInt #

Default CUInt 

Methods

def :: CUInt #

Default CLong 

Methods

def :: CLong #

Default CULong 

Methods

def :: CULong #

Default CLLong 

Methods

def :: CLLong #

Default CULLong 

Methods

def :: CULLong #

Default CFloat 

Methods

def :: CFloat #

Default CDouble 

Methods

def :: CDouble #

Default CPtrdiff 

Methods

def :: CPtrdiff #

Default CSize 

Methods

def :: CSize #

Default CSigAtomic 

Methods

def :: CSigAtomic #

Default CClock 

Methods

def :: CClock #

Default CTime 

Methods

def :: CTime #

Default CUSeconds 

Methods

def :: CUSeconds #

Default CSUSeconds 

Methods

def :: CSUSeconds #

Default CIntPtr 

Methods

def :: CIntPtr #

Default CUIntPtr 

Methods

def :: CUIntPtr #

Default CIntMax 

Methods

def :: CIntMax #

Default CUIntMax 

Methods

def :: CUIntMax #

Default All 

Methods

def :: All #

Default Any 

Methods

def :: Any #

Default [a] 

Methods

def :: [a] #

Default (Maybe a) 

Methods

def :: Maybe a #

Integral a => Default (Ratio a) 

Methods

def :: Ratio a #

Default a => Default (IO a) 

Methods

def :: IO a #

(Default a, RealFloat a) => Default (Complex a) 

Methods

def :: Complex a #

Default a => Default (Dual a) 

Methods

def :: Dual a #

Default (Endo a) 

Methods

def :: Endo a #

Num a => Default (Sum a) 

Methods

def :: Sum a #

Num a => Default (Product a) 

Methods

def :: Product a #

Default (First a) 

Methods

def :: First a #

Default (Last a) 

Methods

def :: Last a #

(Read t, RealFloat t) => Default (Config t) # 

Methods

def :: Config t #

Default r => Default (e -> r) 

Methods

def :: e -> r #

(Default a, Default b) => Default (a, b) 

Methods

def :: (a, b) #

(Default a, Default b, Default c) => Default (a, b, c) 

Methods

def :: (a, b, c) #

(Default a, Default b, Default c, Default d) => Default (a, b, c, d) 

Methods

def :: (a, b, c, d) #

(Default a, Default b, Default c, Default d, Default e) => Default (a, b, c, d, e) 

Methods

def :: (a, b, c, d, e) #

(Default a, Default b, Default c, Default d, Default e, Default f) => Default (a, b, c, d, e, f) 

Methods

def :: (a, b, c, d, e, f) #

(Default a, Default b, Default c, Default d, Default e, Default f, Default g) => Default (a, b, c, d, e, f, g) 

Methods

def :: (a, b, c, d, e, f, g) #

hascal :: (Read t, RealFloat t) => Config t -> String -> Result t Source #

Given a configuration and a String-expression, returns Either a String containing an error message; or a Complex number.

showHascal :: (Show t, Read t, RealFloat t) => Config t -> String -> String Source #

Given a configuration and a String-expression, returns a String containing the error message or the resulting complex number.

showNumber :: (Show t, RealFloat t) => Complex t -> String Source #

Show a Complex number a little bit more human-readable by matching both the real and the imaginery part against zero and one.