# diegoeche/nano

Small proof of concept programming language with permisive operators
Switch branches/tags
Nothing to show
Fetching latest commitâ€¦
Cannot retrieve the latest commit at this time.
 Failed to load latest commit information. #Tests.hs# AlgorithmW.hs Analyser.hs Environment.hs Evaluator.hs Interpreter.hs LambdaCalculus.hs Main.hs Makefile Parser.hs README.md Tests.hs TypeChecker.hs

# An ambiguous language called Nano

nano it's a simple (trust me) language that proposes a new way to create extensibility through what I call "permisive operators". A permisive operator can be built using arbitrary characters and can be applied without leaving whitespace.

## Building Matematical Notation

nano has few built-in operations based on lambda-calculus. All these use normal prefix notation. The following declarations declare the + and - operators with appropiate precedences.

let infixr 1 x + y = add x y
let infixr 2 x - y = sub x y

By default operators are use prefix notations. There aren't negative lexicals in nano. Nano is powerful enough, that we can just define a "-" unary operator for writing negative lexicals.

let 10 - x = sub 0 x

Nano is so simplistic that it doesn't even define expressions or grouping. You can define them yourself by using closed operators.

let closed ( x ) = x

All you need is recursion :)

let rec suffix n ! = if (n==0) 1 (n * (n-1)!)

There's no even list sugar syntax, but you can create it!

let infixr 2 x : y = cons x y
let [] = empty
let rec infixr l [ idx = if (idx == 0) (hd l) ((rest l)[(idx -1))
let suffix x ] = x
let 10 [ x = x
let infixr x , y = x : y
let suffix x ] = x : empty
let rec infixr x ... y = if (x > y)
empty
(cons x ((x+1)...y))
let infixl 4 x ? y = if x (cons y empty) (empty)
let infixl 4 x : y = if (isNull x) y (hd x)

Since application doesn't require whitespace, is possible to have real hungarian notation.

let infixl x default y = if (isNull (fst x)) y (hd (fst x))
let s x = if x "true" "false"
let i x = if x 1 0

And closing operators can be used to have a mini-xml language

let infixr x ; y = buildPair x y
let closed <html> x </html> = buildPair "html" x