The Concurnas Programming Language

actor MyActor{//lets define an actor
  -count = 0
  def increment(){
    count++
  }
}

//Use of the above actor:
ma = new MyActor()

ma.increment()//just like normal method call, will block until execution is complete

sync{//sync - wait for all isolates created in the block to complete
  {ma.increment()}!//called concurrently
  {ma.increment()}!
}

count = ma.getCount()
//count == 3, not possible with regular objects!

class MyCounter(-count int){//ordinary class
  def increment(){
    count++
  }
}

//We can now define and use our typed actor through the aid of the of keyword as follows:
actor MyActor of MyCounter(0)


//let's use our new typed actor:
ma = new MyActor()

ma.increment()

sync{//sync - wait for all isolates created in the block to complete
  ma.increment()!
  ma.increment()!
}

count = ma.count//count == 3

class MyCounter(-count int){
  def increment(){
    count++
  }
}

inst1 = actor MyCounter(0)      //create a new actor on MyCounter
inst2 = new actor MyCounter(0)  //create a new actor on MyCounter

//a simple kernel for performing matrix multiplication...
gpukernel 2 matMult(M int, K int, 
      global in A float[2], global in B float[2], global out resultMat float[2]) {
  globalRow = get_global_id(0) 
  globalCol = get_global_id(1) 
  acc = 0.0f;
  for (k=0; k<K; k++) {
    acc += A[k*M + globalRow] * B[globalCol*K + k]
  }
  resultMat[globalCol*M + globalRow] = acc;
} 

//create an array buffer on a GPU device
ar gpus.GPUBufferInput = device.makeOffHeapArrayMixed<int[]>(int[].class, 10)
//copy data from the heap into the buffer...
copyComplete boolean:gps.GPURef = ar.writeToBuffer([1 2 3 4 5 6 7 8 9 10])
//perform other computation, possibly on the GPU, whilst we wait for the copy to complete...
await(copyComplete)

//an input only buffer
ar gpus.GPUBufferInput = device.makeOffHeapArrayIn<int[]>(int[].class, 10)
//a 2 by 4 output matrix
mat gpus.GPUBufferOutput = device.makeOffHeapArrayOut<int[2]>(int[2].class, 2, 4)

//defining raw C99 compliant OpenCL C code:
@GPUStubFunction(source="float plus1(float a, float b){ return a + b;}")
gpudef plus1(a float, b float) float

//using existing C99 compliant OpenCL C code:
@GPUStubFunction(sources=['./cpucode.cl', './gpuutilCode.cl'])
gpudef plus2(a float, b float) float

//a matrix multiplication algorithm leveraging GPU local memory
gpukernel 2 matMultLocal(M int, N int, K int, 
    constant A float[2], constant B float[2], global out result float[2]) {
  row = get_local_id(0)
  col = get_local_id(1)
  globalRow = CacheSize*get_group_id(0) + row //row of result (0..M)
  globalCol = CacheSize*get_group_id(1) + col //col of result (0..N)
	
  //local memory holding cache of CacheSize*CacheSize elements from A and B
  local cacheA = float[CacheSize, CacheSize]
  local cacheb = float[CacheSize, CacheSize]
	
  acc = 0.0f
	
  //loop over all tiles
  cacheSize int = K/CacheSize
  for (t=0; t<cacheSize; t++) {
    //cache a section of A and B from global memory
    //into local memory tiledRow = CacheSize*t + row
    tiledCol = CacheSize*t + col
    cacheA[col][row] = A[tiledCol*M + globalRow]
    cacheb[col][row] = B[globalCol*K + tiledRow]
		
    barrier(true)//ensure all work items finished caching
		
    for (k=0; k<CacheSize; k++) {//accumulate result for matrix subsections
      acc += cacheA[k][row] * cacheb[col][k]
    }
		
    barrier(true)//ensure all work items finished before moving on to next cache section
  }
  
  result[globalCol*M + globalRow] = acc
}

c1 := inGPU1.writeToBuffer([ 1 2 3 4 ])
copyduration = c1.getProfilingInfo().getWorkDuration()
summary = c1.getProfilingInfo().toString()				  		

//A remote server:
remServer = new com.concurnas.lang.dist.RemoteServer(port = 42001)
remServer.startServer()
//wait until time to terminate
remServer.close()

