Lasca Language

Lasca is Scala shifted towards Haskell.

Lasca is a LLVM-based statically or dynamically typed strict functional programming language. Simplified OCaml if you will.

It has a 'dynamic' compilation mode, meaning instant code generation without compile time type checking/inference, allowing instant compilation/execution cycle, and more freedom dynamic languages give.

It has a full type inference, parametric polymorphism, GC, algebraic data types, pattern matching, and type classes are coming soon.

Imagine

• Scala with fast compilation/start time, optional dynamic typing, and without null
• Go with ADTs, global type inference, and parametric polymorphism
• Haskell with decent records syntax, runtime polymorphism, and string interpolation
• OCaml with typeclasses, overloaded +-*/ for ints and floats, and do-notation
• Rust with garbage collector without <::>!?
• Erlang with types and fast execution
• Python with multithreading, pattern matching, and multiline lambdas
• TypeScript with indentation significant syntax, and LLVM
• Julia with static type checking, and zero-based indexing

Inspired by:

• Scala
• Haskell, Liquid Haskell, Linear Haskell, Idris
• OCaml/SML/F#/1ML
• Clojure (persisted data structures, HAMT/CHAMP)
• Go (CSP)
• Erlang (actors, immutability, minimalism)
• Python (docstrings, doctests, syntax)
• Julia
• Swift
• Nim
• Pony
• Koka (algebraic effects)

Ideas

• light, non-symbol-polluted syntax (Python)
• indentation-based
• readability first
• fast development cycle
• presentation compiler for IDE integration
• IDE-friendly (intellisence 'dot-autocomplete', auto-formatting, compiler API)
• type-safe
• strict functional
• expression-based
• practical first, but as clean and concise as possible
• prefer things done one way
• LLVM backend
• JavaScript/WebAssembly backend (native or via LLVM/emscripten)
• GraalVM backend?
• no OOP and data subclassing/inheritance?
• syntactic sugar is ok
• no null
• annotations (Java/Python-style)
• annotation-based extensions
• macros based metaprogramming (like Scala Macros, Template Haskell)
• Concurrency Oriented Programming (Erlang). Objects are out. Concurrency is in.
• Gradual Typing
• Deferred Type Errors (runtime compilation mode, Haskell)
• Linear/affine types (Rust, Linear Haskell)?
• Liquid Type system (refinement types, Leon, Liquid Haskell) and Z3/CVC4 as proof assistant.
• Algebraic Subtyping for module system
• import features (Scala-like)
• compile-time and runtime reflection
• save/distribute AST (Scala TASTY). Full program optimization/reflection
• important things must be greppable and googlable, call it searchability :)
• compiler as a service: Language Server Protocol
• markdown/rst comments/docs, doctest (Julia, Python)
• CPS/Actors/π-calculus/STM?, non-blocking IO, reactive

Example

Current implementation uses braces and semicolons, but I consider adding indentation-based syntax, or semicolon inference.

-- Algebraic data type a la Haskell
data JValue
    = JNull
    | JNum(n: Float)
    | JString(s: String)
    | JBool(v: Bool)
    | JArray(v: [JValue])
    | JObject(v: Map String JValue)

-- function argument type annotations are optional, compiler infers those
def jsonToString(js: JValue) = match js {
    JObject(m) ->
        if Map.isEmpty(m) then "{}" else {
            println(toString(m));
            res = Array.makeArray(m.size, "");
            var idx = 0;
            Map.foreachWithKey(m, { k, v ->
                setIndex(res, idx.readVar, "\"${k}\": ${jsonToString(v)}");
                idx := idx.readVar + 1;
            });
            s = String.join(", ", res);
            "{ ${s} }"
        }
    JNull -> "null"
    JNum(n) -> toString(n)
    JBool(v) -> toString(v)
    JString(v) -> "\"${v}\""
    JArray(v) -> {
        values = Array.map(v, jsonToString);
        toString(values);
    }
}

What Works Right Now

• JIT and AOT compilation and execution (via LLVM OrcJIT)
  • lasca -e hello.lasca to execute
  • lasca hello.lasca to create a binary
