Golo 2.0.0
Golo 2.0.0 is here with new language features, improvements and fixes. This is the result of a great community effort: we are glad that new contributors joined us, and the new language features are contributions developped outside of the Dynamid research group.
As Golo tries to stick to the semantics of semantic versioning, we bumped to a
new major version. Indeed, named augmentations are a new language feature, and they turn with
into a keyword, which introduces a tiny backwards incompatibility.
Before we dive into the highlights of this new release:
- Download Golo 2.0.0
- Play with Golo on Google AppEngine
- Read the Golo programming language guide
- Star / fork the project on GitHub
- Get in touch on our mailing-list
- Chat with us
Noteworthy changes
UTF-8 characters (and Emoji)
Yes, one can now have fun with UTF-8 symbols:
let ていすう = 1
var ヘンスウ = 1
function 関数 = |인수| -> 인수
struct структура = { عنصر }
Even better (or worse), Emoji is possible:
module Emoji.Me.IM.Famous
function main = |args| {
println("🍻")
let 👍 = "Golo"
println(👍)
}
which prints: 🍻 Golo
Named augmentations
Augmentations can now be given names, as in:
augmentation FooBar = {
function foo = |this| -> "foo"
function bar = |this, a| -> this: length() + a
}
augmentation Spamable = {
function spam = |this| -> "spam"
}
Then, such augmentations can be applied to types as in:
augment java.util.Collection with FooBar
augment MyStruct with Spamable
augment java.lang.String with FooBar, Spamable
See the documentation for more details about named augmentations
Banged function calls
Banged function calls allow caching the result of a first call:
function take_a_while = {
# ... complex computation
return 42
}
# (...)
foreach i in range(0, 100) {
println(take_a_while!())
}
In this contrieved example, take_a_while
would be called only once, and the value
would serve as a result for all subsequent calls to this call site.
Banged function calls shall only be used to cache the result of calls to pure functions.
The performance improvements done by caching with banged function calls are especially interesting when used on decorators. Indeed, Golo decorators are simply high-order functions, and they need to be evaluated for each decorated function call. This is not the case for banged decorators:
function decorator = |func| -> |x| -> func(x)
@!decorator
function identity = |x| -> x
which expands to:
function decorator = |func| -> |x| -> func(x)
function identity = |x| -> decorator!(|x| -> x)(x)
See the documentation for more details about banged function calls
Range objects improvements
Range objects now have a literal syntax:
let r1 = [1..10]
let r2 = ['a'..'f']
Ranges now support incrementedBy
/ decrementedBy
methods, which allows code such as:
foreach i in [0..10]: incrementBy(2) {
print(i + " ")
}
Number type conversion functions
Sometimes one needs to make explicit type conversions in a dynamically-typed language.
The intValue(n)
, longValue(n)
, charValue(n)
, doubleValue(n)
and floatValue(n)
functions
do just that:
let i = intValue("666") # 666 (string to integer)
let j = intValue(1.234) # 1 (double to integer)
let k = intValue(666_L) # 666 (long to integer)
# etc
New standard library functions
A few additions have been made to the standard library, including:
newTypedArray
to build typed JVM arrays (i.e., not justObject[]
arrays),uuid
to get a new UUID-generated string,sleep
as a shortcut tojava.lang.Thread.sleep
.
Other changes
The compiler has been tightened to reject referencing uninitialized references, such as in:
let a = a + 1
The golodoc generation has been improved.
Under the hood, the method / function runtime resolution has gone through several refactorings and fixes.
Until next time…
Many thanks again to our community members, and have fun with Golo!