//A client:
rm = Remote('localhost', port = 42001)
//execute code remotely, returning a ref:
ans int: = {10+10}!(rm.onfailRetry())
rm.close()
//ans == 20

//A remote server:
remServer = new com.concurnas.lang.dist.RemoteServer()//use default port 42000
remServer.startServer()
//wait until time to terminate
remServer.close()

class MyCalculator{//dependent code
  -callCounter = 0
  //greatest common divisor of two integers...
  def gcd(x int, y int){//+ counter and result
    while(y){
      (x, y) = (y, x mod y)
    }
    "count: {++callCounter}, result: {x}"
  }
}

//connect and execute remotely
rm = Remote('127.0.0.1')//use default port 42000
result = try{
  calc = MyCalculator()
  calc.gcd(34, 4756)

  //Dependant code (MyCalculator.class) and object state (callCounter) is also transmitted...
  res String: = {calc.gcd(97, 7081)}!(rm.onfailRetry())
  res:get()
}finally{
  rm.close()
}
//result == count: 2, result: 97

from com.concurnas.offheap.storage import OffHeapRAM
from com.concurnas.offheap import OffHeapObject	
msg = ["hello" "world"]//message to store

10meg = 10 * (1024**2)
//our off heap store:
offHeapStore = new OffHeapRAM<String[]>(10meg)
offHeapStore.start()

offHeapObj OffHeapObject<String[]> = offHeapStore.put(msg)//add msg to the store
gotMsg = offHeapObj.get()//extract a copy of the original message
del offHeapObj//remove the object from the store

offHeapStore.close()

assert gotMsg == msg//equal by value
assert gotMsg &<> msg//different by reference	  

from com.concurnas.offheap.storage import OffHeapMapDisk
import java.io.File
msg = ["hello" "world"]
100meg = 100 * (1024**2)
//our off heap store:
offHeapStore = new OffHeapMapDisk<String, String[]>(100meg, new File('msgDatabase.db'))
offHeapStore.start()

offHeapStore.put('msg', msg)//add msg to the store
gotMsg = offHeapStore.get('msg')//extract a copy of the original message
offHeapStore.close()//msg is persisted to disk in 'msgDatabase.db'

assert gotMsg == msg//equal by value
assert gotMsg &<> msg//different by reference			

//Removing a field:
class MyClass(firstName String, sirName String)
//Later version:
class MyClass(firstName String)

//Adding a field:
class MyClass(firstName String)
//Later version:
class MyClass(firstName String, sirName String)

//Changing the type of a field:
class MyClass(firstName String, sirName String, userid byte)
//Later version:
class MyClass(firstName String, sirName String, userid long)

empty = new int[10]//empty array of zeros
ones = new int[10](1)//array of ones

matrix = new int[2, 2]
ndim = new int[2, 2, 2]//a 2 x 2 x 2 3 dimensional array
mones = new int[2, 2](1)//2 x 2 matrix of ones

ar1 = [1 2 3 4 5]//in place array definition
ar2 = ar1 + [ 6 7 8 ]//concatenation: ar2 ==  [1 2 3 4 5 6 7 8]

m1 = [1 2; 3 4]//in place matrix definition

//concatenation:
m2 = m1 + [ 5 6] //m2 == [1 2; 3 4; 5 6]
m3 = [m1 m1]     //m3 == [1 2 1 2 ; 3 4 3 4]

//extracting values
arraGot = ones[1]//getting the second value from an array
got = m2[0,1]//got == 2
got2 = m2[;,1]//taking a slice from a matrix: got2 == [2 4 6]

//lists
alist = [1, 2, 3, 4, 5, 6, 7, 8, 10]//a list of Integers
objList = ['element', 2, 3.4]//a mixed list of Objects

//operations on lists...
element = alist[0]//get the first item
del alist[0]//remove first item
check = 3 in alist//check to see if a value is in a list
sublist = alist[4 ... 8]//sublist
sublists = alist[4 ... ], alist[ ... 4]//sublist from index 4 to end, and from start to 4

if(alist){//checking for non emptyness
  System.out.println('list is not null or empty!')
}

for(item in alist; idx){//iteration
  System.out.println('item:{idx}={item}')
}

