!=(Any a, Any b) -> Bool
Returns true if the two value are not equal

%(Int a, Int b) -> Int
Returns the result of wrapping a around so that 0 <= res < b.  The modulus b must be 0 or negative.  Use Int::remainder if you want the remainder after division, which has a different behavior for negative numbers.

&&(Bool a, Bool b) -> Bool
Returns true if both a and b are true

*(Int a, Int b) -> Int
Multiplies two integers

+(Int a, Int b) -> Int
Adds two integers together

++(Str s1, Str s2) -> Str
Concatenates the two strings by appending s2 to s1 and returns the joined string.

-(Int a, Int b) -> Int
Subtracts two integers

/(Float a, Float b) -> Float
Divide float a by float b

<(Int a, Int b) -> Bool
Returns true if a is less than b

<=(Int a, Int b) -> Bool
Returns true if a is less than or equal to b

==(Any a, Any b) -> Bool
Returns true if the two value are equal

>(Int a, Int b) -> Bool
Returns true if a is greater than b

>=(Int a, Int b) -> Bool
Returns true if a is greater than or equal to b

AWS::urlencode(Str str) -> Str
Url encode a string per AWS' requirements

Bool::and(Bool a, Bool b) -> Bool
Returns true if both a and b are true

Bool::isNull(Any check) -> Bool
Returns true if the check parameter is null

Bool::not(Bool b) -> Bool
Returns the inverse of b: true if b is false and false if b is true

Bool::or(Bool a, Bool b) -> Bool
Returns true if either a is true or b is true

Bool::xor(Bool a, Bool b) -> Bool
Returns true if exactly one of a and b is trueReturns false if both are true or neither is true.

Bytes::base64Encode(Bytes bytes) -> Str
Base64URL encodes bytes with = padding. Uses URL-safe encoding with - and _ instead of + and /, as defined in RFC 4648 section 5.

Bytes::hexEncode(Bytes bytes) -> Str
Hex (Base16) encodes bytes using an uppercase alphabet. Complies with RFC 4648 section 8.

Bytes::length(Bytes bytes) -> Int
Length of encoded byte string

Crypto::md5(Bytes data) -> Bytes
Computes the md5 digest of the given data. NOTE: There are multiple security problems with md5, see https://en.wikipedia.org/wiki/MD5#Security

Crypto::sha1hmac(Bytes key, Bytes data) -> Bytes
Computes the SHA1-HMAC (hash-based message authentication code) digest of the given key and data.

Crypto::sha256(Bytes data) -> Bytes
Computes the SHA-256 digest of the given data.

Crypto::sha256hmac(Bytes key, Bytes data) -> Bytes
Computes the SHA-256 HMAC (hash-based message authentication code) digest of the given key and data.

Crypto::sha384(Bytes data) -> Bytes
Computes the SHA-384 digest of the given data.

DB::count(Datastore table) -> Int
Return the number of items stored in table.

DB::deleteAll_v1(Datastore table) -> Nothing
Delete everything from table

DB::delete_v1(Str key, Datastore table) -> Nothing
Delete key from table

DB::generateKey() -> Str
Returns a random key suitable for use as a DB key

DB::getAllWithKeys_v2(Datastore table) -> Dict
Fetch all the values in tableReturns an object with key: value. ie. {key : value, key2: value2}

DB::getAll_v3(Datastore table) -> List
Fetch all the values in table.

DB::getExisting(List keys, Datastore table) -> List
Finds many values in table by keys (ignoring any missing items), returning a [value] list of values

