Lyng: modern scripting for kotlin multiplatform

A KMP library and a standalone interpreter

• simple, compact, intuitive and elegant modern code style:

class Point(x,y) {
   fun dist() { sqrt(x*x + y*y) } 
}
Point(3,4).dist() //< 5

fun swapEnds(first, args..., last, f) {
    f( last, ...args, first)
} 

• extremely simple Kotlin integration on any platform
• 100% secure: no access to any API you didn't explicitly provide
• 100% coroutines! Every function/script is a coroutine, it does not block the thread, no async/await/suspend keyword garbage:

    delay(1.5) // coroutine is delayed for 1.5s, thread is not blocked!

and it is multithreaded on platforms supporting it (automatically, no code changes required, just launch more coroutines and they will be executed concurrently if possible)/

• functional style and OOP together, multiple inheritance, implementing interfaces for existing classes, writing extensions.
• Any unicode letters can be used as identifiers: assert( sin(π/2) == 1 ).

Resources:

• introduction and tutorial - start here please
• Samples directory

Integration in Kotlin multiplatform

Add dependency to your project

// update to current please:
val lyngVersion = "0.6.1-SNAPSHOT"

repositories {
    // ...
    maven("https://gitea.sergeych.net/api/packages/SergeychWorks/maven")
}

And add dependency to the proper place in your project, it could look like:

comminMain by getting {
    dependencies {
        // ...
        implementation("net.sergeych:lynglib:$lyngVersion")
    }
}

Now you can import lyng and use it:

Execute script:

import net.sergeyh.lyng.*

// we need a coroutine to start, as Lyng
// is a coroutine based language, async topdown
runBlocking {
    assert(5 == eval(""" 3*3 - 4 """).toInt())
    eval(""" println("Hello, Lyng!") """)
}

Exchanging information

Script is executed over some Context. Create instance of the context, add your specific vars and functions to it, an call over it:

import new.sergeych.lyng.* 

// simple function
val context = Context().apply {
    addFn("addArgs") {
        var sum = 0.0
        for( a in args) sum += a.toDouble()
        ObjReal(sum)
    }
    addConst("LIGHT_SPEED", ObjReal(299_792_458.0))
    
    // callback back to kotlin to some suspend fn, for example::
    // suspend fun doSomeWork(text: String): Int
    addFn("doSomeWork") {
        // this _is_ a suspend lambda, we can call suspend function,
        // and it won't consume the thread:
        doSomeWork(args[0].toString()).toObj()
    }
}
// adding constant:
context.eval("addArgs(1,2,3)") // <- 6

Note that the context stores all changes in it so you can make calls on a single context to preserve state between calls.

Why?

Designed to add scripting to kotlin multiplatform application in easy and efficient way. This is attempt to achieve what Lua is for C/++.

• fast start (times and times faster than initializing v8/wasm)
• fast and simple kotlin interoperability
• coroutine-based, truly async. On platforms with multithreading, run multithreaded. No python/ruby/javascript threads hell.
• small footprint
• absolutely safe: no access to any dangerous or sensitive functions until you specifically provide it.

Language

• Javascript, WasmJS, native, JVM, android - batteries included.
• dynamic types in most elegant and concise way
• async, 100% coroutines, supports multiple cores where platofrm supports thread
• good for functional an object-oriented style

Language Roadmap

v1.0.0

Planned autumn 2025. Complete dynamic language with sufficient standard library:

Ready features:

• Language platform and independent command-line launcher
• Integral types and user classes, variables and constants, functions
• lambdas and closures, coroutines for all callables
• while-else, do-while-else, for-else loops with break-continue returning values and labels support
• ranges, lists, strings, interfaces: Iterable, Iterator, Collection, Array
• when(value), if-then-else
• exception handling: throw, try-catch-finally, exception classes.
• multiplatform maven publication
• documentation for the current state

Under way:

• maps, sets and sequences (flows?)
• regular exceptions
• modules
• string interpolation and more string tools
• multiple inheritance for user classes
• launch, deferred, coroutineScope, mutex, etc.
• site with integrated interpreter to give a try
• kotlin part public API good docs, integration focused
• better stack reporting

v1.1+

Planned features.

• type specifications
• source docs and maybe lyng.md to a standard
• moacro-style kotlin integration or something else to simplify it

Further

• client with GUI support based on compose multiplatform somehow
• notebook - style workbooks with graphs, formulaes, etc.
• language server or compose-based lyng-aware editor