dhansmair/nomad

calculator application written in Haskell

Nomad

A CLI calculator application written in Haskell. This project is a continued version of https://github.com/dhansmair/nomad-calculator (university project). It's a learning project that explores functional programming in Haskell, but also other topics such as parsing, the lambda calculus and basic type inference.

Features of nomad:

• evaluate common arithmetic expressions
• Definition of variables and (mathematical) functions
• Partial function application
• higher-order functions
• Builtin functions such as sin, cos, tan, log, exp etc.
• Builtin derive, which returns the derivative of a function of type num -> num.

Features that would be nice (but will probably not come):

• automatic simplification of terms and functions
• boolean type
• loading / executing code from file
• useful type error messages

Setup

stack build                 // builds all executables
stack run cli               // runs cli executable

Syntax

x = expr                    // define global variable
f(x,y) = expr               // define function
f = \x,y -> expr            // equivalently, functions can be defined as abstractions
expr                        // evaluate expressions
(\x -> 2*x)(4)              // lambda application
f(1,2)                      // function application

expressions can be:

1                           // any number
x                           // a variable
1 + 2 / 3 etc               // binary operations
f(x)                        // function call
(\x,y->x*y)(5,3)            // application of an abstraction

Commands

:q                  close the cli
:t <expr>           show the type of an expression
:env                show the current environment (stored functions and variables)

nomad's Issues

command to load a file ":l path"

do not print brackets when not necessary

only necessary when an addition is a child of a multiplication, etc

useful error messages

rename My* to Nomad*

command line arguments

like e.g. interpret a file

remove EnvT, just use a parameter typeAssumptions

nomad/src/Typesystem/TypeCheck.hs

Line 74 in 33f5471

getType :: (Monad m) => Expr -> NomadExceptT (EnvT m) Type

this would benefit the modularity of the code.

try-rule monad

find concept for a monad in which it is possible to try out application of rules, and apply them if possible.
If not, the state should somehow express that the current tree hasn't been modified yet.

If no more modification is possible, the function should return the final result.

throw error when duplicate names occur

implement class Read for Expr and Stmt

can directly use the parse method

printing of applications is sometimes wrong / misleading

an example:

> f(x) = 2 ln(x)
f = \x -> 2.0 * ln(x)	:: num -> num
> derive(f)
\x -> 2.0 * derive(ln, x)	:: num -> num
> 

Extend grammar to multiple statements separated with ;

prettyprint partially applied builtins

correct brackets in type signature

implement MonadError and MonadWriter for FrischT

use NomadExceptT or Either NomadError in deriveBy (Derivation.hs)

refactor commands, add a more generic way like a lookup

make statements also expressions ?