DB::getManyWithKeys_v1(List keys, Datastore table) -> Dict
Finds many values in table by keys, returning a {key:{value}, key2: {value2 object of keys and values

DB::getMany_v3(List keys, Datastore table) -> Option
Finds many values in table by keys. If all keys are found, returns Just a list of [values], otherwise returns Nothing (to ignore missing keys, use DB::getExisting)

DB::get_v2(Str key, Datastore table) -> Option
Finds a value in table by key

DB::keys_v1(Datastore table) -> List
Fetch all the keys of entries in tableReturns an list with strings

DB::queryCount(Datastore table, Block filter) -> Int
Return the number of items from table for which filter returns true. Note that this does not check every value in table, but rather is optimized to find data with indexes. Errors at compile-time if Dark's compiler does not support the code in question.

DB::queryExactFields(Dict spec, Datastore table) -> List
Fetch all the values from table which have the same fields and values that spec has, returning a list of values. Previously called DB::query_v3

DB::queryExactFieldsWithKey(Dict spec, Datastore table) -> Dict
Fetch all the values from table which have the same fields and values that spec has  , returning {key : value} as an object. Previous called DB::queryWithKey_v2

DB::queryOneWithExactFields(Dict spec, Datastore table) -> Option
Fetch exactly one value from table which have the same fields and values that spec has. If there is exactly one value, it returns Just value and if there is none or more than 1 found, it returns Nothing. Previously called DB::queryOne_v2

DB::queryOneWithExactFieldsWithKey(Dict spec, Datastore table) -> Option
Fetch exactly one value from table which have the same fields and values that spec has. If there is exactly one key/value pair, it returns Just {key: value} and if there is none or more than 1 found, it returns Nothing. Previously called DB::queryOnewithKey_v2

DB::queryOneWithKey_v3(Datastore table, Block filter) -> Option
Fetch exactly one value from table for which filter returns true. Note that this does not check every value in table, but rather is optimized to find data with indexes. If there is exactly one key/value pair, it returns Just {key: value} and if there is none or more than 1 found, it returns Nothing. Errors at compile-time if Dark's compiler does not support the code in question.

DB::queryOne_v4(Datastore table, Block filter) -> Option
Fetch exactly one value from table for which filter returns true. Note that this does not check every value in table, but rather is optimized to find data with indexes. If there is exactly one value, it returns Just value and if there is none or more than 1 found, it returns Nothing. Errors at compile-time if Dark's compiler does not support the code in question.

DB::queryWithKey_v3(Datastore table, Block filter) -> Dict
Fetch all the values from table for which filter returns true, returning {key : value} as an object. Note that this does not check every value in table, but rather is optimized to find data with indexes. Errors at compile-time if Dark's compiler does not support the code in question.

DB::query_v4(Datastore table, Block filter) -> List
Fetch all the values from table for which filter returns true. Note that this does not check every value in table, but rather is optimized to find data with indexes. Errors at compile-time if Dark's compiler does not support the code in question.

DB::schemaFields_v1(Datastore table) -> List
Fetch all the fieldNames in table

DB::schema_v1(Datastore table) -> Dict
Returns an Obj representing { fieldName: fieldType } in table

DB::set_v1(Dict val, Str key, Datastore table) -> Dict
Upsert val into table, accessible by key

Date::<(Date d1, Date d2) -> Bool
Returns whether d1 <  d2

Date::<=(Date d1, Date d2) -> Bool
Returns whether d1 <=  d2

Date::>(Date d1, Date d2) -> Bool
Returns whether d1   d2

Date::>=(Date d1, Date d2) -> Bool
Returns whether d1  d2

Date::add(Date d, Int seconds) -> Date
Returns a new Date seconds seconds after d

Date::atStartOfDay(Date date) -> Date
Returns the Date with the time set to midnight

Date::day(Date date) -> Int
Returns the day portion of the Date as an int

Date::fromSeconds(Int seconds) -> Date
Converts an integer representing seconds since the Unix epoch into a Date

Date::greaterThan(Date d1, Date d2) -> Bool
Returns whether d1   d2

Date::greaterThanOrEqualTo(Date d1, Date d2) -> Bool
Returns whether d1  d2

Date::hour_v1(Date date) -> Int
Returns the hour portion of the Date as an int

Date::lessThan(Date d1, Date d2) -> Bool
Returns whether d1 <  d2

Date::lessThanOrEqualTo(Date d1, Date d2) -> Bool
Returns whether d1 <=  d2

Date::minute(Date date) -> Int
Returns the minute portion of the Date as an int

Date::month(Date date) -> Int
Returns the month portion of the Date as an int between 1 and 12

Date::now() -> Date
Returns the current time.

Date::parse_v2(Str s) -> Result
Parses a string representing a date and time in the ISO 8601 format (for example: 2019-09-07T22:44:25Z) and returns the Date wrapped in a Result.

Date::second(Date date) -> Int
Returns the second portion of the Date as an int

Date::subtract(Date d, Int seconds) -> Date
Returns a new Date seconds seconds before d

Date::toSeconds(Date date) -> Int
Converts a Date date to an integer representing seconds since the Unix epoch

Date::toString(Date date) -> Str
Stringify date to the ISO 8601 format YYYY-MM-DD'T'hh:mm:ss'Z'

Date::toStringISO8601BasicDate(Date date) -> Str
Stringify date to the ISO 8601 basic format YYYYMMDD

Date::toStringISO8601BasicDateTime(Date date) -> Str
Stringify date to the ISO 8601 basic format YYYYMMDD'T'hhmmss'Z'

Date::today() -> Date
Returns the Date with the time set to midnight

Date::weekday(Date date) -> Int
Returns the weekday of date as an int. Monday = 1, Tuesday = 2, ... Sunday = 7 (in accordance with ISO 8601).

Date::year(Date date) -> Int
Returns the year portion of the Date as an int

Dict::empty() -> Dict
Returns an empty dictionary.

Dict::filterMap(Dict dict, Block f) -> Dict
Calls f on every entry in dict, returning a new dictionary that drops some entries (filter) and transforms others (map).  If f key value returns Nothing, does not add key or value to the new dictionary, dropping the entry.  If f key value returns Just newValue, adds the entry keynewValue to the new dictionary.  This function combines Dict::filter and Dict::map.

Dict::filter_v1(Dict dict, Block f) -> Dict
Evaluates f key value on every entry in dictReturns a new dictionary that contains only the entries of dict for which f returned true.

Dict::fromList(List entries) -> Option
Each value in entries must be a [key, value] list, where key is a String.  If entries contains no duplicate keys, returns Just dict where dict has entries.  Otherwise, returns Nothing (use Dict::fromListOverwritingDuplicates if you want to overwrite duplicate keys).

Dict::fromListOverwritingDuplicates(List entries) -> Dict
Returns a new dict with entries. Each value in entries must be a [key, value] list, where key is a String.  If entries contains duplicate keys, the last entry with that key will be used in the resulting dictionary (use Dict::fromList if you want to enforce unique keys).  This function is the opposite of Dict::toList.

Dict::get_v2(Dict dict, Str key) -> Option
If the dict contains key, returns the corresponding value, wrapped in an option: Just value. Otherwise, returns Nothing.

Dict::isEmpty(Dict dict) -> Bool
Returns true if the dict contains no entries.

Dict::keys(Dict dict) -> List
Returns dict's keys in a list, in an arbitrary order.

Dict::map(Dict dict, Block f) -> Dict
Returns a new dictionary that contains the same keys as the original dict with values that have been transformed by f, which operates on each key-value pair.  Consider Dict::filterMap if you also want to drop some of the entries.

Dict::member(Dict dict, Str key) -> Bool
Returns true if the dict contains an entry with key, and false otherwise.

Dict::merge(Dict left, Dict right) -> Dict
Returns a combined dictionary with both dictionaries' entries. If the same key exists in both left and right, it will have the value from right.

Dict::remove(Dict dict, Str key) -> Dict
If the dict contains key, returns a copy of dict with key and its associated value removed. Otherwise, returns dict unchanged.

Dict::set(Dict dict, Str key, Any val) -> Dict
Returns a copy of dict with the key set to val.

Dict::singleton(Str key, Any value) -> Dict
Returns a new dictionary with a single entry keyvalue.

Dict::size(Dict dict) -> Int
Returns the number of entries in dict (the number of key-value pairs).

Dict::toJSON(Dict dict) -> Str
Returns dict as a JSON string.

Dict::toList(Dict dict) -> List
Returns dict's entries as a list of [key, value] lists, in an arbitrary order. This function is the opposite of Dict::fromList.

Dict::values(Dict dict) -> List
Returns dict's values in a list, in an arbitrary order.

Float::absoluteValue(Float a) -> Float
Returns the absolute value of a (turning negative inputs into positive outputs).

Float::add(Float a, Float b) -> Float
Add float a to float b

Float::ceiling(Float a) -> Int
Round up to an integer value

Float::clamp(Float value, Float limitA, Float limitB) -> Float
If value is within the range given by limitA and limitB, returns value.  If value is outside the range, returns limitA or limitB, whichever is closer to value.  limitA and limitB can be provided in any order.

Float::divide(Float a, Float b) -> Float
Divide float a by float b

Float::floor(Float a) -> Int
Round down to an integer value. Consider Float::truncate if your goal is to discard the fractional part of a number: Float::floor -1.9 == -2.0 but Float::truncate -1.9 == -1.0.

Float::greaterThan(Float a, Float b) -> Bool
Returns true if a is greater than b

Float::greaterThanOrEqualTo(Float a, Float b) -> Bool
Returns true if a is greater than b

Float::lessThan(Float a, Float b) -> Bool
Returns true if a is less than b

Float::lessThanOrEqualTo(Float a, Float b) -> Bool
Returns true if a is less than b

Float::max(Float a, Float b) -> Float
Returns the greater of float a and float b

Float::min(Float a, Float b) -> Float
Returns the lesser of float a and float b

Float::multiply(Float a, Float b) -> Float
Multiply float a by float b

Float::negate(Float a) -> Float
Returns the negation of a-a.

Float::power(Float base, Float exponent) -> Float
Returns base raised to the power of exponent

Float::round(Float a) -> Int
Round to the nearest integer value

Float::roundDown(Float a) -> Int
Round down to an integer value. Consider Float::truncate if your goal is to discard the fractional part of a number: Float::floor -1.9 == -2.0 but Float::truncate -1.9 == -1.0.

Float::roundTowardsZero(Float a) -> Int
Discard the fractional portion of the float, rounding towards zero.

Float::roundUp(Float a) -> Int
Round up to an integer value

Float::sqrt(Float a) -> Float
Get the square root of a float

Float::subtract(Float a, Float b) -> Float
Subtract float b from float a

Float::sum(List a) -> Float
Returns the sum of all the floats in the list

Float::truncate(Float a) -> Int
Discard the fractional portion of the float, rounding towards zero.

Http::badRequest(Str error) -> Response
Returns a Response that can be returned from an HTTP handler to respond with a 400 status and string error message.

Http::forbidden() -> Response
Returns a Response that can be returned from an HTTP handler to respond with 403 Forbidden.

Http::notFound() -> Response
Returns a Response that can be returned from an HTTP handler to respond with 404 Not Found.

Http::redirectTo(Str url) -> Response
Returns a Response that can be returned from an HTTP handler to respond with a 302 redirect to url.

Http::response(Any response, Int code) -> Response
Returns a Response that can be returned from an HTTP handler to respond with HTTP status code and response body.

Http::responseWithHeaders(Any response, Dict headers, Int code) -> Response
Returns a Response that can be returned from an HTTP handler to respond with HTTP status coderesponse body, and headers.

Http::responseWithHtml(Any response, Int code) -> Response
Returns a Response that can be returned from an HTTP handler to respond with HTTP status code and response body, with content-type set to "text/html".

Http::responseWithJson(Any response, Int code) -> Response
Returns a Response that can be returned from an HTTP handler to respond with HTTP status code and response body, with content-type set to "application/json"

Http::responseWithText(Any response, Int code) -> Response
Returns a Response that can be returned from an HTTP handler to respond with HTTP status code and response body, with content-type set to "text/plain".

Http::setCookie_v2(Str name, Str value, Dict params) -> Dict
Returns an HTTP Set-Cookie header  suitable for use with , given a cookie name, a  value for it, and a  of Set-Cookie params ({{ExpiresMax-AgeDomainPathSecureHttpOnly, and/or SameSite).

Http::success(Any response) -> Response
Returns a Response that can be returned from an HTTP handler to respond with HTTP status 200 and response body.

Http::unauthorized() -> Response
Returns a Response that can be returned from an HTTP handler to respond with 401 Unauthorized.

HttpClient::basicAuth_v1(Str username, Str password) -> Dict
Returns an object with 'Authorization' created using HTTP basic auth

HttpClient::bearerToken_v1(Str token) -> Dict
Returns an object with 'Authorization' set to the passed token

HttpClient::delete_v5(Str uri, Dict query, Dict headers) -> Result
Make blocking HTTP DELETE call to uriReturns a Result object where the response object is wrapped in Ok if the status code is in the 2xx range, and is wrapped in Error otherwise. Parsing errors/UTF-8 decoding errors are also Error wrapped response objects, with a message in the body and/or raw fields

HttpClient::formContentType() -> Dict
Returns an object with 'Content-Type' for url-encoded HTML forms

HttpClient::get_v5(Str uri, Dict query, Dict headers) -> Result
Make blocking HTTP GET call to uriReturns a Result object where the response object is wrapped in Ok if the status code is in the 2xx range, and is wrapped in Error otherwise. Parsing errors/UTF-8 decoding errors are also Error wrapped response objects, with a message in the body and/or raw fields

HttpClient::head_v5(Str uri, Dict query, Dict headers) -> Result
Make blocking HTTP HEAD call to uriReturns a Result object where the response object is wrapped in Ok if the status code is in the 2xx range, and is wrapped in Error otherwise. Parsing errors/UTF-8 decoding errors are also Error wrapped response objects, with a message in the body and/or raw fields

HttpClient::htmlContentType() -> Dict
Returns an object with 'Content-Type' for html

HttpClient::jsonContentType() -> Dict
Returns an object with 'Content-Type' for JSON

HttpClient::options_v5(Str uri, Dict query, Dict headers) -> Result
Make blocking HTTP OPTIONS call to uriReturns a Result object where the response object is wrapped in Ok if the status code is in the 2xx range, and is wrapped in Error otherwise. Parsing errors/UTF-8 decoding errors are also Error wrapped response objects, with a message in the body and/or raw fields

HttpClient::patch_v5(Str uri, Any body, Dict query, Dict headers) -> Result
Make blocking HTTP PATCH call to uriReturns a Result object where the response object is wrapped in Ok if the status code is in the 2xx range, and is wrapped in Error otherwise. Parsing errors/UTF-8 decoding errors are also Error wrapped response objects, with a message in the body and/or raw fields

HttpClient::plainTextContentType() -> Dict
Returns an object with 'Content-Type' for plain text

HttpClient::post_v5(Str uri, Any body, Dict query, Dict headers) -> Result
Make blocking HTTP POST call to uriReturns a Result object where the response object is wrapped in Ok if the status code is in the 2xx range, and is wrapped in Error otherwise. Parsing errors/UTF-8 decoding errors are also Error wrapped response objects, with a message in the body and/or raw fields

HttpClient::put_v5(Str uri, Any body, Dict query, Dict headers) -> Result
Make blocking HTTP PUT call to uriReturns a Result object where the response object is wrapped in Ok if the status code is in the 2xx range, and is wrapped in Error otherwise. Parsing errors/UTF-8 decoding errors are also Error wrapped response objects, with a message in the body and/or raw fields

Int::absoluteValue(Int a) -> Int
Returns the absolute value of a (turning negative inputs into positive outputs).

Int::add(Int a, Int b) -> Int
Adds two integers together

Int::clamp(Int value, Int limitA, Int limitB) -> Int
If value is within the range given by limitA and limitB, returns value.  If value is outside the range, returns limitA or limitB, whichever is closer to value.  limitA and limitB can be provided in any order.

Int::divide(Int a, Int b) -> Int
Divides two integers

Int::greaterThan(Int a, Int b) -> Bool
Returns true if a is greater than b

Int::greaterThanOrEqualTo(Int a, Int b) -> Bool
Returns true if a is greater than or equal to b

Int::lessThan(Int a, Int b) -> Bool
Returns true if a is less than b

Int::lessThanOrEqualTo(Int a, Int b) -> Bool
Returns true if a is less than or equal to b

Int::max(Int a, Int b) -> Int
Returns the higher of a and b

Int::min(Int a, Int b) -> Int
Returns the lower of a and b

Int::mod(Int a, Int b) -> Int
Returns the result of wrapping a around so that 0 <= res < b.  The modulus b must be 0 or negative.  Use Int::remainder if you want the remainder after division, which has a different behavior for negative numbers.

Int::multiply(Int a, Int b) -> Int
Multiplies two integers

Int::negate(Int a) -> Int
Returns the negation of a-a.

Int::power(Int base, Int exponent) -> Int
Raise base to the power of exponent

Int::random_v1(Int start, Int end) -> Int
Returns a random integer between start and end (inclusive).

Int::remainder(Int value, Int divisor) -> Result
Returns the integer remainder left over after dividing value by divisor, as a Result.  For example, Int::remainder 15 6 == Ok 3. The remainder will be negative only if value < 0.  The sign of divisor doesn't influence the outcome.  Returns an Error if divisor is 0.

Int::sqrt(Int a) -> Float
Get the square root of an Int

Int::subtract(Int a, Int b) -> Int
Subtracts two integers

Int::sum(List a) -> Int
Returns the sum of all the ints in the list

Int::toFloat(Int a) -> Float
Converts an Int to a Float

JSON::parse_v1(Str json) -> Result
Parses a json string and returns its value. HTTPClient functions, and our request handler, automatically parse JSON into the body and jsonbody fields, so you probably won't need this. However, if you need to consume bad JSON, you can use string functions to fix the JSON and then use this function to parse it.

JWT::signAndEncodeWithHeaders_v1(Str pemPrivKey, Dict headers, Any payload) -> Result
Sign and encode an rfc751J9 JSON Web Token, using the RS256 algorithm, with an extra header map. Takes an unecnrypted RSA private key in PEM format.

JWT::signAndEncode_v1(Str pemPrivKey, Any payload) -> Result
Sign and encode an rfc751J9 JSON Web Token, using the RS256 algorithm. Takes an unecnrypted RSA private key in PEM format.

JWT::verifyAndExtract_v1(Str pemPubKey, Str token) -> Result
Verify and extra the payload and headers from an rfc751J9 JSON Web Token that uses the RS256 algorithm. Takes an unencrypted RSA public key in PEM format.

List::append(List as, List bs) -> List
Returns a new list with all values in as followed by all values in bs, preserving the order.

List::drop(List list, Int count) -> List
Drops the first count values from list.

List::dropWhile(List list, Block f) -> List
Drops the longest prefix of list which satisfies the predicate val

List::empty() -> List
Returns an empty list.

List::filterMap(List list, Block f) -> List
Calls f on every val in list, returning a new list that drops some values (filter) and transforms others (map).  If f val returns Nothing, drops val from the list.  If f val returns Just newValue, replaces val with newValue.  Preserves the order of values that were not dropped.  This function combines List::filter and List::map.

List::filter_v2(List list, Block f) -> List
Calls f on every val in list, returning a list of only those values for which f val returns true.  Preserves the order of values that were not dropped.  Consider List::filterMap if you also want to transform the values.

List::findFirst_v2(List list, Block f) -> Option
Returns Just firstMatch where firstMatch is the first value of the list for which f returns trueReturns Nothing if no such value exists.

List::flatten(List list) -> List
Returns a single list containing the values of every list directly in list (does not recursively flatten nested lists).

List::fold(List list, Any init, Block f) -> Any
Folds list into a single value, by repeatedly applying f to any two pairs.

List::getAt_v1(List list, Int index) -> Option
Returns Just value at index in list if index is less than the length of the list otherwise returns Nothing.

List::head_v2(List list) -> Option
Returns Just the head (first value) of a list. Returns Nothing if the list is empty.

List::indexedMap(List list, Block f) -> List
Calls f on every val and its index in list, returning a list of the results of those calls.  Consider List::map if you don't need the index.

List::interleave(List as, List bs) -> List
Returns a new list with the first value from as then the first value from bs, then the second value from as then the second value from bs, etc, until one list ends, then the remaining items from the other list.

List::interpose(List list, Any sep) -> List
Returns a single list containing the values of list separated by sep.

List::isEmpty(List list) -> Bool
Returns true if list has no values.

List::last_v2(List list) -> Option
Returns the last value in list, wrapped in an option (Nothing if the list is empty).

List::length(List list) -> Int
Returns the number of values in list.

List::map(List list, Block f) -> List
Calls f on every val in list, returning a list of the results of those calls.  Consider List::filterMap if you also want to drop some of the values.

List::map2(List as, List bs, Block f) -> Option
If the lists are the same length, returns Just list formed by mapping f over as and bs in parallel,  calling f a b on every pair of values from as and bs.  For example, if as is [1,2,3] and bs is ["x","y","z"], returns [(f 1 "x"), (f 2 "y"), (f 3 "z")].  If the lists differ in length, returns Nothing (consider List::map2shortest if you want to drop values from the longer list instead).

List::map2shortest(List as, List bs, Block f) -> List
Maps f over as and bs in parallel, calling f a b on every pair of values from as and bs.  If the lists differ in length, values from the longer list are dropped.  For example, if as is [1,2] and bs is ["x","y","z"], returns [(f 1 "x"), (f 2 "y")].  Use List::map2 if you want to enforce equivalent lengths for as and bs.

List::member(List list, Any val) -> Bool
Returns true if val is in the list.

List::push(List list, Any val) -> List
Add element val to front of list list

List::pushBack(List list, Any val) -> List
Add element val to back of list list

List::randomElement(List list) -> Option
Returns Just randomValue, where randomValue is a randomly selected value in listReturns Nothing if list is empty.

List::range(Int lowest, Int highest) -> List
Returns a list of numbers where each element is 1 larger than the previous. You provide the lowest and highest numbers in the list. If lowest is greater than highest, returns the empty list.

List::repeat(Int times, Any val) -> List
Returns a new list containing val repeated times times.

List::reverse(List list) -> List
Returns a reversed copy of list.

List::singleton(Any val) -> List
Returns a one-element list containing the given val.

List::sort(List list) -> List
Returns a copy of list with every value sorted in ascending order. Use this if the values have types Dark knows how to sort.  Consider List::sortBy or List::sortByComparator if you need more control over the sorting process.

List::sortBy(List list, Block f) -> List
Returns a copy of list, sorted in ascending order, as if each value evaluated to f val.  For example, List::sortBy ["x","jkl","ab"] \val - String::length val returns [ "x", "ab", "jkl" ].  Consider List::sort if the list values can be directly compared, or List::sortByComparator if you want more control over the sorting process.

List::sortByComparator(List list, Block f) -> Result
Returns a copy of list, sorted using f a b to compare values a and b.  f must return -1 if a should appear before b1 if a should appear after b, and 0 if the order of a and b doesn't matter.  Consider List::sort or List::sortBy if you don't need this level of control.

List::tail(List list) -> Option
If the list contains at least one value, returns Just a list of every value other than the first. Otherwise, returns Nothing.

List::take(List list, Int count) -> List
Drops all but the first count values from list.

List::takeWhile(List list, Block f) -> List
Return the longest prefix of list which satisfies the predicate val

List::uniqueBy(List list, Block f) -> List
Returns the passed list, with only unique values, where uniqueness is based on the result of f. Only one of each value will be returned, but the order will not be maintained.

List::unzip(List pairs) -> List
Given a pairs list where each value is a list of two values (such lists are constructed by List::zip and List::zipShortest), returns a list of two lists,  one with every first value, and one with every second value. For example, if pairs is [[1,"x"], [2,"y"], [3,"z"]], returns [[1,2,3], ["x","y","z"]].

List::zip(List as, List bs) -> Option
If the lists have the same length, returns Just list formed from parallel pairs in as and bs.  For example, if as is [1,2,3] and bs is ["x","y","z"], returns [[1,"x"], [2,"y"], [3,"z"]].  See List::unzip if you want to deconstruct list into as and bs again.  If the lists differ in length, returns Nothing (consider List::zipShortest if you want to drop values from the longer list instead).

List::zipShortest(List as, List bs) -> List
Returns a list of parallel pairs from as and bs.  If the lists differ in length, values from the longer list are dropped.  For example, if as is [1,2] and bs is ["x","y","z"], returns [[1,"x"], [2,"y"]].  Use List::zip if you want to enforce equivalent lengths for as and bs.  See List::unzip if you want to deconstruct the result into as and bs again.

Math::acos(Float ratio) -> Option
Returns the arc cosine of ratio, as an Option.  If ratio is in the inclusive range [-1.0, 1.0], returns  Just result where result is in radians and is between 0.0 and Math::pi. Otherwise, returns Nothing.  This function is the inverse of Math::cos.

Math::asin(Float ratio) -> Option
Returns the arc sine of ratio, as an Option.  If ratio is in the inclusive range [-1.0, 1.0], returns  Just result where result is in radians and is between -Math::pi/2 and Math::pi/2. Otherwise, returns Nothing.  This function is the inverse of Math::sin.

Math::atan(Float ratio) -> Float
Returns the arc tangent of ratio. The result is in radians and is between -Math::pi/2 and Math::pi/2.  This function is the inverse of Math::tan. Use Math::atan2 to expand the output range, if you know the numerator and denominator of ratio.

Math::atan2(Float y, Float x) -> Float
Returns the arc tangent of y / x, using the signs of y and x to determine the quadrant of the result.  The result is in radians and is between -Math::pi and Math::pi. Consider Math::atan if you know the value of y / x but not the individual values x and y.

Math::cos(Float angleInRadians) -> Float
Returns the cosine of the given angleInRadians.  One interpretation of the result relates to a right triangle: the cosine is the ratio of the lengths of the side adjacent to the angle and the hypotenuse.

Math::cosh(Float angleInRadians) -> Float
Returns the hyperbolic cosine of angleInRadians.

Math::degrees(Float angleInDegrees) -> Float
Returns the equivalent of angleInDegrees in radians, the unit used by all of Dark's trigonometry functions.  There are 360 degrees in a circle.

Math::pi() -> Float
Returns an approximation for the mathematical constant π, the ratio of a circle's circumference to its diameter.

Math::radians(Float angleInRadians) -> Float
Returns angleInRadians in radians, the unit used by all of Dark's trigonometry functions.  There are Float::multiply 2 Math::pi radians in a circle.

Math::sin(Float angleInRadians) -> Float
Returns the sine of the given angleInRadians.  One interpretation of the result relates to a right triangle: the sine is the ratio of the lengths of the side opposite the angle and the hypotenuse.

Math::sinh(Float angleInRadians) -> Float
Returns the hyperbolic sine of angleInRadians.

Math::tan(Float angleInRadians) -> Float
Returns the tangent of the given angleInRadians.  One interpretation of the result relates to a right triangle: the tangent is the ratio of the lengths of the side opposite the angle and the side adjacent to the angle.

Math::tanh(Float angleInRadians) -> Float
Returns the hyperbolic tangent of angleInRadians.

Math::tau() -> Float
Returns an approximation for the mathematical constant τ, the number of radians in one turn. Equivalent to Float::multiply Math::pi 2.

Math::turns(Float angleInTurns) -> Float
Returns the equivalent of angleInTurns in radians, the unit used by all of Dark's trigonometry functions.  There is 1 turn in a circle.

Option::andThen(Option option, Block f) -> Option
If option is Just input, returns input. Where the lambda f is applied to input and must return Just output or Nothing. Otherwise if option is Nothing, returns Nothing.

Option::map2(Option option1, Option option2, Block f) -> Option
If both arguments are Just (option1 is Just v1 and option2 is Just v2), then return Just (f v1 v2) -- The lambda f should have two parameters, representing v1 and v2. But if either option1 or option2 are Nothing, returns Nothing without applying f.

Option::map_v1(Option option, Block f) -> Option
If option is Just value, then return Just (f value). The lambda f applied to value and the result is wrapped in Just. Otherwise if the result is Nothing, then return Nothing.

Option::withDefault(Option option, Any default) -> Any
If option is Just value, returns valueReturns default otherwise.

Password::check(Password existingpwr, Str rawpw) -> Bool
Check whether a Password matches a raw password String safely. This uses libsodium's pwhash under the hood, which is based on argon2.  NOTE: This is not usable interactively, because we do not send Password values to the client for security reasons.

Password::hash(Str pw) -> Password
Hash a password into a Password by salting and hashing it. This uses libsodium's crypto_pwhash_str under the hood, which is based on argon2.  NOTE: This is not usable interactively, because we do not send Password values to the client for security reasons.

Result::andThen_v1(Result result, Block f) -> Result
If result is Ok value, returns value. The lambda f is applied to value and must return Error msg or Ok newValue. If result is Error msg, returns result unchanged.

Result::fromOption_v1(Option option, Str error) -> Result
Turn an option into a result, using error as the error message for Error. Specifically, if option is Just value, returns Ok valueReturns Error error otherwise.

Result::map2(Result result1, Result result2, Block f) -> Result
If both result1 is Ok v1 and result2 is Ok v2, returns Ok (f v1 v2) -- the lambda f is applied to v1 and v2, and the result is wrapped in Ok. Otherwise, returns the first of result1 and result2 that is an error.

Result::mapError_v1(Result result, Block f) -> Result
If result is Error msg, returns Error (f msg). The lambda f is applied to msg and the result is wrapped in Error. If result is Ok value, returns result unchanged.

Result::map_v1(Result result, Block f) -> Result
If result is Ok value, returns Ok (f value). The lambda f is applied to value and the result is wrapped in Ok. If result is Error msg, returns result unchanged.

Result::toOption_v1(Result result) -> Option
Turn a result into an option.

Result::withDefault(Result result, Any default) -> Any
If result is Ok value, returns valueReturns default otherwise.

StaticAssets::baseUrlFor(Str deploy_hash) -> Str
Return the baseUrl for the specified deploy hash

StaticAssets::baseUrlForLatest() -> Str
Return the baseUrl for the latest deploy

StaticAssets::fetchBytes(Str deploy_hash, Str file) -> Result
Return the bytes of the specified file from the deploy_hash

StaticAssets::fetchLatestBytes(Str file) -> Result
Return the bytes of the specified file from the latest deploy

StaticAssets::fetchLatest_v1(Str file) -> Result
Return the specified file from the latest deploy - only works on UTF8-safe files for now

StaticAssets::fetch_v1(Str deploy_hash, Str file) -> Result
Return the specified file from the deploy_hash - only works on UTF8-safe files for now

StaticAssets::serveLatest_v1(Str file) -> Result
Return the specified file from the latest deploy

StaticAssets::serve_v1(Str deploy_hash, Str file) -> Result
Return the specified file from the latest deploy

StaticAssets::urlFor(Str deploy_hash, Str file) -> Str
Return a url for the specified file and deploy hash

StaticAssets::urlForLatest(Str file) -> Str
Return a url for the specified file and latest deploy

String::append_v1(Str s1, Str s2) -> Str
Concatenates the two strings by appending s2 to s1 and returns the joined string.

String::base64Decode(Str s) -> Str
Base64 decodes a string. Works with both the URL-safe and standard Base64 alphabets defined in RFC 4648 sections 4 and 5.

String::base64Encode(Str s) -> Str
URLBase64 encodes a string without padding. Uses URL-safe encoding with - and _ instead of + and /, as defined in RFC 4648 section 5.

String::contains(Str lookingIn, Str searchingFor) -> Bool
Checks if lookingIn contains searchingFor

String::digest(Str s) -> Str
Take a string and hash it to a cryptographically-secure digest.  Don't rely on either the size or the algorithm.

String::dropFirst(Str string, Int characterCount) -> Str
Returns all but the first characterCount characters of string, as a String.  If characterCount is longer than string, returns the empty string.  If characterCount is negative, returns string.

String::dropLast(Str string, Int characterCount) -> Str
Returns all but the last characterCount characters of string, as a String.  If characterCount is longer than string, returns the empty string.  If characterCount is negative, returns string.

String::endsWith(Str subject, Str suffix) -> Bool
Checks if subject ends with suffix

String::first(Str string, Int characterCount) -> Str
Returns the first characterCount characters of string, as a String.  If characterCount is longer than string, returns string.  If characterCount is negative, returns the empty string.

String::foreach_v1(Str s, Block f) -> Str
Iterate over each Character (EGC, not byte) in the string, performing the operation in the block on each one.

String::fromChar_v1(Character c) -> Str
Converts a char to a string

String::fromList_v1(List l) -> Str
Returns the list of characters as a string

String::htmlEscape(Str html) -> Str
Escape an untrusted string in order to include it safely in HTML output.

String::isEmpty(Str s) -> Bool
Returns true if s is the empty string "".

String::join(List l, Str separator) -> Str
Combines a list of strings with the provided separator

String::last(Str string, Int characterCount) -> Str
Returns the last characterCount characters of string, as a String.  If characterCount is longer than string, returns string.  If characterCount is negative, returns the empty string.

String::length_v1(Str s) -> Int
Returns the length of the string

String::newline() -> Str
Returns a string containing a single ' '

String::padEnd(Str string, Str padWith, Int goalLength) -> Str
If string is shorter than goalLength characters, returns a copy of string ending with enough copies of padWith for the result have goalLength.  If the string is longer than goalLength, returns an unchanged copy of string.

String::padStart(Str string, Str padWith, Int goalLength) -> Str
If string is shorter than goalLength characters, returns a copy of string starting with enough copies of padWith for the result have goalLength.  If the string is longer than goalLength, returns an unchanged copy of string.

String::prepend(Str s1, Str s2) -> Str
Concatenates the two strings by prepending s2 to s1 and returns the joined string.

String::random_v2(Int length) -> Result
Generate a string of length length from random characters.

String::replaceAll(Str s, Str searchFor, Str replaceWith) -> Str
Replace all instances on searchFor in s with replaceWith

String::reverse(Str string) -> Str
Reverses string

String::slice(Str string, Int from, Int to) -> Str
Returns the substring of string between the from and to indices.  Negative indices start counting from the end of string.  Indices represent characters.

String::slugify_v2(Str string) -> Str
Turns a string into a prettified slug, including only lowercased alphanumeric characters, joined by hyphens

String::split(Str s, Str separator) -> List
Splits a string at the separator, returning a list of strings without the separator. If the separator is not present, returns a list containing only the initial string.

String::startsWith(Str subject, Str prefix) -> Bool
Checks if subject starts with prefix

String::toBytes(Str str) -> Bytes
Converts the given unicode string to a utf8-encoded byte sequence.

String::toFloat_v1(Str s) -> Result
Returns the float value of the string

String::toInt_v1(Str s) -> Result
Returns the int value of the string, wrapped in a Ok, or Error  if the string contains characters other than numeric digits

String::toList_v1(Str s) -> List
Returns the list of Characters (EGC, not byte) in the string

String::toLowercase_v1(Str s) -> Str
Returns the string, lowercased

String::toUUID_v1(Str uuid) -> Result
Parse a UUID of form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX from the input uuid string

String::toUppercase_v1(Str s) -> Str
Returns the string, uppercased

String::trim(Str str) -> Str
Returns a copy of str with all leading and trailing whitespace removed. 'whitespace' here means all Unicode characters with the White_Space property, which includes " ", "\t" and "\n".

String::trimEnd(Str str) -> Str
Returns a copy of str with all trailing whitespace removed. 'whitespace' here means all Unicode characters with the White_Space property, which includes " ", "\t" and "\n".

String::trimStart(Str str) -> Str
Returns a copy of str with all leading whitespace removed. 'whitespace' here means all Unicode characters with the White_Space property, which includes " ", "\t" and "\n".

Twilio::sendText_v1(Str accountSID, Str authToken, Str fromNumber, Str toNumber, Str body) -> Dict
Send text with body to phone number toNumber from number fromNumber, authenticated via accountSID and authToken

Uuid::generate() -> UUID
Generate a new UUID v4 according to RFC 4122

X509::pemCertificatePublicKey(Str pemCert) -> Result
Extract the public key from a PEM encoded certificate and return the key in PEM format.

^(Int base, Int exponent) -> Int
Raise base to the power of exponent

emit_v1(Any event, Str Name) -> Any
Emit a event to the name worker

equals(Any a, Any b) -> Bool
Returns true if the two value are equal

notEquals(Any a, Any b) -> Bool
Returns true if the two value are not equal

toString(Any v) -> Str
Returns a string representation of v, suitable for displaying to a user. Redacts passwords.

||(Bool a, Bool b) -> Bool
Returns true if either a is true or b is true