Czy może ktoś wyjasnić składnię, np:
----------------------------------------------------
------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
class Fib
{
/**
* This example illustrates creating a lot of recursive work by
calculating
* fibonacci numbers top down.
*
* It uses promises to allow results to be reacted to.
*
* The compiler does not have syntax support for promises, and they
are just
* treated as a special type of cown at the moment. This will change
but the
* code illustrates roughly how they would be used.
*
* Cown's only currently wrap object types, not primitives, so the
example
* uses a U64Obj, that boxes a U64. This is not essential, and will be
* addressed in the future.
*
* The idealised syntax we are aiming for is given below
* fib(x: U64): promise[U64]
{
if (x < 2)
{
// Implicitely lifting a Value to a promise
1
}
else
{
// When returns a promise for the value it evaluates to.
// Thus nested when would require an implicit coercion from
// promise[promise[U64]] to promise[U64]
when ()
{
var p1 = Fib.fib(x - 1);
var p2 = Fib.fib(x - 2);
when (p1, p2) {
p1 + p2
}
}
}
}
*/

fib(x: U64 & imm): cown[U64Obj] & imm
{
var pw = Promise.create();
var pr = (mut-view pw).wait_handle();

if (x < 2)
{
pw.fulfill(U64Obj.create(1));
}
else
{
// `when` with no arguments used to start a new asynchronous task.
// Better syntax may be needed for this.
// This is required, so that the whole promise graph isn't
constructed
// sequentially.
when ()
{
var p1 = Fib.fib(x - 1);
var p2 = Fib.fib(x - 2);
// When both computations complete, fulfill the result with the
addition
// of the two sub calls.
when (p1, p2) {
var r = U64Obj.create(p1.v + p2.v);
pw.fulfill(r)
}
}
};
pr
}
}

class Main
{
main()
{
when (var uo = Fib.fib(12))
{
// CHECK-L: result=233
Builtin.print1("result={}\n", uo.v);
}
}
}
----------------------------------------------------
------------
kompiluje się, najpierw (po skompilowaniu kompilatora i interpretera):
~/veronac --output fib fib.verona
potem
~/interpreter --cores 2 fib
--cores nieobowiązkowe
można zamiast interpretera od razu uruchamić przez kompilator, ale warto
skompilować do kodu bajtowego.
zamiast 12 mozna wpisać 24, lepiej nie wpisywać wię...szych wartości typu
120 bo złożoność jest wykładnicza.
co oznaczają
1.Promise
2.when
3.mut-view
4.fulfill
szkoda że nie ma większego opisu, dokumentacji.