Language Features

Language Features

This page describes a few of the language features that Jactl offers. Jactl syntax is largely based on Java with parts also liberally borrowed from Groovy and Perl.

Semi-Colon Optional

Semi-colon statement terminator is optional and is only needed if multiple statements are on the same line:

int  x = 1
long y = 2

or

int x = 1; long y = 2

Functions Return Value of Last Statement

Functions can explicitly return a value using the return statement but if the last statement is not a return then its value will be returned:

int fib(int x) { return x <= 2 ? 1 : fib(x-1) + fib(x-2) }

is the same as:

int fib(int x) { x <= 2 ? 1 : fib(x-1) + fib(x-2) }

Dynamic Typing with Optional Static Typing

Sppecifying types is optional in Jactl when declaring variables, parameters, and fields. If a type is specified then Jactl can perform compile-time checking and some optimisations.

Static typing:

int fib(int x) { x <= 2 ? 1 : fib(x-1) + fib(x-2) }

Dynamic typing:

def fib(x) { x <= 2 ? 1 : fib(x-1) + fib(x-2) }

Map and List Literals

Map and list literals:

// Lists
[1,2,3,4]
['abc', 'def', 'xyz']

// Maps (keys only need to be quoted if they are not simple identifiers)
[a:1, b:2, c:3]
['a key':'a value', b:'another value']

// Can easily return maps or lists from functions
def addAndMultiply(x,y) { [sum:x + y, product:x * y] }  

Maps can use the canonical [ ] form or can also be provided in JSON syntax:

Map m1 = [x:1, y:2]
Map m2 = {"x":1, "y":2}

Interpolated Strings

Strings can be delimited with single quotes for simple strings, or double quotes for interpolated strings where $ is used to insert the value of a variable:

def x = 'this is a simple string'
def y = "Value of x = $x"

More complex expressions can be inserted into interpolated strings using ${ }:

def x = 3
def y = "x * x is ${x * x}"

// Expressions can contain other interpolated strings
def z = "Interpolated with ${"embedded interpolated (x*x=${x*x})"} string"

Multi-Line Strings

Multi-line simple strings and interpolated strings can be specified using triple quotes:

def simple = '''
multi-line
simple string'''

def interpolated = """
This is not 
a ${$simple}"""

Triple quotes are useful when you want to embed quotes and don’t want to have to escape them:

def x = 3
def y = """Value "${x*x}" for input of $x"""
def z = '''Triple quoted simple 'string' with embedded quotes'''

Functions as Values

Functions are just objects and can be passed around as values:

def fib(x) { x <= 2 ? 1 : fib(x-1) + fib(x-2) }

def applyArg(f, x) { f(x) }

def g = fib        // assign to another variable
g(40)

applyArg(fib, 40)  // pass as arg to a function

Methods passed as value are bound to the owning object:

class Multiplier {
  int multiple = 1
  def multiply(int x) { x * multiple }
}

def m = new Multplier(multiple:4)

g = m.multiply
g(3)                      // result is 12

applyArg(m.multiply, 5)   // result is 20

Closures

Closures in Jactl follow the Groovy syntax where the parameters are declared (with optional type) after the initial {:

def add = { x,y -> x + y }

add(2,3)           // result is 5

def f = add
f('abc', 'xyz')    // result is 'abcxyz'

Closures can close over variables visible in the existing scope:

def x = 2
def sumx = { y -> x + y }

sumx(3)   // result is 5
x = 7
sumx(3)   // result is 10

Variables can be modified within closures:

def x = 5
def incx = { x++ }
incx()    // x will now be 6    

Closure Passing Syntax

If the last parameter to a function is a closure then the closure can be written after the closing ) for the other arguments:

def logResult(prefix, clos) { "$prefix: result is ${ clos() }"}

logResult("Addition", { 2 + 3 })   // Pass closure as 2nd argument

logResult("Addition"){ 2 + 3 }     // Closure arg can be provided after the ')'

If there are no other arguments then the parentheses are optional:

def fib(x) { x <= 2 ? 1 : fib(x-1) + fib(x-2) }
def measure(clos) { def start = nanoTime(); clos(); nanoTime() - start }

def totalTime

totalTime = measure{
  for (int i = 0; i < 40; i++) {
    fib(i + 1)
  }
}

// Or using built-in "each" method
totalTime = measure{ 40.each{ i -> fib(i + 1) } } 

Higher-Order Functions

Since functions and closures can be passed by value it is possible to write other functions that operate on a function. For example, we can create a higher-order function compose that returns a new function that is the composition of two other functions:

def compose(f,g) { return { x -> f(g(x)) } }
def twice(x) { x * 2 }
def plus3(x) { x + 3 }

def plus3Twice = compose(twice, plus3)

plus3Twice(7)        // returns 20

Efficient Built-in Higher-Order Functions

There are also many built-in higher-order functions for operating on collection types (List, Map, array) including map, flatMap, filter, and each:

def fib(x) { x <= 2 ? 1 : fib(x-1) + fib(x-2) }

