Released Functions

abs

abs(float: Float[1]): Float[1]
  • Parameters
    • float: Float[1]
  • Returns
    • Float[1]
abs(int: Integer[1]): Integer[1]
  • Parameters
    • int: Integer[1]
  • Returns
    • Integer[1]
  • Usage
{|Person->getAll()->project({p|$p.firstName}, 'firstName')->groupBy('firstName', 'new'->agg({e|$e}, {y|$y->count()->abs()}))}

adjust

adjust(date: Date[1], number: Integer[1], unit: DurationUnit[1]): Date[1]
  • Parameters
    • date: Date[1]
    • number: Integer[1]
    • unit: DurationUnit[1]
  • Returns
    • Date[1]

and

and(vals: Boolean[*]): Boolean[1]
  • Parameters
    • vals: Boolean[*]
  • Returns
    • Boolean[1]
and(first: Boolean[1], second: Boolean[1]): Boolean[1]
  • Parameters
    • first: Boolean[1]
    • second: Boolean[1]
  • Returns
    • Boolean[1]

at

at<T>(set: T[*], key: Integer[1]): T[1]
  • Parameters
    • set: T[*]
    • key: Integer[1]
  • Returns
    • T[1]

average

average(numbers: Float[*]): Float[1]
  • Parameters
    • numbers: Float[*]
  • Returns
    • Float[1]
average(numbers: Integer[*]): Float[1]
  • Parameters
    • numbers: Integer[*]
  • Returns
    • Float[1]
average(numbers: Number[*]): Float[1]
  • Parameters
    • numbers: Number[*]
  • Returns
    • Float[1]

cast

cast<T>(source: Any[m], object: T[1]): T[m]
  • Parameters
    • source: Any[m]
    • object: T[1]
  • Returns
    • T[m]

concatenate

concatenate<T>(set1: T[*], set2: T[*]): T[*]
  • Parameters
    • set1: T[*]
    • set2: T[*]
  • Returns
    • T[*]

contains

contains(collection: Any[*], value: Any[1]): Boolean[1]
  • Parameters
    • collection: Any[*]
    • value: Any[1]
  • Returns
    • Boolean[1]
contains(source: String[1], val: String[1]): Boolean[1]
  • Parameters
    • source: String[1]
    • val: String[1]
  • Returns
    • Boolean[1]

count

count(s: Any[*]): Integer[1]
  • Parameters
    • s: Any[*]
  • Returns
    • Integer[1]

distinct

distinct<T>(s: T[*]): T[*]
  • Parameters
    • s: T[*]
  • Returns
    • T[*]

divide

divide(left: Number[1], right: Number[1]): Float[1]
  • Parameters
    • left: Number[1]
    • right: Number[1]
  • Returns
    • Float[1]

drop

drop<T>(set: T[*], count: Integer[1]): T[*]
  • Parameters
    • set: T[*]
    • count: Integer[1]
  • Returns
    • T[*]

endsWith

endsWith(source: String[1], val: String[1]): Boolean[1]
  • Parameters
    • source: String[1]
    • val: String[1]
  • Returns
    • Boolean[1]

equal

equal(left: Any[*], right: Any[*]): Boolean[1]
  • Parameters
    • left: Any[*]
    • right: Any[*]
  • Returns
    • Boolean[1]

exists

exists<T>(value: T[*], func: Function<{T[1]->Boolean[1]}<[1]): Boolean[1]
  • Parameters
    • value: T[*]
    • func: Function<{T[1]->Boolean[1]}<[1]
  • Returns
    • Boolean[1]

filter

filter<T>(value: T[*], func: Function<{T[1]->Boolean[1]}<[1]): T[*]
  • Parameters
    • value: T[*]
    • func: Function<{T[1]->Boolean[1]}<[1]
  • Returns
    • T[*]

first

first<T>(set: T[*]): T[0..1]
  • Parameters
    • set: T[*]
  • Returns
    • T[0..1]

