function int sum($x int) {
    if ($x) $x + sum( next($x) )
    else 0    
};

sum( iter((1,2,3,4,5)) );

(1,2,3,4,5) / v:reduceLeft(_($x, $y) {$x * $y});   # = 120

def plus($x, $y) {$x + $y};
(1,2,3,4,5) / v:reduceLeft(%plus^2);    # = 15

&&{key := eval($keypath), value := <the portion of elements>}  

(1,2,3,4,5) / v:splitSequence(_{. mod 2 = 0}, _{.}, "starts");

&&{<$keyname> := eval(<$keypath>), <$valuename> := <the portion of elements>}

Splits the input sequence of strings into a number of groups with further merging of these groups into single strings.

$condition - the quoted expression desribing the condition of splitting the input sequence into the groups. If the condition is satisfied on an input element, the next group of strings starts.

$type - the type of handling splitting elements. If

    $type = "starts"

    $type = "ends"

    $type = "ends"

("abc", "def", "a12", "a34", "yy", "zz") / v:join(_{v:char-at(0) = 97}, "starts", "-");   # = ("", "abc-def", "a12",  "a34-yy-zz")

("abc", "def", "a12", "a34", "yy", "zz") / v:join(_{v:char-at(0) = 97}, "ends", "-");    # = ("abc", "def-a12", "a34" "yy-zz")

("abc", "def", "a12", "a34", "yy", "zz") / v:join(_{v:char-at(0) = 97}, "between", "-");    # = ("", "def", "", "yy-zz")

"11a222"/v:matchAll(«\d+», "")
    # = ("11", "222")

"11a222"/v:matchAll(«(\d)\d*», "")/"{.} / {$_m1}"!;
    # = ("11 / 1", "222 / 2")

round($location) <= $p < round($location) + round($length) 

addFunction("def add1() {. + 1}");

&_ {@o := [owner]; @p := [oproperty]; @i := [index] }

&_{@prefix := "map", @name := "http://ontobox.org/map"}

$object := &_ / v:put("num", 1);

$object / @num;     # = (1)

class C(v C);
C &c, &c1, &c2, &c3, &c4;
&c {v := (&c1, &c2, &c3, &c4)};
&c / v:removeValues(%v, _{. = &c3 or . = &c1});

&c / v;     # = (&c2, &c4)

class C(n v:int);
C &c {n := (1,2,3,4,5)};

&c / v:replaceValues(%n, _{. mod 2 = 0}, _{(., . * .)});

&c / n;                    # = (1, 2, 4, 3, 4, 16, 5)

"function f($x) { $x + 1 }"

class Libfunc {
    fun function
};
Libfunc &myfunc {
    fun := toFunction("function add1($x) { $x + 1 }")
};
# now load this function in the box:
eval(&myfunc/fun);

function add1($x) { $x + 1 };

&myfunc {fun:= `add1};

(1,2,3)/v:collect(_{$x}) / {. + $x/v:last()};  # = (4,5,6)

In Libretto it is possible to forbid the evaluation of a block {...} by putting underscore "_" before it: _{...}. Such a suspended expression becomes an ordinary data value. For evaluation of the suspended expression, the function eval/1 is used. To evaluate exp in the context of Ctx, we write Ctx / eval(exp).

eval/1 is also used for evaluation parametrized strings: it evaluates values in curly brackets while leaving other parts of the parametrized string untouched:

(1,2,3)/v:eval("1 + {.} = {1 + .}")      # = ("1 + 1 = 2", "1 + 2 = 3", "1 + 3 = 4")

'!' is used as a syntactic sugar for v:eval/1:

_{1+2}!     # = 3
(1,2,3)/"1 + {.} = {1 + .}"!     # = ("1 + 1 = 2", "1 + 2 = 3", "1 + 3 = 4")

$term := ``. + 1; (1, 2)/eval($term); # = (2, 3)

eval/2 does the same job as eval/1, but it can evaluate anonymuous functions with arguments and provides the application of escapers in case of parametrized strings. For instance, if we assign $f a anonymuous function with one argument:

$f := _($x) {. * $x};

then we can apply this function using eval/2:

(1,2,3) / v:eval($f, (5));              # = (5, 10, 15)

The second argument of eval/2 contains the sequence of actual parameters of the anonymuous functions ((5) in our case).

'!' can be used as a syntactic sugar here:

(1,2,3) / $f!(5);        # = (5, 10, 15)

If eval/2 evaluates parametrized strings, then the 2nd argument contains an escaper for transforming the values of the expressions in curly brackets:

«<a>{«<b/>»}</a>»!;           # = "<a><b/></a>"
«<a>{«<b/>»}</a>»!x:esc;       # = "«<a><b/></a>»"

Here the inner string «<b/>» is modified by the function x:esc/1. Note that using « and » allows us to introduce nested strings. «a{«b»}a» without ! is an ordinary string, but with the indication of whether a quote is opening or closing (like with parentheses). The ascii equivalents of « and » are ^" and "^ respectively.

Any function with one argument can serve as the escaper:

def double($x) {$x + $x};
«A{«b»}a»!double;         # = "Abba"
«a{1+2}a»!double;          # = "a6a"

&_ {@query := ``1+2;   @answer := 3}

"def f($x) {$x + 1}; f(5)+6;" / v:execute() / "query = {@query} answer = {@answer}"!;  #2 = (query = ``function  f($x)  $x + 1; answer = "", query = ``f(5) + 6; answer = 12)

index("gps", Person, ``.,  ``child/child);

&John / indexValues("gps");

index("gps", Person, _{child/child}, _{.});

&John / index-values("gps");

• 1st is the name of the index
• 2nd is the basic set for indexing
• 3rd (key) is indexing value corresponding to the basic element
• 4th (value) is indexed value corresponding to the basic element

&p/(child/child)

def f() {if (. = "a") v:rollback("aaa") else .}; ("a", 1)/v:label("aaa", `{f()}, "aaaaa");   # = (1, "aaaaa")

x:entity("lt") / v:codes-string();   # = "<"

x:entity("#x25") / v:codes-string();    # = "%"

x:esc("<a>");    # = "<a>"

«<a>{"<a>"}</a>»!x:esc;   # = "<a><a></a>"