//maps
amap = {12 -> 'twelve', 1 -> 'one'}
defaultmap = {6 -> 20, default -> 0}
got = amap[12]//get an item
got2 = defaultmap[16]//an entry from 16 -> 0 will be created by default
del amap[12]//remove an item
amap[99] ='big'//create a mapping
check = 99 in amap//check for presence of key
check = 23 not in amap//check for absence of key

if(amap){//checking for non emptyness
  System.out.println('map is not null or empty!')
}

for(key in amap; idx){//iteration over map keys
  System.out.println('item:{key}={amap[key]}')
}

//sets
aset = set()
aset.add('item')
aset.add('toremove')
check = 'item' in aset

if(aset){//checking for non emptyness
	System.out.println('set is not null or empty!')
}

for(item in aset){//iteration
	System.out.println('item:{item}')
}

//ranges
numRange = 0 to 10           //a range of: [0, ..., 10]
tepRange = 0 to 10 step 2    //a range of: [0, 2, ..., 10]
revRange = tepRange reversed //a reversed range of: [10, 8, ..., 0]
decRange = 10 to 0 step 2    //a range of: [10, 8, ..., 0]
infRange = 0 to              //an infinite sequence [0,... ]
steInfRa = 0 to step 2       //a stepped infinite sequence [0, 2,... ]
decInfRa = 0 to step -1      //a stepped infinitely decreasing sequence [0, -1,... ]

check = 2 in numRange //checking for presence
for(x in 0 to 10){
  System.out.println('sequence item:{x}')
}

//implied type lists
mylist = list()//mylist is implied to be a String list based on usage
mylist.add('element')

//implied type map
mymap = map()//implied to be a map of Integer to String
mymap[1] = 'value'

//implied type set
aset = set()//implied to be a set of Integers
aset.add(123)

mylist = [1, 2, 5, 4, 3, 2]

plusone = x+1 for x in mylist//list comprehension of a list
plusoneEven = x+1 for x in mylist if x mod 2 == 0 //only even numbers!

myeq = (x**2+1) for x in 0 to 10//list comprehension of a range

mymap = {0 -> 93, 1-> 55, 4 -> 34}
lckeys = (key, mymap[keyfor]) for key in sorted(mymap)
//iterate over our sorted map keys and produce a list of tuples 

myArray1 = [1 2 3 4 5 6 7 8 9 10]
myArray2 = [1 2 3 4 5 6 7 8 9 10]

plus10 = myArray1^ + 10//create new array with 10 added to each element of myArray1
myArray2^ += 10//add 10 to each element of the array in place

assortment = ['aString' Integer(1) Float(22) 'anotherString']
whichStr = assortment^ is String //type checking. whichStr == [true false false true]

mymatrix = [1 2; 3 4]
mymatrix^ **=2//mymatrix now == [1 4 ; 9 16]

 class Inca(public value int){
  def inc() => value++;;
  override toString() => 'Inca({value})'
}

incs = [Inca(3) Inca(4) Inca(22)]
incs^inc()//call inc on each element, incs now == [Inca(4) Inca(5) Inca(23)]
values = incs^value//extract values from each object, values == [4 5 23]

from java.lang.Math import sin, toRadians
mymat = [ 80 170; 260 350]
sins = sin(toRadians((mymat^ + 10) mod 360))

myArray1 = [1 2 3 4 5 6 7 8 9 10]
myArray2 = myArray1 + 10//no ^ needed!

from java.lang.Math import sin, toRadians
mymat = [ 80 170; 260 350]
sins = sin(toRadians((mymat + 10) mod 360))//no ^ needed!

open class Person(~name String, ~surname String){
  //Concurnas automatically creates a this(name String, surname String) constructor
  likes = java.util.HashSet<Food>()//field defaults to be accessible from within class only
  def addLike(like Food) boolean => likes.add(like)//a public method
}//open classes can be extended

//an enumeration, a simple class structure for limited choices
enum Food{Tomatoes, Beans, Bread, Grapes, Pizza}

//an abstract class may define methods which need to be implicated by concrete classes
//abstract classes themselves may not have instance objects created of them
abstract class Validating(~name String, ~surname String) < Person(name, surname){
  def validateLike(like Food) boolean//abstract method to be defined by subclass