greaterThan

greaterThan(left: String[1], right: String[1]): Boolean[1]
  • Parameters
    • left: String[1]
    • right: String[1]
  • Returns
    • Boolean[1]
greaterThan(left: Number[1], right: Number[1]): Boolean[1]
  • Parameters
    • left: Number[1]
    • right: Number[1]
  • Returns
    • Boolean[1]

greaterThanEqual

greaterThanEqual(left: String[1], right: String[1]): Boolean[1]
  • Parameters
    • left: String[1]
    • right: String[1]
  • Returns
    • Boolean[1]
greaterThanEqual(left: Number[1], right: Number[1]): Boolean[1]
  • Parameters
    • left: Number[1]
    • right: Number[1]
  • Returns
    • Boolean[1]

if

if<T>(test: Boolean[1], valid: Function<{->T[m]}<[1], invalid: Function<{->T[m]}<[1]): T[m]
  • Parameters
    • test: Boolean[1]
    • valid: Function<{->T[m]}<[1]
    • invalid: Function<{->T[m]}<[1]
  • Returns
    • T[m]

in

in(value: Any[1], collection: Any[*]): Boolean[1]
  • Parameters
    • value: Any[1]
    • collection: Any[*]
  • Returns
    • Boolean[1]
in(value: Any[0..1], collection: Any[*]): Boolean[1]
  • Parameters
    • value: Any[0..1]
    • collection: Any[*]
  • Returns
    • Boolean[1]

indexOf

indexOf(str: String[1], toFind: String[1]): Integer[1]
  • Parameters
    • str: String[1]
    • toFind: String[1]
  • Returns
    • Integer[1]

isEmpty

isEmpty(p: Any[*]): Boolean[1]
  • Parameters
    • p: Any[*]
  • Returns
    • Boolean[1]
isEmpty(p: Any[0..1]): Boolean[1]
  • Parameters
    • p: Any[0..1]
  • Returns
    • Boolean[1]

isNotEmpty

isNotEmpty(p: Any[*]): Boolean[1]
  • Parameters
    • p: Any[*]
  • Returns
    • Boolean[1]
isNotEmpty(p: Any[0..1]): Boolean[1]
  • Parameters
    • p: Any[0..1]
  • Returns
    • Boolean[1]

joinStrings

joinStrings(strings: String[*], prefix: String[1], separator: String[1], suffix: String[1]): String[1]
  • Parameters
    • strings: String[*]
    • prefix: String[1]
    • separator: String[1]
    • suffix: String[1]
  • Returns
    • String[1]
joinStrings(strings: String[*]): String[1]
  • Parameters
    • strings: String[*]
  • Returns
    • String[1]
joinStrings(strings: String[*], separator: String[1]): String[1]
  • Parameters
    • strings: String[*]
    • separator: String[1]
  • Returns
    • String[1]
  • Usage
{|Firm->getAll()->groupBy({f|$f.legalName}, {x|$x.employees->map({v_automap|$v_automap.firstName})}->agg({y|$y->joinStrings('*')}), ['legalName', 'employeesFirstName'])}

length

length(str: String[1]): Integer[1]
  • Parameters
    • str: String[1]
  • Returns
    • Integer[1]

lessThan

lessThan(left: String[1], right: String[1]): Boolean[1]
  • Parameters
    • left: String[1]
    • right: String[1]
  • Returns
    • Boolean[1]
lessThan(left: Number[1], right: Number[1]): Boolean[1]
  • Parameters
    • left: Number[1]
    • right: Number[1]
  • Returns
    • Boolean[1]
lessThan(left: Number[0..1], right: Number[1]): Boolean[1]
  • Parameters
    • left: Number[0..1]
    • right: Number[1]
  • Returns
    • Boolean[1]

lessThanEqual