• type inference
• dynamic typing mode (lasca -e --mode dynamic hello.lasca)
• ADTs, inner functions, out of order function definitions
• pattern matching
• calling external C functions
• string interpolation, UTF8 encoded immutable strings
• builtin types: String, Bool, Int, Byte, Int16, Int32, Float, Array, ByteArray, Var, FileHandle
• implemented List, Option, Either, Map, ArrayBuffer
• regular expressions with PCRE-2
• overloaded + - * / operators

Package System

Consider Nix as package manager

Compiler Modes

• Dynamic Mode, aka Prototype Mode. Syntax is checked. All types are dynamically checked.
• Static Mode. Syntax is checked. Typechecking/inference, faster execution.
• Hardcore Liquid types enabled. (See Liquid Haskell) Proves checked. Array bounds checks eliminated.

Type System

• Hindley-Milner by default, dependent types if needed
• traits, kind of type classes
• Liquid types as in Liquid Haskell

Memory Management

GC, concurrent mark and sweep per actor/green thread GC Consider MultiCore Ocaml GC

for now, use Boehm conservative GC

Other

• indentation significant (i.e. Python, Haskell)
• uppercase Typenames, lowercase idents and type arguments (Haskell/Scala style)
• pattern-matching
• ADT, traits, type classes
• easy C interoperability
• no exceptions (Go/Rust panic style errors)
• don't overuse `'~!@#$%^&* symbols
• default immutability
• string interpolation: "${ident} = ${expression}"
• multiline strings
• Uniform Function Call Syntax (Rust, D). For example, any function can be a method for its first argument:

    def toString(s: String) = ...
    "Hello".toString
    def plus(l: Num, r: Num)
    1.plus(2)

• uniform select principle. Use (.) for record field selection, func calls, package name resolution etc
• UTF-8 strings
• Haskell-like application for type functions: Option Int, Either Int String, etc

Install on Mac OS using Homebrew

brew install boehmgc pcre2
brew install nau/lasca/lasca-compiler

Setup LASCAPATH environment variable. Add this to your .bash_profile

export LASCAPATH="$(brew --prefix lasca-compiler)/src"

Try it!

echo 'def main() = println("Hello Lasca!")' > hello.lasca
lasca -e hello.lasca
> Hello Lasca!

Add bash completion config for lasca compiler options:

lasca --bash-completion-script lasca > $(brew --prefix)/etc/bash_completion.d/lasca

Build on Mac OS

You need LLVM 6.0 installed, and latest Haskell Stack.

brew install cmake boehmgc pcre2

brew install llvm-hs/llvm/llvm-6.0 # this compiles llvm from sources, make take some time

brew install haskell-stack

stack setup

Setup LASCAPATH environment variable. Add this to your .bash_profile

export LASCAPATH="${lasca-compiler-src-dir}/libs/base"

Add your ~/.local/bin directory to your PATH

export PATH=$PATH:~/.local/bin

Build and install lasca compiler

make install

Add bash completion config for lasca compiler options:

lasca --bash-completion-script lasca > $(brew --prefix)/etc/bash_completion.d/lasca

Run hello.lasca

lasca --exec examples/hello.lasca

Build on Ubuntu

Requirements: Haskell Stack > 1.6, Cabal > 2.0, LLVM 6, CMake

Don't install Haskell Stack from apt. It's likely to be older than 1.6 and won't be able to upgrade

Do this instead:

curl -sSL https://get.haskellstack.org/ | sh

sudo apt install llvm-6.0-dev libgc-dev zlib1g-dev cmake
sudo add-apt-repository universe
sudo apt install libpcre2-dev
export LASCAPATH="${lasca-compiler-src-dir}/libs/base"
export PATH=$PATH:~/.local/bin
stack setup
make install
lasca -e examples/hello.lasca

Current n-body run

There are several implementation of n-body problem Currently it's quite slow due to boxing.

$ time lasca -e -O2 examples/nbody.lasca -- 50000000
-0.169075164
-0.169059907

real      7m13.261s
user      7m39.476s
sys       0m38.716s

find src -name "*.hs"  | xargs cat | wc -l
4738

cat rts/runtime.c rts/builtin.c rts/lasca.h | wc -l
1324