  override addLike(like Food) boolean {//methods must be explicitly overridden
    super.addLike(like) if validateLike(like) else false
  }
}

//BornPerson extends Validating, pass relevant details to superclass...
class BornPerson(name String, surname String, ~birthYear short) < Validating(name, surname){
  this(surname String, birthYear short){
    this('unknown', surname, birthYear)//call default constructor
  }

  //those born after 1980 don't like fast food...
  def validateLike(like Food) boolean {
    like <> Food.FastFood if birthYear > 1980 else true
  }
}//this is a closed class which may not be extended

//creating an instance object of a BornPerson...
aperson = BornPerson('dave', 'jones', 1991)//new keyword is optional
aperson.addLike(Food.Beans)

trait Eater{
  def eat() String => "eating {favouriteFood()}" //concrete method
  def favouriteFood() String //abstract method to be implemented by composing class
}

trait Animal < Eater{
  override def eat() String => "animal is " + super.eat()
  def legCount() int//abstract
}

trait FourLegged ~ Animal{
  def legCount() => 4
  def favouriteFood() String
}

//~ indicates we're composting a class of the defined traits...
class Dog ~ Animal, FourLegged {
  def favouriteFood() => "sausages"
}

fido = new Dog()
fido.eat()//eat returns: "animal is eating sausages"

abstract class Operator{
  def operate(a int) int
}

open class ID < Operator{
  def operate(a int) => a
}

trait PlusOne   < Operator{  def operate(a int) => super.operate(a+1) }
trait Square    < Operator{  def operate(a int) => super.operate(a**2) }
trait MinusOne  < Operator{  def operate(a int) => super.operate(a-1) }
trait DivTwo    < Operator{  def operate(a int) => super.operate(a/2) }

//create a class composed of these stacked traits...
class DMSP < ID ~ PlusOne, Square, MinusOne, DivTwo
DMSP().operate(10)//returns: 17

open class Pair<X, Y>(-x X, -y Y)//generic class with two type parameters, X and Y

//instances of our generic class
pp1 = new Pair<String, int>("one", 1)
pp2 = new Pair<String, String>("name", "another")

//a generic function with one type parameter X:
def addTwice<X>(addTo java.util.List<X>, what X){
  addTo.add(what)
  addTo.add(what)
}

//a class with upper bounded generic parameters
class NumericalPair<A Number, B Number>(a A, b B) < Pair<A, B>(a, b)
np1 = new NumericalPair<float, int>(0.3f, 1)//A and B must be subtypes of Number

//We can use the wildcard ? where we are not interested in the generic qualification
ppAny = np1 as NumericalPair<?, ?>

//in/out parameters allow us to support Contravariance and Covariance respectfully
trait Source<out T>{//Contravariant generic parameter
  def nextT() T
}

trait Comparable<in T>{//Covariant generic parameter
  def compareTo(other T) int
}

//pp1 is inferred to be of type: Pair<String, int>
pp1 = new Pair("one", 1)

//filenames is inferred to be of type: java.util.ArrayList<String>
filenames = java.util.ArrayList()
filenames.add("pic1.jpg")

class Person(-name String)//- generate a getter for name only
  ~petName String //generate a getter and setter
  +age int//generate a setter only
}

//redirect field access to getters and setters
p1 = new Person('dave')
p1.petName = "lenin"//equivalent to p1.setPetName("lenin")
petname = p1.petName//equivalent to petname = p1.getPetName()

class Person(name String)
p1 = Person('dave')
p2 = Person('dave')

assert p1 == p2//equivalent to; p1.equals(p2) - p1 and p2 have the same value
assert p1 &<> p2//p1 and p2 are not the same object

people = set()
people.add(p1)
people.add(p2)

assert people.size() == 1//one item stored by value

class MyClass1{
  @Deprecated def myOldMethod(){
      //The Deprecated indicates that the method is deprecated
  }
}

annotation MapsTo{//a custom annotation
  name String
  mapTo String
  repeat = 1//annotation field default value
}

class MyClass2{
  @MapsTo(name = "mappingName", mapTo = "anotherName")
  afield int = 99//afield is annotated with MapsTo
}

class Robot{
  -path = ""
  private def add(dir String) => path +=dir
  def up() 	=> add("U") 
  def down()  => add("D") 
  def left()  => add("L") 
  def right() => add("R") 
}