lessThanEqual(left: String[1], right: String[1]): Boolean[1]
  • Parameters
    • left: String[1]
    • right: String[1]
  • Returns
    • Boolean[1]
lessThanEqual(left: Number[1], right: Number[1]): Boolean[1]
  • Parameters
    • left: Number[1]
    • right: Number[1]
  • Returns
    • Boolean[1]

limit

limit<T>(set: T[*], count: Integer[1]): T[*]
  • Parameters
    • set: T[*]
    • count: Integer[1]
  • Returns
    • T[*]

map

map<T, V>(value: T[*], func: Function<{T[1]->V[*]}<[1]): V[*]
  • Parameters
    • value: T[*]
    • func: Function<{T[1]->V[*]}<[1]
  • Returns
    • V[*]
map<T, V>(value: T[m], func: Function<{T[1]->V[1]}<[1]): V[m]
  • Parameters
    • value: T[m]
    • func: Function<{T[1]->V[1]}<[1]
  • Returns
    • V[m]
map<T, V>(value: T[0..1], func: Function<{T[1]->V[0..1]}<[1]): V[0..1]
  • Parameters
    • value: T[0..1]
    • func: Function<{T[1]->V[0..1]}<[1]
  • Returns
    • V[0..1]

max

max(ints: Float[1..*]): Float[1]
  • Parameters
    • ints: Float[1..*]
  • Returns
    • Float[1]
max(ints: Float[*]): Float[0..1]
  • Parameters
    • ints: Float[*]
  • Returns
    • Float[0..1]
max(ints: Integer[1..*]): Integer[1]
  • Parameters
    • ints: Integer[1..*]
  • Returns
    • Integer[1]
max(ints: Integer[*]): Integer[0..1]
  • Parameters
    • ints: Integer[*]
  • Returns
    • Integer[0..1]
max(left: Number[1], right: Number[1]): Number[1]
  • Parameters
    • left: Number[1]
    • right: Number[1]
  • Returns
    • Number[1]
max(numbers: Number[1..*]): Number[1]
  • Parameters
    • numbers: Number[1..*]
  • Returns
    • Number[1]
max(numbers: Number[*]): Number[0..1]
  • Parameters
    • numbers: Number[*]
  • Returns
    • Number[0..1]

minus

minus(decimal: Decimal[*]): Decimal[1]
  • Parameters
    • decimal: Decimal[*]
  • Returns
    • Decimal[1]
minus(float: Float[*]): Float[1]
  • Parameters
    • float: Float[*]
  • Returns
    • Float[1]
minus(ints: Integer[*]): Integer[1]
  • Parameters
    • ints: Integer[*]
  • Returns
    • Integer[1]
minus(numbers: Number[*]): Number[1]
  • Parameters
    • numbers: Number[*]
  • Returns
    • Number[1]

not

not(bool: Boolean[1]): Boolean[1]
  • Parameters
    • bool: Boolean[1]
  • Returns
    • Boolean[1]

now

now(): DateTime[1]
  • Returns
    • DateTime[1]

or

or(vals: Boolean[1..*]): Boolean[1]
  • Parameters
    • vals: Boolean[1..*]
  • Returns
    • Boolean[1]
or(first: Boolean[1], second: Boolean[1]): Boolean[1]
  • Parameters
    • first: Boolean[1]
    • second: Boolean[1]
  • Returns
    • Boolean[1]

parseFloat

parseFloat(string: String[1]): Float[1]
  • Parameters
    • string: String[1]
  • Returns
    • Float[1]

parseInteger

parseInteger(string: String[1]): Integer[1]
  • Parameters
    • string: String[1]
  • Returns
    • Integer[1]

plus

plus(decimal: Decimal[*]): Decimal[1]
  • Parameters
    • decimal: Decimal[*]
  • Returns
    • Decimal[1]
plus(float: Float[*]): Float[1]
  • Parameters
    • float: Float[*]
  • Returns
    • Float[1]
