opel was designed to let you write simple, short asynchronous expressions. It uses Parboiled as a language grammar engine and common Java 8 CompletableFuture.

For example temperature() function asks REST service for temperature in Fahrenheit for given capital city and we want to convert it to Celsius. We can write a simple expression to achievie it.

(temperature('Warsaw') - 32) * 5 / 9

this expression will be transformed to equivalent code:

temperature('Warsaw')
	.thenCombine(CompletableFuture.completedFuture(32), (l, r) -> l - r)
	.thenCombine(CompletableFuture.completedFuture(5), (l, r) -> l * r)
	.thenCombine(CompletableFuture.completedFuture(9), (l, r) -> l / r)

• Our business case
• Why have we created another language?
• What can opel do for you?
• What opel can't do?
• Using with Gradle

In OpBox which is our solution to build frontend in microservices world we have to prepare site title depending on data returned from data source (REST service). For show product page it may look like:

restService('showProduct') + ' - Allegro.pl - Więcej niż aukcje.'

Allegro is a big platform with huge traffic. We encounter many performance issues so we decided to design everything asynchronously. Whenever it's possible we use CompletableFutures. It's a bit more complicated that way but opel abstraction layer enables our users (non developers) to write simple expressions in easy way.

After checking some expression languages like: SpEL or JEXL we didn't find any libraries supporting required asynchronous behavior.

opel aims at very simple expressions. Certainly it won't be enough to make complicated scripts - but we want opel to stay that way.

opel supports:

• primary math and string operations (i.e. 2+2*2, 'Hello' + 'world !')
• relational and equality operators (i.e. 2 == 3, 2 > 1 != false)
• logic operators (i.e. true && false, false || true)
• simple map element access (i.e. map.field or map['field'])
• simple list element access (i.e. list[index])
• object method calls (i.e. 'Hello, World!'.length())
• if expressions (i.e. if (2 > 3) 'a' else 'b')
• defining local constant values (i.e. val x = 2+2*2; x * x)
• registrable implicit conversions (i.e. 2 + '2' or 'Hello, World!'.myMethod())
• registrable functions (i.e. myFunction('Hello, World!'))
• registrable constant values (i.e. 'Hello, ' + WORLD_VALUE)

More can be found in documentation.

Basically, all you have to do is to add a compile dependency:

dependencies {
    compile 'pl.allegro.tech:opel:1.1.8'
}