Features

High-level

• Developer can focus on important logic, not boiler-plate.
• Let eevo worry about implementation details, optimizations, data representation.
• Avoid premature optimization.

Functional programming

• All you need is data, and functions to transform that data.

Interactive

• Read, Evaluate, Print, Loop (REPL).

First Class Types

• Numbers: integers Int, decimals Dec, ratios Ratio.
• Text: strings Str, symbols (identifiers/variables) Sym.
• Booleans: True, Nil.
• Lists, pairs Pair,
  • Code expressions.
• Records: Rec (hash tables/maps),
  • Unordered set of key value pairs.
  • Look up tables, accept key and return corresponding value.
  • Environments (namespaces/modules/capabilities).
• Functions with closures Func,
  • Func for anonymous functions,
  • Prim for external functions written in host language.
• Macros functions which transform code.
• Dependent Types
• Void
• Errors

Functions as the universal type

• Records, arrays, dictionaries, environments, sets, types, strings are all modeled as functions.
• Functions are records with infinite many keys.
• Full unification still a work in progress.

Metaprogramming

• Homoiconic syntax allows for powerful and simple macro system.
• Abstract away boiler-plate, cost free.
• Customize syntax to extend language with new features to fit your needs.
• Shape the language to meet your problem, not the other way around.

Quoted expressions

• Quote code expressions to avoid (or delay) evaluation.
• Manipulate code like data.
• Quasiquote enables selective unquoting of the code to evaluate parts.

Literate Programming

• Write documentation directly inside an eevo script and convert it to Markdown.
• Keep documentation local to ensure it stays up to date.

Tail call optimization

• Recursive loops become computationally equivalent to imperative loops.

Dyslexic friendly

• Primarily designed by someone with dyslexia, who wrote the language, standard library, and documentation to be as easy as possible to read.

See the language manual for complete set of features.

Anti-Features

Just like jazz, what is missing is often more insightful:

No mutations

• Model change only one way: function calls.
• Ensures code is easy to reason about locally.
• Mutations make programs difficult to predict and harder to read, increasing the mental load of every line of code.
  • Given the same code and data you always get the same result.
• Prevents the mistakes that come from half constructed values.
• Leave mutations as an optimization performed by the compiler.
  • Allows for other easy optimizations such as automatic parallelization.
• Removes circular references, making automatic reference counting easy.

No dependencies (eg LLVM)

• Dependencies are just someone else’s code, which silently increase the surface error of potential bugs.
• Only relies on a C compiler and libc.

No statements

• Everything is an expression: 5, "hello", def, if, etc.

No keywords

• All symbols enjoy equal status and allows redefining them at will.
• Modify the core language just like any users’ code.

No reader macros

• Limit the amount of the language that authors can modify.
• Ensures all scripts remain easy to read once you learn eevo.

No exceptions

• Errors are just regular values which have to be explicitly handled.

No multiple return values

• Just return a list, and require callee to explicitly expand into multiple values.

No explicit return

• Last item of procedure is always returned.
• Use Void to explicitly avoid returning last value.

No arrays, linked lists, or tuples

• Just pairs (2-tuples) and records.
• Construct lists, trees, or any other compound data structure out of pairs.

No function currying

• Partial application should be explicit to avoid hard to debug accidents when you forget an argument.
• Functions only take one argument, but it is often a list of arguments.
• You are welcome to write functions in the curry style, but the standard library is not written that way.

No build systems

• Simply run the primary .evo file (by convention the same name as the project) and let it handle including and running all other files as needed.

No mandatory editor tools

• Syntax should be easy to modify without specialized tools.

No garbage collector

• Memory managed through a simple bump allocator, with reference counting in the works.