plus(ints: Integer[*]): Integer[1]
  • Parameters
    • ints: Integer[*]
  • Returns
    • Integer[1]
plus(numbers: Number[*]): Number[1]
  • Parameters
    • numbers: Number[*]
  • Returns
    • Number[1]
plus(strings: String[*]): String[1]
  • Parameters
    • strings: String[*]
  • Returns
    • String[1]

rem

rem(dividend: Number[1], divisor: Number[1]): Number[1]
  • Parameters
    • dividend: Number[1]
    • divisor: Number[1]
  • Returns
    • Number[1]

replace

replace(source: String[1], toReplace: String[1], replacement: String[1]): String[1]
  • Parameters
    • source: String[1]
    • toReplace: String[1]
    • replacement: String[1]
  • Returns
    • String[1]

round

round(number: Number[1]): Integer[1]
  • Parameters
    • number: Number[1]
  • Returns
    • Integer[1]
round(decimal: Decimal[1], scale: Integer[1]): Decimal[1]
  • Parameters
    • decimal: Decimal[1]
    • scale: Integer[1]
  • Returns
    • Decimal[1]

size

size(p: Any[*]): Integer[1]
  • Parameters
    • p: Any[*]
  • Returns
    • Integer[1]

slice

slice<T>(set: T[*], start: Integer[1], end: Integer[1]): T[*]
  • Parameters
    • set: T[*]
    • start: Integer[1]
    • end: Integer[1]
  • Returns
    • T[*]

split

split(str: String[1], token: String[1]): String[*]
  • Parameters
    • str: String[1]
    • token: String[1]
  • Returns
    • String[*]

startsWith

startsWith(source: String[1], val: String[1]): Boolean[1]
  • Parameters
    • source: String[1]
    • val: String[1]
  • Returns
    • Boolean[1]
  • Usage
{|Person->getAll()->project({a|$a.firstName->startsWith('tri')}, 'a')}

substring

substring(str: String[1], start: Integer[1], end: Integer[1]): String[1]
  • Parameters
    • str: String[1]
    • start: Integer[1]
    • end: Integer[1]
  • Returns
    • String[1]

take

take<T>(set: T[*], count: Integer[1]): T[*]
  • Parameters
    • set: T[*]
    • count: Integer[1]
  • Returns
    • T[*]

times

times(ints: Float[*]): Float[1]
  • Parameters
    • ints: Float[*]
  • Returns
    • Float[1]
times(ints: Integer[*]): Integer[1]
  • Parameters
    • ints: Integer[*]
  • Returns
    • Integer[1]
times(numbers: Number[*]): Number[1]
  • Parameters
    • numbers: Number[*]
  • Returns
    • Number[1]

toLower

toLower(source: String[1]): String[1]
  • Parameters
    • source: String[1]
  • Returns
    • String[1]

toOne

toOne<T>(values: T[*]): T[1]
  • Parameters
    • values: T[*]
  • Returns
    • T[1]

toOneMany

toOneMany<T>(values: T[*]): T[1..*]
  • Parameters
    • values: T[*]
  • Returns
    • T[1..*]

toString

toString(any: Any[1]): String[1]
  • Parameters
    • any: Any[1]
  • Returns
    • String[1]

toUpper

toUpper(source: String[1]): String[1]
  • Parameters
    • source: String[1]
  • Returns
    • String[1]

today

today(): StrictDate[1]
  • Returns
    • StrictDate[1]
  • Usage
{|Trade->getAll()->filter({t|$t.settlementDateTime->datePart() == today()})->project({t|$t.id}, 'tradeId')}

trim

trim(str: String[1]): String[1]
  • Parameters
    • str: String[1]
  • Returns
    • String[1]

union

union<T>(set1: T[*], set2: T[*]): T[*]
  • Parameters
    • set1: T[*]
    • set2: T[*]
  • Returns
    • T[*]
← LanguageUpcoming Functions →