// Find first fibonacci number under 1000 that is a multiple of 57
def x = 1000.map{ [it, fib(it)] }.filter{ n,fib -> fib % 57 == 0 }.limit(1)[0]

// Returns [36, 14930352] so 36th fibonacci number (14930352) is a multiple of 57  

These higher-order functions that operate over collections work by iterating over the collections rather than creating a new collection each time. So in the example above where we iterate over the first 1000 Fibonacci numbers looking for the first one that is a multiple of 57, we don’t actually calculate the first 1000 Fibonacci numbers. The limit(1) means that we stop iterating as soon as we find the first one that matches. Each number flows through each of the higher-order functions one at a time before we iterate over the subsequent number.

Regex Support with Capture Variables $1, $2, …

Regular expression matching is part of the language rather than being delegated to library calls. The =~ operator searches a string for a substring that matches the given pattern:

'abcxdef' =~ /x/     // Result is true

Capture expressions in a regex pattern cause variables $1, $2, and so on to get populated with the corresponding values from the string being matched:

if ('Total: 14ms' =~ /: (\d+)(.*)$/) {
  println "Amount is $1, unit is $2"   // Prints: Amount is 14, unit is ms     
}

def x = 'a=1,bcd=234,e=3'
def result = []
// Extract all key=value values from x into list of [key,value] pairs:
while (x =~ /([^,=]+)=(\d+)/g) {
  result <<= [$1, $2]
}
println result
// Prints: [['a', '1'], ['bcd', '234'], ['e', '3']]

Regex substitutions can be done using s/.../.../ syntax:

def x = 'abcdef'
x =~ s/[ace]/x/   // Substitute only first match
println x         // Prints: xbcdef

x =~ s/[ace]/x/g  // Replace all matching substrings
println x         // Prints: xbxdxf

Embedded expressions can be used in the replacement string and can refer to capture variables:

def x = 'abcdef'
x =~ s/([ace])(.)/${ $2 + $1 }/g
println x                            // Prints: badcfe 

Implicit it Parameter

Closures that don’t declare a parameter have an automatic it parameter created for them:

def twice = { it + it }
twice(3)          // 6

// All numbers from 1 to 100 that are multiples of 7 and whose digits sum to be a multiple of 5:
def nums = 100.map{ it + 1 }
              .filter{ it % 7 == 0 }
              .map{ [it, it.toString().map{ it as int }.sum()] }
              .filter{ it[1] % 5 == 0 }
              .map{ it[0] }
// Result: [14, 28, 91]

Regular expressions operate on the implicit it variable if no string value is provided:

// Sanitise text to make suitable for a link
def linkify = { s/ /-/g;  s/[^\w-]//g }

// Find all top level headings in input and generate markdown for table of contents:
stream(nextLine).filter{ /^# /r }
                .map{ s/# // }
                .map{ "* [$it](#${ linkify(it.toLowerCase()) })" }
                .each{ println it }

Pattern Matching with Destructuring

Jactl provides switch expressions that can match on literal values but can also be used to match on the structure of the data and bind variables to different parts of the structure:

switch (x) {
  /X=(\d+),Y=(\d+)/n ->  $1 + $2   // regex match with capture vars
  [1,*]              -> 'matched'  // list whose first element is 1
  [_,_]              -> 'matched'  // list with 2 elements
  [int,String,_]     -> 'matched'  // 3 element list. 1st is an int, 2nd is a String
  [a,_,a]            -> a * 2      // 1st and last elements the same in 3 element list
  [a,*,a] if a < 10  -> a * 3      // list with at least 2 elements. 1st and last the same and < 10
  [a,${2*a},${3*a}]  -> a          // match if list is of form [2,4,6] or [3,6,9] etc
  [a,b,c,d]          -> a+b+c+d    // 4 element list
}

Statement if/unless Condition

As well as standard if statements, it is possible to have the if and the condition come after the statement to be executed so this standard form of if:

def fib(x) {
  if (x <= 2) {
    return 1
  }
  return fib(x-1) + fib(x-2)
}

can be written:

def fib(x) {
  return 1 if x <= 2
  return fib(x-2) + fib(x-1)
}

It is also possible to us unless instead of if when that is more natural:

def fib(x) {
  return 1 unless x > 2
  return fib(x-2) + fib(x-1)
}

Additional and, or, and not Operators

As well as the standard &&, ||, and ! boolean operators, there are and, or, and not operators that have much lower precedence (lower than assignment expressions, for example). This allows for this style of programming where it makes sense:

stream(nextLine).each{
  /^\$ *cd +\/$/r   and do { cwd = root;             return }
  /^\$ *cd +\.\.$/r and do { cwd = cwd.parent;       return }
  /^\$ *cd +(.*)$/r and do { cwd = cwd.children[$1]; return }
  /^\$ *ls/r        and return
  /^dir +(.*)$/r    and cwd.children[$1] = new Dir($1,-1,cwd)
  /^(\d+) +(.*)$/n  and cwd.children[$2] = new File($2,$1)
}

Default Parameter Values

Functions and closures can have parameters with default values:

def format(num, int base = 10) { sprintf("%9s", num.toBase(base) as String) }

format(300)      // Defaults to decimal: '      300'
format(300, 16)  // Hex:                 '      12C' 
format(300, 2)   // Binary:              '100101100'

Named Arguments

When invoking fuctions/closures, the parameter names can be supplied:

def format(num, int base = 10) { sprintf("%9s", num.toBase(base) as String) }

format(num:400, base:16)
format(base:8,  num:400)       // any order supported for named args 

eval() Statement

Jactl has a built-in eval statement which will compile and execute a string of Jactl code at run-time. A map of values for variables that the script references can be passed in as an optional argument:

eval('3 + 4')                                        // returns 7
eval('x + y', [x:3, y:4])                            // returns 7
eval('def twice = {it+it}; twice(x+y)', [x:3, y:4])  // returns 14

Built-in JSON Support

Jactl can convert objects into JSON using the toJson() method:

def x = [a:1,b:[x:3,y:4],c:['a','b','c']]
x.toJson()         // {"a":1,"b":{"x":3,"y":4},"c":["a","b","c"]}

The corresponding fromJson() method on strings will convert back from JSON to simple objects:

def json = '{"a":1,"b":{"x":3,"y":4},"c":["a","b","c"]}'
json.fromJson()   // [a:1, b:[x:3, y:4], c:['a', 'b', 'c']] 

For user defined classes, Jactl will generate a toJson() method and a class static method fromJson():

class X { int i; String s }
X x = new X(i:3, s:'abc')
x.toJson()      // {"i":3,"s":"abc"}
x = X.fromJson('{"i":3,"s":"abc"}')

Decimal Number Support

Jactl uses BigDecimal for “floating point” numbers by default (known as Decimal numbers in Jactl). This makes it suitable for manipulating currency amounts where arbitrary precision is required. Jactl also offers double numbers for situations where speed is more important than accuracy. For example:

1211.12 / 100            // Result is: 12.1112
((double)1211.12) / 100  // Result is: 12.111199999999998

Default Value Operator ?:

Jactl offers the ?: operator that will return the value on the right-hand side if the left-hand side is null:

def x
x ?: 123    // value will be 123 since x is null

Spaceship Operator <=>

The <=> operator is a comparator operator that returns -1, 0, or 1 if the left-hand side is less than, equal, or greater than the right-hand side respectively. This makes it easy to create a comparator function for sorting things:

def employees = [[name:'Mary', salary:10000], [name:'Susan', salary:5000], [name:'Fred', salary:7000]]

// Sort according to salary
employees.sort{ a,b -> a.salary <=> b.salary }

// Result: [[name:'Susan', salary:5000], [name:'Fred', salary:7000], [name:'Mary', salary:10000]]

Field Access ?. and ?[ Operators

When accessing fields of a map or a list/array the ?. operator (for maps) and the ?[ operator (for lists) allows you to safely dereference a null value. If the map/list is null then the resulting field reference will also be null if you use these operators:

def x
x.a            // Generates a NullError since x is null
x?.a           // Value will be null
x?[0]          // Value will be null
x?.a?.b?[0]    // Value will be null

Auto-Creation of Fields

When assigning a value to a field expression like a.b.c the values for intermediate fields will be automatically constructed where possible. For example:

def x = [:]       // empty map
x.a.b.c = '123'   // automatically create fields for x.a and x.a.b
x                 // x now has a value of: [a:[b:[c:'123']]]
x.d.e[2] = 'abc'  // x now has a value of: [a:[b:[c:'123']], d:[e:[null, null, 'abc']]]

Multi-Assignments

Multiple variables can be declared and initialised in one statement and multiple assignments can also be done in one statement:

def (x,y,z) = [4,5,6]                    // initialisation
(x,y,z) = [0,1,2]                        // assignment
(x,y) += [2,3]                           // supports all assignment operators +=, -=, *=, etc

def a = [:]
(a.b.c[x], a.b.c[y]) = [x + y, y + z]    // multi-assign with auto-creation of subfields

You can use a multi-assignment to swap the values of two variables:

(x,y) = [y,x]      // swaps x and y

Classes

Users can define their own classes:

class X {
  int i
  String field
  def anotherField
  def method() { field + ':' + anotherField + ':' + i }
}

class Y extends X {
  // Override method in base class 
  def method() { "Y: " + super.method() }
}

def y = new Y(i:4, field:'value1', anotherField:'value2')
y.method()      // returns 'Y: value1:value2:4'

Packages and Import Statements

Classes can be grouped into packages (libraries) just like in Java/Groovy using a package statement:

package org.customer.utils

class Useful {
  static def func() {
    ...
  }
}

Import statements allow you to use a class without needing to fully qualify it with its package name each time:

import org.customer.utils.Useful
def x = Useful.func()

Import allows you to give a class an alias using as:

import org.customer.utils.Useful as U
def x = U.func()

You can also import static functions and class constants using import static:

import static org.customer.utils.Useful.func as f
def x = f()   // invokes Useful.func()