Language functions
append
Arguments: [list: Nullable[List[Nullable[Anything]]], element: Nullable[Anything]]
Returns: List[Nullable[Anything]]
Append an element to a list.
concat
Arguments: [lhs: Nullable[List[Nullable[Anything]]], rhs: Nullable[List[Nullable[Anything]]]]
Returns: List[Nullable[Anything]]
Concatenate two lists to create a new list.
map
Arguments: [iterable: List[Nullable[Anything]], foreach: λ(list_element)]
Returns: List[Nullable[Anything]]
Apply an expression to each element in a list to produce a new list. Serves the same purpose in RiskScape as a for loop or a list comprehension.
For convenience, the iterable argument does not have to be a list type. You can pass map() a single item and the foreach lambda expression will be applied to the first argument directly. E.g. map(1, foreach: (x) -> x + 1) will simply return 2.
Treating both lists and single items as iterable makes pipeline code reusable for a variety of different modelling situations. For example, sampling the hazard-layer can result in either a single hazard intensity value or a list of values, depending on the function used.
zip
Arguments: [lhs: List[Nullable[Anything]], rhs: List[Nullable[Anything]], lambda: λ(lhs_element,rhs_element)]
Returns: List[Nullable[Anything]]
Produces a new list by calling lamba with the nth elements from each input list, until the shortest input list is exhausted. For example the lamba expression (l1, l2) -> l1 + l2 would result in a list containing the sum of nth elements of each input list.
length
Arguments: [list: List[Nullable[Anything]]]
Returns: Integer
Returns the number of items in the list.
range
Arguments: [start: Integer, stop: Integer]
Returns: List[Integer]
Returns a list of integers that increase in value from start (inclusive) to stop (exclusive).
aggregate_struct
Arguments: [items: List[Nullable[Anything]], aggregation: Anything]
Returns: Nullable[Anything]
Aggregate function for applying aggregate functions to one of more members of a struct, e.g. group(struct_aggregate(loss, {max_damage: v -> max(v.damage)}), by: region) will apply max aggregation to the damage attribute of the loss type. Can also be used in a normal expression to aggregate values from tuples in a list.
null_of
Arguments: [typedef: Text]
Returns: Nullable[Anything]
Advanced function, useful for testing scenarios, for setting a null value of a specific type. For example, null_of('text') returns an expression that always evaluates to null but is still typed as text.
merge
Arguments: [original: Anything, replace: Anything]
Returns: {}
Merge two structs to produce a new struct. Members of replace take precedence over the original. This method is not recursive - that is, any nested structs that share the same attribute name will not be merged, one will win and the other will be replaced completely.
call
Arguments: [scope: {}, lambda: λ()]
Returns: Anything
Internal/Expert function for applying an expression to a specific scope, excluding any outer scope, contrary to how most RiskScape functions work. Useful for testing/debugging scenarios.
to_list
Arguments: [value: Anything]
Returns: List[Anything]
Aggregate function for combining all grouped elements in to a list.
Use with caution on large datasets, as this can lead to slow performance and memory issues.
Can also be used in a normal expressions to turn relational data into a list, e.g. to_list(bookmark('input_data.csv'))