Intended features

Object-oriented programming

• The classic. Classes. Encapsulation. Vertical inheritance.
• Nesting. Nested classes, nested definitions. 
• Everything is an object. Classes included. 
• Prototypes. Singleton classes. Not-so-singleton classes that can become prototypes. 
• Parameterized types. Infix types. Existential types. Covariance, contravariance, invariance. 
• Invariants. Contracts. 
• Traits/mixins, protocols, abstract classes. Horizontal inheritance. Multiple inheritance. 
• Accessibility/visibility scopes. Private, protected, public, object-private, module-protected. The usual and the less usual. 
• Open classes. Sealed classes. 
• Constructors. Constructors, where the name finally really does not matter. There is no name. Primary constructors. Auxiliary constructors. Designated constructors. Convenience constructors. 
• Immutability. Mutability. Frozen objects. Immutable instance variables. Class instance variables. 
• Single dispatch. Multiple dispatch. Multi-methods. Dynamic value dispatch. 

Functional programming

• Everything is a value. Yes, functions are values too. 
• Lambda expressions. Closures. Pattern matching. Method values. 
• Referential transparency. Tail-call optimizations. 
• Call-with-current-continuation. Delimited continuations. Full-scale continuations. Saguro stacks. 
• Compile-time and runtime meta-programming. Quasi-quotation. Fundep materialization. 
• Probably a lot of buzzwords connected with this. 

Type system

• Static typing. Dynamic type for multiple dispatch etc. 
• Types are values, too. 
• Dependent types. Works best with immutable and frozen objects. 
• Union types. 
• Compound types. Constrained types. 
• Existential types. 
• Function types. Partial function types. Curried function types. 

Runtime

• Dynamic runtime with optimizations available via static typing and more. 
• Hot-swap code upgrades, per module unit. 
• Language-agnostic. 
• Interpreting or just-in-time compiling AST instead of low-level bytecode. 
• Interface for native function implementations. 

(to be continued…)