# milly

milly is an hobby, and should not be taken seriously.

Interpreter for a Minimal ML-like language whose ideal goal is to be used for bootstrapping compilers and interpreters.

## How to build

milly's interpreter is written in portable ISO C11, sources are in `src/` and header files are in `include/`.

In order to build it, you must have **GNU Make** installed (in the future i'll try to remove this dependency)
and you just have to run:

> $  make

in the project root to obtain the executable `milly`.

## The language

milly is a minimal dialect of Standard ML and Haskell,
here is a list of the features (or better, limitations) I want to introduce:

- Keep the implementation <5000 LOC
- Eager evaluation (call by value)
- Algebraic Datatypes (pretty useful for representing syntax trees)
- First class functions
- Pattern patching (pretty useful for analyzing syntax trees)
- Integers, booleans, strings
- Mutable `ref` cell
- FFI to C
- Polymorphic types à la Hindley Milner (probably unfeasible)
- Automatic currying of functions, with optimised partial evaluation (unfeasible)
- Delimited continuations (this is an overkill)
- Easy syntax allowing easy kakoune support
- A formal specification (this should be quite manageable to do, and also a good way to learn denotational semantics)

milly's full grammar is specified as a pair of lex and yacc files in `ref_parser/`.

kakoune plugin for milly is in `extra/milly.kak`.

Here is a small example of the syntax:

```
# Helpers
datatype 'a list {
  Cons of ('a, 'a list),
  Empty
}

datatype 'a maybe {
  Just of 'a,
  Nothing
}

# Lambda calculus term, nameless representation
datatype term {
  Var of int,
  Int of int,
  Abs of term,
  App of (term, term)
}

# Result of the evaluation
datatype value {
  Int     of int,
  Closure of (env, term)
}

alias env = value list

typecheck add_binding : value -> env -> env
def add_binding v env = Cons v env

typecheck lookup : int -> env -> value maybe
def lookup _ <Empty> = Nothing
  | lookup 0 <Cons x xs> = Just x
  | lookup n <Cons x xs> = lookup (subtract n 1) xs

typecheck eval : env -> term -> value
def eval e <Var idx> = 
        match lookup idx e {
          case <Just v>   -> v
          case <Nothing>  -> abort "Variable out of scope"
        }

  | eval e <Int x> = Int x
  | eval e <Abs t> = Closure e t
  | eval e <App t1 t2> =
      let def new_env = add_binding (eval e t2) e
      in eval new_env t1
```