robot = Robot()
robot..up()..up()..left()..down()..right()//double dot .. returns the Robot object
result = robot.path//UULDR

class Robot{
  -path = ""
  private def add(dir String) => path +=dir
  def up() 	=> add("U") 
  def down()  => add("D") 
  def left()  => add("L") 
  def right() => add("R") 
}


result = with(Robot()){
  up(); up(); left(); down(); right()
  path
}//result == UULDR

trait MessageGetter {public def getMessage() String}
trait MessageSender{public def sendMessage(msg String) void}

inject class MessageProcessor(obtainer MessageGetter, sender MessageSender){
//the default constructor for MessageProcessor is marked as being injectable
  public def processMessage(){
    this.sender.sendMessage(this.obtainer.getMessage())
  }
}

class SimpleMG ~ MessageGetter { 
  def getMessage() String => 'A message'
}
class MessagePrinter ~ MessageSender{
  def sendMessage(msg String) void => System.out.println(msg)
}

provider MPProvider{//
  provide MessageProcessor //provide objects of this type
  MessageGetter => new SimpleMG()//dependency satisfaction for MessageProcessor 
  MessageSender => new MessagePrinter()//dependency satisfaction for MessageProcessor
}

//to be used as follows:
mpProvider = new MPProvider()
mp = mpProvider.MessageProcessor()
//mp is a MessageProcessor instance with all dependencies satisfied

inject class AgeHolder(age Integer)
inject class User(name String, ah AgeHolder)

provider UserProvider{
  single provide User//we mark the provider as single
  String => "freddie"
  AgeHolder => new AgeHolder(22)
}

up = new UserProvider()
inst1 = up.User()
inst2 = up.User()

//both User objects are the same across different calls to UserProvider.User:
assert inst1 &== inst2

class Bean{
  count = 0
  def increment() void => count++ 
}

inject class BeanCounter(-left Bean, -right Bean)

provider CounterProvider{
  provide BeanCounter
  shared Bean => new Bean()//we mark the Bean dependency qualifier as being shared
}

bcProvider = new CounterProvider()
bcInst1 = bcProvider.BeanCounter()
bcInst2 = bcProvider.BeanCounter()

//same bean for both dependencies of the provided object:
assert bcInst1.left &== bcInst1.right
//two beans from two separate invocations of the provider differ:
assert bcInst2.left &<> bcInst1.left

inject class User(firstName String, sirName String)

provider UserProvider{
  provide User
  'firstName' String => "Freddie"
  'sirName' String => "Brown"
}

uprov = new UserProvider()
user = uprov.User()

aVariable String = "a String"
aVariable = null//this is a compile time error!

nullableVar String? = "a String"//nullableVar can hold a null value
nullableVar = null//this is now acceptable

len = nullableVar.length()//compile time error! As nullableVar may be null

nullableVar String? = "a String"//nullableVar can hold a null value
//...
res = if(nullableVar <> null){
  nullableVar.length()//OK as we've already established that nullableVar is not null
}else{
  -1
}

//Safe call operator:
nullableVar String? = null
len = nullableVar?.length()//len is of type Integer?

//Elvis operator
nullableVar String? = null
len int = nullableVar?.length()?:-1//len is of type int

//Not null assertion operator
nullableString String? = null
//throws a NullPointerException if nullableString is null:
length int = nullableString??.length()

class HolderNoNullGeneric<X>(~x X)
class HolderNullGenericOK<X?>(~x X)

nonNull = HolderNoNullGeneric<String>("not null")
nullOK  = HolderNullGenericOK<String?>(null)

π = Math.PI
πStr = "π=" + π //πStr == "π=3.141592653589793"
你好 = "Hello!"

res1 = {a = 12; b= 16
a ** 2 + b}//anonymous block returns a value

//branching if, elif, else blocks may return values
res2 = if(someCondition()){ "value1"} else{"value2"}

//loops return values
fromLoop java.util.List<int> = for(a in 0 to 10){
  a * 2 + 12
}

//a data class in one line...
class MyClass<X>(-x heldValue, public afield String, ~another int)

//an ordinary function:
def addfunc1(a int, b int) int {
  return a + b
}

//we can use => to compact the function to:
def addfunc2(a int, b int) int => return a + b

//infer the return type:
def addfunc3(a int, b int) => return a + b

//implicit return expression:
def addfunc4(a int, b int) => a + b//most compact form!

//an overloaded function
def adder(a int, b int) => a + b
def adder(a int, b float) => adder(a, b as int)
def adder(a int) => adder(a, 10)

//a default value
def powerPlus(a int, raiseTo = 2, c int) => a ** raiseTo + c

//call our function with a default value
res1 = powerPlus(4, 10)//second argument defaults to '2'
res2 = powerPlus(4, 3, 10)//second argument provided

//calling a function with named parameters:
def powerAdder(a int, raiseATo = 2, b int, raiseBTo = 2) => a**raiseATo + b**raiseBTo
res3 = powerAdder(2, 4, raiseATo=3)//equivalent to: powerAdder(2, 3, 4, 2)

//varargs:
def sum(elms int...) int {
  res = 0
  for(elm in elms){
    res += elm
  }
  res
}

//call our function with a vararg
thesum = sum(1, 2, 3, 4, 5)

//fully defined typedef
typedef People = java.util.ArrayList<String>

//partially defined typedef
typedef NameMap<X> = java.util.ArrayList<java.util.HashMap<String, java.util.HashSet<X>>>

//using typedefs...
nm NameMap<String>= new NameMap<String>()
//above is equivalent to:
//nm java.util.ArrayList<java.util.HashMap<String, java.util.HashSet<String>>> = new java.util.ArrayList<java.util.HashMap<String, java.util.HashSet<String>>>()

def returnPair(a int, b int) (int, int) => a*b, a+10

obtained (int, int) = returnPair(10, 13)

r1, r2 = obtained//tuple decomposition, r1 and r2 can be used as ordinary variables

class MyClass(a int, b int, c String){
  override toString() => 'MyClass({a}, {b}, "{c}")'
}

mc1 = MyClass(12, 14, "hi there")
mc2 = mc1@ //copy mc1

assert mc1 == mc2//same values!
assert mc1 &<> mc2//different objects!

mc3 = mc1@(a = 100)//copy mc1 but overwrite value of a
assert 'MyClass(100, 14, "hi there")' == mc3.toString()

mc4 = mc1@(<a, b>)//copy mc1 but exclude a and b
assert 'MyClass(0, 0, "hi there")' == mc4.toString()

class ArgumentException(msg String) < Exception(msg)

def process(a int) int {
  if(a < 2){
    throw new ArgumentException("a is smaller than 2")
  }
  return a ** 2
}

result = try{
  process(1)
}catch(e ArgumentException){
  //handle exception as appropriate
  0 //return a default value
}catch(e){
  //unexpected exception, handle as appropriate
  throw e//re-throw
}

def readFirstLineFromFile(path String)  {
  from java.io import FileReader, BufferedReader
  try ( br = new BufferedReader(new FileReader(path))) {
    br.readLine();
  }//br will now be closed automatically
}

//factorial
def factorial(i int) int {
    match(i){
        0 => 1
        n => n * factorial(n-1)
    }
}

//a simple example
def simpleMatcher(x int){	
  match(x){
    0 => "zero"
    1 => "one"
    2 => "two"
    else => "other"
  }
}

//matcher for numbers with complex conditions
def advancedMatcher(a int){
  match(a){
    10 => "ten"
    ==9 => "explicit 9"
    2 or 3 => "or case"
    >2 and >5 and <==10 => "gt 5"
    >3 and <==10 => "gt three not ten"
    >11 => "gt to 11"
    else => "something else" + a
  }
}

//match operating across differing types
def machOnDifferingTypes(a Object){
  match(a){
    x int; x == 2 => "small"
    x String; x == "hello" => "said hi"
    else => "else: "+a
  }
}

//match based on object contents...
class Person(-yearOfBirth int, -name String)
def objContentsMatch(an Object){
  match(an){
    person Person(yearOfBirth < 1970) => "Person. Born: {person.yearOfBirth}"
    x => "unknown input"
  }
}

def powPlus(x int, r int, c int) => x**r + c //a normal function

mref (int, int, int) int = powPlus&//create a method reference to powPlus

def takesMethodRef(toCall (int, int, int) int) int{
  toCall(2, 2, 3)//call a method reference
}

//partially evaluated method reference:
partial (int) int = powPlus&(2, 2, int)

//a lambda definition with fully defined arguments:
alambda (int, int) int = def(a int, b int) int { a + b}

//anonymous lambdas:
//a function taking a function reference and applying it to each input argument
def map<X>(inputs list<X>, func (X) X) {
  func(x) for x in inputs
}

//we define a lambda as a => a+10 - this is equivalent to: def(a int) int { a + 10 }
mapped = map([1, 2, 3], a => a+10)

//We define a SAM (Single access method) type:
trait Doer<X>{
  def doOperation(a X) X
}

//a function taking the above SAM type and applying it to each input argument
def SAMmap<X>(inputs list<X>, func Doer) {
  func.doOperation(x) for x in inputs
}

//here our lambda a => a+10, gets converted into the SAM type: Doer
mapped = SAMmap([1, 2, 3], a => a+10)

lazy slowValue = {sum = 0L; for(x in (1 to 1000000)){ sum += x}; sum}//long time to calc

result = slowValue if (java.util.Random().nextInt() < 0) else "not calculated"

from com.mycompany.myproduct.langs using mylisp, myFortran, myAPL

calc = mylisp||(+ 1 2 (* 2 3))|| // == 9

myFortran || program hello
          		print *, "Hello World!"
       		 end program hello|| //prints "Hello World!"

lotto = myAPL || x[⍋x←6?40] || //6 unique random numbers from 1 to 40

from com.mycompany.myproduct.langs using mylisp, mySQL, myAPL
class Person(name String, yearOfBirth int)
people list<Person>;
//populate our list of people...

//select from our list of people variable defined above...
millennials = mySQL||select name from people where yearOfBirth between 1980 and 2000||

//create a new function, fact for performing factorial
myAPL||fact{×/⍳⍵}||
fact(10)//use of function defined above. Returns: 3628800

from com.mycompany.myproduct.langs using mylisp

aString = "i'm a String!"
invalidCode = mylisp||(+ 1 2 (* 2 aString))||
//results in compilation time error: line 4:35 mylisp: Expected numerical type, not 'String'

moreInvalidCode = mylisp||(+ 1 2 (* 2 3)|| //oops! Missing a closing ')'
//results in compilation time error: line 7:41 mylisp: Parser error, expected ')' symbol

class Complex(real double, imag double){
  def +(other Complex) => new Complex(this.real + other.real, this.imag + other.imag)
  def +=(other Complex) => this.real += other.real;  this.imag += other.imag
  override toString() => "Complex({real}, {imag})"
}

c1 = Complex(2, 3)
c2 = c1@//deep copy of c1
c3 = Complex(3, 4)

result1 = c1 + c3
c2 += c3 //compound plus assignment

//result1 == Complex(5.0, 7.0)
//c2 == Complex(5.0, 7.0)

def String repeat(n int) String {//this is an extension function
  return String.join(", ", java.util.Collections.nCopies(n, this))
}

res = "hi".repeat(2) //creates a reference

def int meg() = this * 1024L * 1024L

12.meg() //-> 12582912L

class Myclass(b int){
  def resolve(a int) => (a+b)*2
}

res = Myclass 4 resolve 4 //basic expression list, res == 16

from java.time import Duration, LocalDateTime

enum Currency{ GBP, USD, EUR, JPY }
enum OrderType{Buy, Sell}

class CcyAmount(amount long, ccy Currency){
  override toString() => "{amount} {ccy}"
}

abstract class Order(type OrderType, ccyamount CcyAmount){
  when LocalDateTime?
		
  def after(dur Duration){
    when = LocalDateTime.now()+ dur
  }
	
  override toString() => "{type} {ccyamount} at {when}"
}
class Buy(ccyamount CcyAmount) < Order(OrderType.Buy, ccyamount)
class Sell(ccyamount CcyAmount) < Order(OrderType.Sell, ccyamount)
//extension functions
def long gbp() => CcyAmount(this, Currency.GBP)
def int mil() => this*1000000L
def int seconds() => Duration.ofSeconds(this)


///////////Expression list:
order = Buy 1 mil gbp after 10 seconds
	
orderStr = "" + order
//orderStr == Buy 1000000 GBP at 2018-02-15T06:32:11.099