Expression.Callbacks.Standard (expression v2.46.0)
The function callbacks for the standard function set available in FLOIP expressions.
This should be relatively swappable with another implementation.
The only requirement is the handle/3 function.
FLOIP functions are case insensitive. All functions in this callback module are implemented as lowercase names.
Some functions accept a variable amount of arguments. Elixir doesn't support variable arguments in functions.
If a function accepts a variable number of arguments the convention
is to call the <function_name>_vargs/2 callback where the context
is given as the first argument and the argument list as a second
argument.
Reserved names such as and, if, and or are suffixed with an
underscore.
Summary
Functions
Returns the absolute value of a number
Returns true if and only if all its arguments evaluate to true
Appends an item or a list of items to a given list.
Base64 decode an expression
Base64 encode an expression
Returns the character specified by a number
Chunk a list into a list of smaller lists.
Removes all non-printable characters from a text string
Returns a numeric code for the first character in a text string
Joins text strings into one text string
Return the number of entries in a list, string, or a map.
Defines a new date value
Calculates a new datetime based on the offset and unit provided.
Parses a UNIX time and returns a DateTime
Converts date stored in text to an actual date object and
formats it using strftime formatting.
Returns only the day of the month of a date (1 to 31)
Deletes an element from a map by the given key.
Moves a date by the given number of months
Return a list of all functions annotated with @expression_docs
Filters a list by returning a new list that contains only the
elements for which filter_fun is truthy.
Finds the first element in the list for which filter_fun is truthy.
Returns the first word in the given text - equivalent to WORD(text, 1)
Formats the given number in decimal format using a period and commas
Return true if a list contains all the provided items
Tests whether all the words are contained in text
Checks if the given text starts with any of the provided prefixes. The function performs a case-insensitive match.
Example 1:
Check whether the given text ends with any of the provided strings. The function performs a case-insensitive match.
Check whether the given text exactly matches any of the provided phrases. The function performs a case-insensitive exact match.
Return true if a list contains any of the provided items
Check whether the given text contains any of the provided strings. The function performs a case-insensitive exact match. The second argument expects either a list of strings or a single string with comma-separated phrases.
Tests whether any of the words are contained in the text
Tests whether text starts with beginning
Tests whether expression contains a date formatted according to our environment
Tests whether expression is a date equal to date_string
Tests whether expression is a date after the date date_string
Tests whether expression contains a date before the date date_string
Tests whether an email is contained in text
Example 1:
Check whether the given text ends with the provided string. The function performs a case-insensitive match.
Returns whether the contact is part of group with the passed in UUID
Return true if a list has the given item as a member
Tests whether expression contains a number
Tests whether expression contains a number equal to the value
Tests whether expression contains a number greater than min
Tests whether expression contains a number greater than or equal to min
Tests whether expression contains a number less than max
Tests whether expression contains a number less than or equal to max
Tests whether the text contains only phrase
Returns whether two text values are equal (case sensitive). In the case that they are, it will return the text as the match.
Tests whether expression matches the regex pattern
Tests whether expresssion contains a phone number.
The optional country_code argument specifies the country to use for parsing.
Tests whether phrase is contained in expression
Tests whether there the expression has any characters in it
Tests whether expression contains a time.
Returns only the hour of a datetime (0 to 23)
Returns one value if the condition evaluates to true, and another value if it evaluates to false
Checks whether value is an error
Returns true if the argument is nil or an empty string
Returns true if the argument is a boolean.
Returns true if the argument is a number.
Returns true if the argument is a string.
Converts a data structure to JSON
Returns the first characters in a text string. This is Unicode safe.
Returns the number of characters in a text string, returns 0 if the string is null or empty
Converts a text string to lowercase
map over a list of items and apply the mapper function to every item, returning the result.
Returns the maximum value of all arguments
MID extracts part of a string, starting at a specified position and for a specified length.
Returns the minimum value of all arguments
Returns only the minute of a datetime (0 to 59)
Returns only the month of a date (1 to 12)
Returns false if the argument supplied evaluates to truth-y
Returns the current date time as UTC
Returns true if any argument is true.
Returns the first truthy value found or otherwise false.
Parse random dates and times with strftime patterns and return a DateTime value
when it matches.
Parses a string as JSON when given a String which is assumed to be JSON encoded.
Formats a number as a percentage
Returns the result of a number raised to a power - equivalent to the ^ operator
Capitalizes the first letter of every word in a text string
Generate a random number between min and max
Formats digits in text for reading in TTS
Reduces elements from a list by applying a function and collecting the results in an accumulator.
Capture values out of a string using a regex.
Returns the list of captures in a list.
Returns nil if there was nothing to match
Captures named values out of a string using a regex.
In contrast to regex_capture() this returns a map
where the keys are the names of the captures and the
values are the captured values.
Rejects elements from a list by returning a new list that contains only the
elements for which reject_fun is truthy.
Return the division remainder of two integers.
Removes the first word from the given text. The remaining text will be unchanged
Example 1:
Remove the last word from a list of words, using the specified separator
Repeats text a given number of times
Returns the last characters in a text string. This is Unicode safe.
Example 1:
The ROUND function rounds a number to a specified number of digits. For example, if cell A1 contains 23.7825, and you want to round that value to two decimal places you can do ROUND(23.7825, 2)
Returns only the second of a datetime (0 to 59)
Sorts a list of values using the result of the sorter function
Split a string into an array using the pattern as separator. Defaults to split the string using a space.
Substitutes new_text for old_text in a text string. If instance_num is given, then only that instance will be substituted
Returns the sum of all arguments, equivalent to the + operator
Example 1:
The SWITCH function evaluates one value (called the expression) against a list of values, and returns the result corresponding to the first matching value. If there is no match, an optional default value (the last one in the list if the list is odd) may be returned
Defines a time value which can be used for time arithmetic
Converts time stored in text to an actual time
Returns the current date
Returns the unicode character specified by a number
Returns a numeric code for the first character in a text string
Removes duplicate values from a list.
Converts a text string to uppercase
URL decode an expression
URL encode an expression
Returns the day of the week of a date (1 for Sunday to 7 for Saturday)
Wraps each item of the list in a new list with the item itself and its index in the original list.
Extracts the nth word from the given text string. If stop is a negative number,
then it is treated as count backwards from the end of the text. If by_spaces is
specified and is true then the function splits the text into words only by spaces.
Otherwise the text is split by punctuation characters as well
Returns the number of words in the given text string. If by_spaces is specified and is true then the function splits the text into words only by spaces. Otherwise the text is split by punctuation characters as well
Extracts a substring of the words beginning at start, and up to but not-including stop.
If stop is omitted then the substring will be all words from start until the end of the text.
If stop is a negative number, then it is treated as count backwards from the end of the text.
If by_spaces is specified and is true then the function splits the text into words only by spaces.
Otherwise the text is split by punctuation characters as well
Returns only the year of a date
Functions
Returns the absolute value of a number
Example 1:
When used in the following Stack expression it returns a value of type Integer: 1.
> abs(-1)
1When used as an expression in text, prepend it with an @:
> "... @abs(-1) ..."
"1"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "abs(-1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 1 = result
1
iex> Expression.evaluate_as_string!(
...> "@abs(-1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"1"Example 2:
When used in the following Stack expression it returns a value of type Float: 0.5.
> abs(-0.5)
0.5When used as an expression in text, prepend it with an @:
> "... @abs(-0.5) ..."
"0.5"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "abs(-0.5)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 0.5 = result
0.5
iex> Expression.evaluate_as_string!(
...> "@abs(-0.5)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"0.5"Returns true if and only if all its arguments evaluate to true
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true when used with the following context:
%{"contact" => %{"age" => 32, "gender" => "F"}}> contact.gender = "F" and contact.age >= 18
trueWhen used as an expression in text, prepend it with an @:
> "... @and(contact.gender = "F", contact.age >= 18) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "and(contact.gender = \"F\", contact.age >= 18)",
...> %{"contact" => %{"age" => 32, "gender" => "F"}},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@and(contact.gender = \"F\", contact.age >= 18)",
...> %{"contact" => %{"age" => 32, "gender" => "F"}},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false when used with the following context:
%{"contact" => %{"age" => 32, "gender" => "?"}}> contact.gender = "F" and contact.age >= 18
falseWhen used as an expression in text, prepend it with an @:
> "... @and(contact.gender = "F", contact.age >= 18) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "and(contact.gender = \"F\", contact.age >= 18)",
...> %{"contact" => %{"age" => 32, "gender" => "?"}},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@and(contact.gender = \"F\", contact.age >= 18)",
...> %{"contact" => %{"age" => 32, "gender" => "?"}},
...> Expression.Callbacks.Standard
...> )
"false"Appends an item or a list of items to a given list.
Example 1:
When used in the following Stack expression it returns a value of type List with values String, String, String:
[
"A",
"B",
"C"
].
> append(["A", "B"], "C")
["A", "B", "C"]When used as an expression in text, prepend it with an @:
> "... @append(["A", "B"], "C") ..."
"ABC"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "append([\"A\", \"B\"], \"C\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["A", "B", "C"] = result
["A", "B", "C"]
iex> Expression.evaluate_as_string!(
...> "@append([\"A\", \"B\"], \"C\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"ABC"Example 2:
When used in the following Stack expression it returns a value of type List with values String, String, String, String:
[
"A",
"B",
"C",
"B"
].
> append(["A", "B"], ["C", "B"])
["A", "B", "C", "B"]When used as an expression in text, prepend it with an @:
> "... @append(["A", "B"], ["C", "B"]) ..."
"ABCB"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "append([\"A\", \"B\"], [\"C\", \"B\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["A", "B", "C", "B"] = result
["A", "B", "C", "B"]
iex> Expression.evaluate_as_string!(
...> "@append([\"A\", \"B\"], [\"C\", \"B\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"ABCB"Base64 decode an expression
Example 1:
When used in the following Stack expression it returns a value of type String: "hello world".
> base64_decode("aGVsbG8gd29ybGQ=")
"hello world"When used as an expression in text, prepend it with an @:
> "... @base64_decode("aGVsbG8gd29ybGQ=") ..."
"hello world"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "base64_decode(\"aGVsbG8gd29ybGQ=\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "hello world" = result
"hello world"
iex> Expression.evaluate_as_string!(
...> "@base64_decode(\"aGVsbG8gd29ybGQ=\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"hello world"Base64 encode an expression
Example 1:
When used in the following Stack expression it returns a value of type String: "aGVsbG8gd29ybGQ=".
> base64_encode("hello world")
"aGVsbG8gd29ybGQ="When used as an expression in text, prepend it with an @:
> "... @base64_encode("hello world") ..."
"aGVsbG8gd29ybGQ="iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "base64_encode(\"hello world\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "aGVsbG8gd29ybGQ=" = result
"aGVsbG8gd29ybGQ="
iex> Expression.evaluate_as_string!(
...> "@base64_encode(\"hello world\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"aGVsbG8gd29ybGQ="Returns the character specified by a number
> "As easy as @char(65), @char(66), @char(67)"
"As easy as A, B, C"Example 1:
When used in the following Stack expression it returns a value of type String: "A".
> char(65)
"A"When used as an expression in text, prepend it with an @:
> "... @char(65) ..."
"A"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "char(65)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "A" = result
"A"
iex> Expression.evaluate_as_string!(
...> "@char(65)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"A"Chunk a list into a list of smaller lists.
This is useful in cases where one has a large list but want to process them in smaller chunks.
Example 1:
Split a large set of sentences into a smaller set of sentences.
When used in the following Stack expression it returns a value of type List with values List with values String, String, List with values String, String, List with values String:
[
[
"the first sentence",
"the second sentence"
],
[
"the third sentence",
"the fourth sentence"
],
[
"the fifth sentence"
]
]when used with the following context:
%{"sentences" => ["the first sentence", "the second sentence", "the third sentence", "the fourth sentence", "the fifth sentence"]}> chunk_every(sentences, 2)
[["the first sentence", "the second sentence"], ["the third sentence", "the fourth sentence"], ["the fifth sentence"]]When used as an expression in text, prepend it with an @:
> "... @chunk_every(sentences, 2) ..."
"the first sentencethe second sentencethe third sentencethe fourth sentencethe fifth sentence"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "chunk_every(sentences, 2)",
...> %{"sentences" => ["the first sentence", "the second sentence", "the third sentence", "the fourth sentence", "the fifth sentence"]},
...> Expression.Callbacks.Standard
...> )
iex> assert [["the first sentence", "the second sentence"], ["the third sentence", "the fourth sentence"], ["the fifth sentence"]] = result
[["the first sentence", "the second sentence"], ["the third sentence", "the fourth sentence"], ["the fifth sentence"]]
iex> Expression.evaluate_as_string!(
...> "@chunk_every(sentences, 2)",
...> %{"sentences" => ["the first sentence", "the second sentence", "the third sentence", "the fourth sentence", "the fifth sentence"]},
...> Expression.Callbacks.Standard
...> )
"the first sentencethe second sentencethe third sentencethe fourth sentencethe fifth sentence"Removes all non-printable characters from a text string
Example 1:
When used in the following Stack expression it returns a value of type String: "ABC" when used with the following context:
%{"value" => <<65, 0, 66, 0, 67>>}> clean(value)
"ABC"When used as an expression in text, prepend it with an @:
> "... @clean(value) ..."
"ABC"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "clean(value)",
...> %{"value" => <<65, 0, 66, 0, 67>>},
...> Expression.Callbacks.Standard
...> )
iex> assert "ABC" = result
"ABC"
iex> Expression.evaluate_as_string!(
...> "@clean(value)",
...> %{"value" => <<65, 0, 66, 0, 67>>},
...> Expression.Callbacks.Standard
...> )
"ABC"Example 2:
When used in the following Stack expression it returns a value of type String: "".
> clean(nil)
""When used as an expression in text, prepend it with an @:
> "... @clean(nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "clean(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...> "@clean(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Returns a numeric code for the first character in a text string
> "The numeric code of A is @CODE(\"A\")"
"The numeric code of A is 65"Example 1:
When used in the following Stack expression it returns a value of type Integer: 65.
> code("A")
65When used as an expression in text, prepend it with an @:
> "... @code("A") ..."
"65"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "code(\"A\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 65 = result
65
iex> Expression.evaluate_as_string!(
...> "@code(\"A\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"65"Example 2:
When used in the following Stack expression it returns a value of type Null: null.
> code(nil)
nilWhen used as an expression in text, prepend it with an @:
> "... @code(nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "code(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@code(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Joins text strings into one text string
> "Your name is @CONCATENATE(contact.first_name, \" \", contact.last_name)"
"Your name is name surname"Example 1:
When used in the following Stack expression it returns a value of type String: "name surname" when used with the following context:
%{"contact" => %{"first_name" => "name", "last_name" => "surname"}}> concatenate(contact.first_name, " ", contact.last_name)
"name surname"When used as an expression in text, prepend it with an @:
> "... @concatenate(contact.first_name, " ", contact.last_name) ..."
"name surname"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "concatenate(contact.first_name, \" \", contact.last_name)",
...> %{"contact" => %{"first_name" => "name", "last_name" => "surname"}},
...> Expression.Callbacks.Standard
...> )
iex> assert "name surname" = result
"name surname"
iex> Expression.evaluate_as_string!(
...> "@concatenate(contact.first_name, \" \", contact.last_name)",
...> %{"contact" => %{"first_name" => "name", "last_name" => "surname"}},
...> Expression.Callbacks.Standard
...> )
"name surname"Return the number of entries in a list, string, or a map.
Example 1:
When used in the following Stack expression it returns a value of type Integer: 3.
> count([1, 2, 3])
3When used as an expression in text, prepend it with an @:
> "... @count([1, 2, 3]) ..."
"3"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "count([1, 2, 3])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 3 = result
3
iex> Expression.evaluate_as_string!(
...> "@count([1, 2, 3])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3"Example 2:
When used in the following Stack expression it returns a value of type Integer: 3.
> count("zoë")
3When used as an expression in text, prepend it with an @:
> "... @count("zoë") ..."
"3"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "count(\"zoë\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 3 = result
3
iex> Expression.evaluate_as_string!(
...> "@count(\"zoë\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3"Example 3:
When used in the following Stack expression it returns a value of type Integer: 1 when used with the following context:
%{"map" => %{"foo" => "bar"}}> count(map)
1When used as an expression in text, prepend it with an @:
> "... @count(map) ..."
"1"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "count(map)",
...> %{"map" => %{"foo" => "bar"}},
...> Expression.Callbacks.Standard
...> )
iex> assert 1 = result
1
iex> Expression.evaluate_as_string!(
...> "@count(map)",
...> %{"map" => %{"foo" => "bar"}},
...> Expression.Callbacks.Standard
...> )
"1"Example 4:
When used in the following Stack expression it returns a value of type Integer: 0 when used with the following context:
%{"nil_value" => nil}> count(nil_value)
0When used as an expression in text, prepend it with an @:
> "... @count(nil_value) ..."
"0"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "count(nil_value)",
...> %{"nil_value" => nil},
...> Expression.Callbacks.Standard
...> )
iex> assert 0 = result
0
iex> Expression.evaluate_as_string!(
...> "@count(nil_value)",
...> %{"nil_value" => nil},
...> Expression.Callbacks.Standard
...> )
"0"Defines a new date value
Example 1:
Construct a date from year, month, and day integers
When used in the following Stack expression it returns a value of type Date: "2022-01-31" when used with the following context:
%{"day" => 31, "month" => 1, "year" => 2022}> date(year, month, day)
~D[2022-01-31]When used as an expression in text, prepend it with an @:
> "... @date(year, month, day) ..."
"2022-01-31"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "date(year, month, day)",
...> %{"day" => 31, "month" => 1, "year" => 2022},
...> Expression.Callbacks.Standard
...> )
iex> assert ~D[2022-01-31] = result
~D[2022-01-31]
iex> Expression.evaluate_as_string!(
...> "@date(year, month, day)",
...> %{"day" => 31, "month" => 1, "year" => 2022},
...> Expression.Callbacks.Standard
...> )
"2022-01-31"Example 2:
Invalid date inputs
When used in the following Stack expression it returns a complex Null type of default value:
nullwith the following fields:
- type of type String
- error of type Boolean
- message of type String when used with the following context:
%{}> date(nil, nil, nil)
%{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "Invalid date: date(nil, nil, nil)"}When used as an expression in text, prepend it with an @:
> "... @date(nil, nil, nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "date(nil, nil, nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "Invalid date: date(nil, nil, nil)"} = result
%{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "Invalid date: date(nil, nil, nil)"}
iex> Expression.evaluate_as_string!(
...> "@date(nil, nil, nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Calculates a new datetime based on the offset and unit provided.
The unit can be any of the following values:
- "Y" for years
- "M" for months
- "W" for weeks
- "D" for days
- "h" for hours
- "m" for minutes
- "s" for seconds
Specifying a negative offset results in date calculations back in time.
Example 1:
Calculates a new datetime based on the offset and unit provided.
When used in the following Stack expression it returns a value of type DateTime: "2022-08-31T00:00:00Z" when used with the following context:
%{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => "1", "unit" => "M"}> datetime_add(datetime, offset, unit)
~U[2022-08-31 00:00:00Z]When used as an expression in text, prepend it with an @:
> "... @datetime_add(datetime, offset, unit) ..."
"2022-08-31T00:00:00Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datetime_add(datetime, offset, unit)",
...> %{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => "1", "unit" => "M"},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2022-08-31 00:00:00Z] = result
~U[2022-08-31 00:00:00Z]
iex> Expression.evaluate_as_string!(
...> "@datetime_add(datetime, offset, unit)",
...> %{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => "1", "unit" => "M"},
...> Expression.Callbacks.Standard
...> )
"2022-08-31T00:00:00Z"Example 2:
Leap year handling in a leap year.
When used in the following Stack expression it returns a value of type DateTime: "2020-02-29T00:00:00.000000Z".
> datetime_add(date(2020, 02, 28), 1, "D")
~U[2020-02-29 00:00:00.000000Z]When used as an expression in text, prepend it with an @:
> "... @datetime_add(date(2020, 02, 28), 1, "D") ..."
"2020-02-29T00:00:00.000000Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datetime_add(date(2020, 02, 28), 1, \"D\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2020-02-29 00:00:00.000000Z] = result
~U[2020-02-29 00:00:00.000000Z]
iex> Expression.evaluate_as_string!(
...> "@datetime_add(date(2020, 02, 28), 1, \"D\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2020-02-29T00:00:00.000000Z"Example 3:
Leap year handling outside of a leap year.
When used in the following Stack expression it returns a value of type DateTime: "2021-03-01T00:00:00.000000Z".
> datetime_add(date(2021, 02, 28), 1, "D")
~U[2021-03-01 00:00:00.000000Z]When used as an expression in text, prepend it with an @:
> "... @datetime_add(date(2021, 02, 28), 1, "D") ..."
"2021-03-01T00:00:00.000000Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datetime_add(date(2021, 02, 28), 1, \"D\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2021-03-01 00:00:00.000000Z] = result
~U[2021-03-01 00:00:00.000000Z]
iex> Expression.evaluate_as_string!(
...> "@datetime_add(date(2021, 02, 28), 1, \"D\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2021-03-01T00:00:00.000000Z"Example 4:
Negative offsets
When used in the following Stack expression it returns a value of type DateTime: "2020-02-28T00:00:00.000000Z".
> datetime_add(date(2020, 02, 29), -1, "D")
~U[2020-02-28 00:00:00.000000Z]When used as an expression in text, prepend it with an @:
> "... @datetime_add(date(2020, 02, 29), -1, "D") ..."
"2020-02-28T00:00:00.000000Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datetime_add(date(2020, 02, 29), -1, \"D\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2020-02-28 00:00:00.000000Z] = result
~U[2020-02-28 00:00:00.000000Z]
iex> Expression.evaluate_as_string!(
...> "@datetime_add(date(2020, 02, 29), -1, \"D\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2020-02-28T00:00:00.000000Z"Example 5:
Invalid date inputs
When used in the following Stack expression it returns a complex Null type of default value:
nullwith the following fields:
- type of type String
- error of type Boolean
- message of type String when used with the following context:
%{}> datetime_add("_..[0]._", 0, "h")
%{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "Invalid date"}When used as an expression in text, prepend it with an @:
> "... @datetime_add("_..[0]._", 0, "h") ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datetime_add(\"_..[0]._\", 0, \"h\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "Invalid date"} = result
%{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "Invalid date"}
iex> Expression.evaluate_as_string!(
...> "@datetime_add(\"_..[0]._\", 0, \"h\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
""@spec datetime_from_unix( map(), {:literal, String.t() | integer()}, {:literal, unit :: String.t()} ) :: DateTime.t()
Parses a UNIX time and returns a DateTime
Example 1:
When used in the following Stack expression it returns a value of type DateTime: "2023-12-06T23:00:00.000Z" when used with the following context:
%{}> datetime_from_unix("1701903600000", "millisecond")
~U[2023-12-06 23:00:00.000Z]When used as an expression in text, prepend it with an @:
> "... @datetime_from_unix("1701903600000", "millisecond") ..."
"2023-12-06T23:00:00.000Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datetime_from_unix(\"1701903600000\", \"millisecond\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2023-12-06 23:00:00.000Z] = result
~U[2023-12-06 23:00:00.000Z]
iex> Expression.evaluate_as_string!(
...> "@datetime_from_unix(\"1701903600000\", \"millisecond\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2023-12-06T23:00:00.000Z"Example 2:
When used in the following Stack expression it returns a value of type DateTime: "2023-12-06T23:00:00.000Z" when used with the following context:
%{}> datetime_from_unix(1701903600000, "millisecond")
~U[2023-12-06 23:00:00.000Z]When used as an expression in text, prepend it with an @:
> "... @datetime_from_unix(1701903600000, "millisecond") ..."
"2023-12-06T23:00:00.000Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datetime_from_unix(1701903600000, \"millisecond\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2023-12-06 23:00:00.000Z] = result
~U[2023-12-06 23:00:00.000Z]
iex> Expression.evaluate_as_string!(
...> "@datetime_from_unix(1701903600000, \"millisecond\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2023-12-06T23:00:00.000Z"Example 3:
When used in the following Stack expression it returns a value of type DateTime: "2023-12-06T23:00:00Z" when used with the following context:
%{}> datetime_from_unix("1701903600", "second")
~U[2023-12-06 23:00:00Z]When used as an expression in text, prepend it with an @:
> "... @datetime_from_unix("1701903600", "second") ..."
"2023-12-06T23:00:00Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datetime_from_unix(\"1701903600\", \"second\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2023-12-06 23:00:00Z] = result
~U[2023-12-06 23:00:00Z]
iex> Expression.evaluate_as_string!(
...> "@datetime_from_unix(\"1701903600\", \"second\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2023-12-06T23:00:00Z"Converts date stored in text to an actual date object and
formats it using strftime formatting.
It will fallback to "%Y-%m-%d %H:%M:%S" if no formatting is supplied
Example 1:
Convert a date from a piece of text to a formatted date string
When used in the following Stack expression it returns a complex String type of default value:
"2022-01-01 00:00:00"with the following fields:
- date of type Date
- datetime of type DateTime .
> datevalue("2022-01-01")
%{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01], "datetime" => ~U[2022-01-01 00:00:00Z]}When used as an expression in text, prepend it with an @:
> "... @datevalue("2022-01-01") ..."
"2022-01-01 00:00:00"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datevalue(\"2022-01-01\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01], "datetime" => ~U[2022-01-01 00:00:00Z]} = result
%{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01], "datetime" => ~U[2022-01-01 00:00:00Z]}
iex> Expression.evaluate_as_string!(
...> "@datevalue(\"2022-01-01\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2022-01-01 00:00:00"Example 2:
Convert a date from a piece of text and read the date field
When used in the following Stack expression it returns a value of type Date: "2022-01-01".
> datevalue("2022-01-01").date
~D[2022-01-01]When used as an expression in text, prepend it with an @:
> "... @datevalue("2022-01-01").date ..."
"2022-01-01"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datevalue(\"2022-01-01\").date",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~D[2022-01-01] = result
~D[2022-01-01]
iex> Expression.evaluate_as_string!(
...> "@datevalue(\"2022-01-01\").date",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2022-01-01"Example 3:
Convert a date value and read the date field
When used in the following Stack expression it returns a value of type Date: "2022-01-01".
> datevalue(date(2022, 1, 1)).date
~D[2022-01-01]When used as an expression in text, prepend it with an @:
> "... @datevalue(date(2022, 1, 1)).date ..."
"2022-01-01"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "datevalue(date(2022, 1, 1)).date",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~D[2022-01-01] = result
~D[2022-01-01]
iex> Expression.evaluate_as_string!(
...> "@datevalue(date(2022, 1, 1)).date",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2022-01-01"Returns only the day of the month of a date (1 to 31)
Example 1:
Getting today's day of the month
When used in the following Stack expression it returns a value of type Integer: 10.
> day(date(2022, 9, 10))
10When used as an expression in text, prepend it with an @:
> "... @day(date(2022, 9, 10)) ..."
"10"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "day(date(2022, 9, 10))",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 10 = result
10
iex> Expression.evaluate_as_string!(
...> "@day(date(2022, 9, 10))",
...> %{},
...> Expression.Callbacks.Standard
...> )
"10"Example 2:
Getting today's day of the month
When used in the following Stack expression it returns a value of type Integer: 6.
> day(now())
6When used as an expression in text, prepend it with an @:
> "... @day(now()) ..."
"6"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "day(now())",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert 6 = result
6
..$> Expression.evaluate_as_string!(
...> "@day(now())",
...> %{},
...> Expression.Callbacks.Standard
...> )
"6"Deletes an element from a map by the given key.
Example 1:
When used in the following Stack expression it returns a value of type Map:
{
"age": 32
}when used with the following context:
%{"patient" => %{"age" => 32, "gender" => "?"}}> delete(patient, "gender")
%{"age" => 32}When used as an expression in text, prepend it with an @:
> "... @delete(patient, "gender") ..."
"%{"age" => 32}"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "delete(patient, \"gender\")",
...> %{"patient" => %{"age" => 32, "gender" => "?"}},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"age" => 32} = result
%{"age" => 32}
iex> Expression.evaluate_as_string!(
...> "@delete(patient, \"gender\")",
...> %{"patient" => %{"age" => 32, "gender" => "?"}},
...> Expression.Callbacks.Standard
...> )
"%{\"age\" => 32}"Moves a date by the given number of months
Example 1:
Move the date in a date object by 1 month
When used in the following Stack expression it returns a value of type DateTime: "2022-02-01T00:00:00Z" when used with the following context:
%{right_now: ~U[2022-01-01 00:00:00Z]}> edate(right_now, 1)
~U[2022-02-01 00:00:00Z]When used as an expression in text, prepend it with an @:
> "... @edate(right_now, 1) ..."
"2022-02-01T00:00:00Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "edate(right_now, 1)",
...> %{right_now: ~U[2022-01-01 00:00:00Z]},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2022-02-01 00:00:00Z] = result
~U[2022-02-01 00:00:00Z]
iex> Expression.evaluate_as_string!(
...> "@edate(right_now, 1)",
...> %{right_now: ~U[2022-01-01 00:00:00Z]},
...> Expression.Callbacks.Standard
...> )
"2022-02-01T00:00:00Z"Example 2:
Move the date store in a piece of text by 1 month
When used in the following Stack expression it returns a value of type Date: "2022-11-10".
> edate("2022-10-10", 1)
~D[2022-11-10]When used as an expression in text, prepend it with an @:
> "... @edate("2022-10-10", 1) ..."
"2022-11-10"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "edate(\"2022-10-10\", 1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~D[2022-11-10] = result
~D[2022-11-10]
iex> Expression.evaluate_as_string!(
...> "@edate(\"2022-10-10\", 1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2022-11-10"Return a list of all functions annotated with @expression_docs
Filters a list by returning a new list that contains only the
elements for which filter_fun is truthy.
Example 1:
When used in the following Stack expression it returns a value of type List with values String, String:
[
"B",
"B"
].
> filter(["A", "B", "C", "B"], & &1 == "B")
["B", "B"]When used as an expression in text, prepend it with an @:
> "... @filter(["A", "B", "C", "B"], & &1 == "B") ..."
"BB"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "filter([\"A\", \"B\", \"C\", \"B\"], & &1 == \"B\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["B", "B"] = result
["B", "B"]
iex> Expression.evaluate_as_string!(
...> "@filter([\"A\", \"B\", \"C\", \"B\"], & &1 == \"B\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"BB"Finds the first element in the list for which filter_fun is truthy.
Example 1:
When used in the following Stack expression it returns a value of type List with values String, String:
[
"Hi",
"World"
].
> find([["Hello", "World"], ["Hi", "World"]], & &1[0] == "Hi")
["Hi", "World"]When used as an expression in text, prepend it with an @:
> "... @find([["Hello", "World"], ["Hi", "World"]], & &1[0] == "Hi") ..."
"HiWorld"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "find([[\"Hello\", \"World\"], [\"Hi\", \"World\"]], & &1[0] == \"Hi\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["Hi", "World"] = result
["Hi", "World"]
iex> Expression.evaluate_as_string!(
...> "@find([[\"Hello\", \"World\"], [\"Hi\", \"World\"]], & &1[0] == \"Hi\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"HiWorld"Returns the first word in the given text - equivalent to WORD(text, 1)
Example 1:
When used in the following Stack expression it returns a value of type String: "foo".
> first_word("foo bar baz")
"foo"When used as an expression in text, prepend it with an @:
> "... @first_word("foo bar baz") ..."
"foo"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "first_word(\"foo bar baz\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "foo" = result
"foo"
iex> Expression.evaluate_as_string!(
...> "@first_word(\"foo bar baz\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"foo"Example 2:
When used in the following Stack expression it returns a value of type String: "".
> first_word(nil)
""When used as an expression in text, prepend it with an @:
> "... @first_word(nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "first_word(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...> "@first_word(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Formats the given number in decimal format using a period and commas
> You have @fixed(contact.balance, 2) in your account
"You have 4.21 in your account"Example 1:
When used in the following Stack expression it returns a value of type String: "4.21".
> fixed(4.209922, 2, false)
"4.21"When used as an expression in text, prepend it with an @:
> "... @fixed(4.209922, 2, false) ..."
"4.21"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "fixed(4.209922, 2, false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "4.21" = result
"4.21"
iex> Expression.evaluate_as_string!(
...> "@fixed(4.209922, 2, false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"4.21"Example 2:
When used in the following Stack expression it returns a value of type String: "4000.4242".
> fixed(4000.424242, 4, true)
"4000.4242"When used as an expression in text, prepend it with an @:
> "... @fixed(4000.424242, 4, true) ..."
"4000.4242"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "fixed(4000.424242, 4, true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "4000.4242" = result
"4000.4242"
iex> Expression.evaluate_as_string!(
...> "@fixed(4000.424242, 4, true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"4000.4242"Example 3:
When used in the following Stack expression it returns a value of type String: "3.80".
> fixed(3.7979, 2, false)
"3.80"When used as an expression in text, prepend it with an @:
> "... @fixed(3.7979, 2, false) ..."
"3.80"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "fixed(3.7979, 2, false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "3.80" = result
"3.80"
iex> Expression.evaluate_as_string!(
...> "@fixed(3.7979, 2, false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3.80"Example 4:
When used in the following Stack expression it returns a value of type String: "3.80".
> fixed(3.7979, 2)
"3.80"When used as an expression in text, prepend it with an @:
> "... @fixed(3.7979, 2) ..."
"3.80"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "fixed(3.7979, 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "3.80" = result
"3.80"
iex> Expression.evaluate_as_string!(
...> "@fixed(3.7979, 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3.80"Example 5:
When used in the following Stack expression it returns a value of type String: "0.09".
> fixed(0.0909, 2)
"0.09"When used as an expression in text, prepend it with an @:
> "... @fixed(0.0909, 2) ..."
"0.09"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "fixed(0.0909, 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "0.09" = result
"0.09"
iex> Expression.evaluate_as_string!(
...> "@fixed(0.0909, 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"0.09"Return true if a list contains all the provided items
Example 1:
Check whether the given list contains all the provided items
When used in the following Stack expression it returns a value of type Boolean: true.
> has_all_members(["A", "B", "C"], ["C", "B"])
trueWhen used as an expression in text, prepend it with an @:
> "... @has_all_members(["A", "B", "C"], ["C", "B"]) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_all_members([\"A\", \"B\", \"C\"], [\"C\", \"B\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_all_members([\"A\", \"B\", \"C\"], [\"C\", \"B\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Tests whether all the words are contained in text
The words can be in any order and may appear more than once.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_all_words("the quick brown FOX", "the fox")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_all_words("the quick brown FOX", "the fox") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_all_words(\"the quick brown FOX\", \"the fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_all_words(\"the quick brown FOX\", \"the fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_all_words("the quick brown FOX", "red fox")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_all_words("the quick brown FOX", "red fox") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_all_words(\"the quick brown FOX\", \"red fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_all_words(\"the quick brown FOX\", \"red fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_all_words(nil, "red fox")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_all_words(nil, "red fox") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_all_words(nil, \"red fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_all_words(nil, \"red fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Checks if the given text starts with any of the provided prefixes. The function performs a case-insensitive match.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_any_beginning("HEY HOW ARE YOU?", ["hello", "hey how are you"])
trueWhen used as an expression in text, prepend it with an @:
> "... @has_any_beginning("HEY HOW ARE YOU?", ["hello", "hey how are you"]) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_beginning(\"HEY HOW ARE YOU?\", [\"hello\", \"hey how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_any_beginning(\"HEY HOW ARE YOU?\", [\"hello\", \"hey how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_any_beginning("كيف حالك؟", ["كيف حالك", "hey how are you"])
trueWhen used as an expression in text, prepend it with an @:
> "... @has_any_beginning("كيف حالك؟", ["كيف حالك", "hey how are you"]) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_beginning(\"كيف حالك؟\", [\"كيف حالك\", \"hey how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_any_beginning(\"كيف حالك؟\", [\"كيف حالك\", \"hey how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 1:
Check whether the given text ends with any of the provided strings. The function performs a case-insensitive match.
When used in the following Stack expression it returns a value of type Boolean: true.
> has_any_end("I would like to book a vaccine", ["appointment", "visit", "vaccine"])
trueWhen used as an expression in text, prepend it with an @:
> "... @has_any_end("I would like to book a vaccine", ["appointment", "visit", "vaccine"]) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_end(\"I would like to book a vaccine\", [\"appointment\", \"visit\", \"vaccine\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_any_end(\"I would like to book a vaccine\", [\"appointment\", \"visit\", \"vaccine\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Check whether the given text exactly matches any of the provided phrases. The function performs a case-insensitive exact match.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_any_exact_phrase("HEY HOW ARE YOU?", ["hello", "hey how are you?"])
trueWhen used as an expression in text, prepend it with an @:
> "... @has_any_exact_phrase("HEY HOW ARE YOU?", ["hello", "hey how are you?"]) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_exact_phrase(\"HEY HOW ARE YOU?\", [\"hello\", \"hey how are you?\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_any_exact_phrase(\"HEY HOW ARE YOU?\", [\"hello\", \"hey how are you?\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_any_exact_phrase("كيف حالك؟", ["كيف حالك", "hey how are you"])
falseWhen used as an expression in text, prepend it with an @:
> "... @has_any_exact_phrase("كيف حالك؟", ["كيف حالك", "hey how are you"]) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_exact_phrase(\"كيف حالك؟\", [\"كيف حالك\", \"hey how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_any_exact_phrase(\"كيف حالك؟\", [\"كيف حالك\", \"hey how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Return true if a list contains any of the provided items
Example 1:
Check whether the given list contains any of the provided items
When used in the following Stack expression it returns a value of type Boolean: true.
> has_any_member(["A", "B", "C"], ["Z", "C"])
trueWhen used as an expression in text, prepend it with an @:
> "... @has_any_member(["A", "B", "C"], ["Z", "C"]) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_member([\"A\", \"B\", \"C\"], [\"Z\", \"C\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_any_member([\"A\", \"B\", \"C\"], [\"Z\", \"C\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Check whether the given text contains any of the provided strings. The function performs a case-insensitive exact match. The second argument expects either a list of strings or a single string with comma-separated phrases.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_any_phrase("hey how are you?", ["hello", "bye bye", "how are you"])
trueWhen used as an expression in text, prepend it with an @:
> "... @has_any_phrase("hey how are you?", ["hello", "bye bye", "how are you"]) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_phrase(\"hey how are you?\", [\"hello\", \"bye bye\", \"how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_any_phrase(\"hey how are you?\", [\"hello\", \"bye bye\", \"how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_any_phrase("مرحباً كيف حالك؟", ["كيف حالك", "how are you"])
trueWhen used as an expression in text, prepend it with an @:
> "... @has_any_phrase("مرحباً كيف حالك؟", ["كيف حالك", "how are you"]) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_phrase(\"مرحباً كيف حالك؟\", [\"كيف حالك\", \"how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_any_phrase(\"مرحباً كيف حالك؟\", [\"كيف حالك\", \"how are you\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_any_phrase("hey how are you?", "hello, bye bye, how are you")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_any_phrase("hey how are you?", "hello, bye bye, how are you") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_phrase(\"hey how are you?\", \"hello, bye bye, how are you\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_any_phrase(\"hey how are you?\", \"hello, bye bye, how are you\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Tests whether any of the words are contained in the text
Only one of the words needs to match and it may appear more than once.
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- match of type String .
> has_any_word("The Quick Brown Fox", "fox quick")
%{"__value__" => true, "match" => "Quick Fox"}When used as an expression in text, prepend it with an @:
> "... @has_any_word("The Quick Brown Fox", "fox quick") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_word(\"The Quick Brown Fox\", \"fox quick\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => "Quick Fox"} = result
%{"__value__" => true, "match" => "Quick Fox"}
iex> Expression.evaluate_as_string!(
...> "@has_any_word(\"The Quick Brown Fox\", \"fox quick\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- match of type Null .
> has_any_word("The Quick Brown Fox", "yellow")
%{"__value__" => false, "match" => nil}When used as an expression in text, prepend it with an @:
> "... @has_any_word("The Quick Brown Fox", "yellow") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_any_word(\"The Quick Brown Fox\", \"yellow\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "match" => nil} = result
%{"__value__" => false, "match" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_any_word(\"The Quick Brown Fox\", \"yellow\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether text starts with beginning
Both text values are trimmed of surrounding whitespace, but otherwise matching is strict without any tokenization.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_beginning("The Quick Brown", "the quick")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_beginning("The Quick Brown", "the quick") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_beginning(\"The Quick Brown\", \"the quick\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_beginning(\"The Quick Brown\", \"the quick\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_beginning("The Quick Brown", "the quick")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_beginning("The Quick Brown", "the quick") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_beginning(\"The Quick Brown\", \"the quick\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_beginning(\"The Quick Brown\", \"the quick\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_beginning("The Quick Brown", "quick brown")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_beginning("The Quick Brown", "quick brown") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_beginning(\"The Quick Brown\", \"quick brown\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_beginning(\"The Quick Brown\", \"quick brown\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression contains a date formatted according to our environment
This is very naively implemented with a regular expression.
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- date of type Date
- datetime of type DateTime
- match of type DateTime .
> has_date("the date is 15/01/2017 05:50")
%{"__value__" => true, "date" => ~D[2017-01-15], "datetime" => ~U[2017-01-15 05:50:00Z], "match" => ~U[2017-01-15 05:50:00Z]}When used as an expression in text, prepend it with an @:
> "... @has_date("the date is 15/01/2017 05:50") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date(\"the date is 15/01/2017 05:50\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "date" => ~D[2017-01-15], "datetime" => ~U[2017-01-15 05:50:00Z], "match" => ~U[2017-01-15 05:50:00Z]} = result
%{"__value__" => true, "date" => ~D[2017-01-15], "datetime" => ~U[2017-01-15 05:50:00Z], "match" => ~U[2017-01-15 05:50:00Z]}
iex> Expression.evaluate_as_string!(
...> "@has_date(\"the date is 15/01/2017 05:50\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Date: "2017-01-15".
> has_date("the date is 15/01/2017").date
~D[2017-01-15]When used as an expression in text, prepend it with an @:
> "... @has_date("the date is 15/01/2017").date ..."
"2017-01-15"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date(\"the date is 15/01/2017\").date",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~D[2017-01-15] = result
~D[2017-01-15]
iex> Expression.evaluate_as_string!(
...> "@has_date(\"the date is 15/01/2017\").date",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2017-01-15"Example 3:
When used in the following Stack expression it returns a value of type DateTime: "2017-01-15T05:50:00Z".
> has_date("the date is 15/01/2017 05:50").datetime
~U[2017-01-15 05:50:00Z]When used as an expression in text, prepend it with an @:
> "... @has_date("the date is 15/01/2017 05:50").datetime ..."
"2017-01-15T05:50:00Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date(\"the date is 15/01/2017 05:50\").datetime",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2017-01-15 05:50:00Z] = result
~U[2017-01-15 05:50:00Z]
iex> Expression.evaluate_as_string!(
...> "@has_date(\"the date is 15/01/2017 05:50\").datetime",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2017-01-15T05:50:00Z"Example 4:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- date of type Null
- datetime of type Null
- match of type Null .
> has_date("there is no date here, just a year 2017")
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}When used as an expression in text, prepend it with an @:
> "... @has_date("there is no date here, just a year 2017") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date(\"there is no date here, just a year 2017\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil} = result
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_date(\"there is no date here, just a year 2017\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 5:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- date of type Null
- datetime of type Null
- match of type Null .
> has_date(1)
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}When used as an expression in text, prepend it with an @:
> "... @has_date(1) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date(1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil} = result
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_date(1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 6:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- date of type Null
- datetime of type Null
- match of type Null when used with the following context:
%{"var" => 1}> has_date(var)
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}When used as an expression in text, prepend it with an @:
> "... @has_date(var) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date(var)",
...> %{"var" => 1},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil} = result
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_date(var)",
...> %{"var" => 1},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression is a date equal to date_string
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- match of type Date
- test of type Date .
> has_date_eq("the date is 15/01/2017", "2017-01-15")
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-15]}When used as an expression in text, prepend it with an @:
> "... @has_date_eq("the date is 15/01/2017", "2017-01-15") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date_eq(\"the date is 15/01/2017\", \"2017-01-15\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-15]} = result
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-15]}
iex> Expression.evaluate_as_string!(
...> "@has_date_eq(\"the date is 15/01/2017\", \"2017-01-15\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- error of type Map
- match of type Null
- test of type Date .
> has_date_eq("there is no date here, just a year 2017", "2017-01-15")
%{"__value__" => false, "error" => %{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "The first argument is nil"}, "match" => nil, "test" => ~D[2017-01-15]}When used as an expression in text, prepend it with an @:
> "... @has_date_eq("there is no date here, just a year 2017", "2017-01-15") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date_eq(\"there is no date here, just a year 2017\", \"2017-01-15\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "error" => %{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "The first argument is nil"}, "match" => nil, "test" => ~D[2017-01-15]} = result
%{"__value__" => false, "error" => %{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "The first argument is nil"}, "match" => nil, "test" => ~D[2017-01-15]}
iex> Expression.evaluate_as_string!(
...> "@has_date_eq(\"there is no date here, just a year 2017\", \"2017-01-15\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression is a date after the date date_string
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- match of type Date
- test of type Date .
> has_date_gt("the date is 15/01/2017", "2017-01-01")
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-01]}When used as an expression in text, prepend it with an @:
> "... @has_date_gt("the date is 15/01/2017", "2017-01-01") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date_gt(\"the date is 15/01/2017\", \"2017-01-01\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-01]} = result
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-01]}
iex> Expression.evaluate_as_string!(
...> "@has_date_gt(\"the date is 15/01/2017\", \"2017-01-01\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- match of type Date
- test of type Date .
> has_date_gt("the date is 15/01/2017", "2017-03-15")
%{"__value__" => false, "match" => ~D[2017-01-15], "test" => ~D[2017-03-15]}When used as an expression in text, prepend it with an @:
> "... @has_date_gt("the date is 15/01/2017", "2017-03-15") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date_gt(\"the date is 15/01/2017\", \"2017-03-15\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "match" => ~D[2017-01-15], "test" => ~D[2017-03-15]} = result
%{"__value__" => false, "match" => ~D[2017-01-15], "test" => ~D[2017-03-15]}
iex> Expression.evaluate_as_string!(
...> "@has_date_gt(\"the date is 15/01/2017\", \"2017-03-15\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression contains a date before the date date_string
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- match of type Date
- test of type Date .
> has_date_lt("the date is 15/01/2017", "2017-06-01")
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-06-01]}When used as an expression in text, prepend it with an @:
> "... @has_date_lt("the date is 15/01/2017", "2017-06-01") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date_lt(\"the date is 15/01/2017\", \"2017-06-01\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-06-01]} = result
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-06-01]}
iex> Expression.evaluate_as_string!(
...> "@has_date_lt(\"the date is 15/01/2017\", \"2017-06-01\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- match of type Date
- test of type Date .
> has_date_lt("the date is 15/01/2021", "2017-03-15")
%{"__value__" => false, "match" => ~D[2021-01-15], "test" => ~D[2017-03-15]}When used as an expression in text, prepend it with an @:
> "... @has_date_lt("the date is 15/01/2021", "2017-03-15") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_date_lt(\"the date is 15/01/2021\", \"2017-03-15\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "match" => ~D[2021-01-15], "test" => ~D[2017-03-15]} = result
%{"__value__" => false, "match" => ~D[2021-01-15], "test" => ~D[2017-03-15]}
iex> Expression.evaluate_as_string!(
...> "@has_date_lt(\"the date is 15/01/2021\", \"2017-03-15\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether an email is contained in text
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- email of type String .
> has_email("my email is foo1@bar.com, please respond")
%{"__value__" => true, "email" => "foo1@bar.com"}When used as an expression in text, prepend it with an @:
> "... @has_email("my email is foo1@bar.com, please respond") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_email(\"my email is foo1@bar.com, please respond\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "email" => "foo1@bar.com"} = result
%{"__value__" => true, "email" => "foo1@bar.com"}
iex> Expression.evaluate_as_string!(
...> "@has_email(\"my email is foo1@bar.com, please respond\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- email of type Null .
> has_email("i'm not sharing my email")
%{"__value__" => false, "email" => nil}When used as an expression in text, prepend it with an @:
> "... @has_email("i'm not sharing my email") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_email(\"i'm not sharing my email\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "email" => nil} = result
%{"__value__" => false, "email" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_email(\"i'm not sharing my email\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 3:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- email of type Null .
> has_email(nil)
%{"__value__" => false, "email" => nil}When used as an expression in text, prepend it with an @:
> "... @has_email(nil) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_email(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "email" => nil} = result
%{"__value__" => false, "email" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_email(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 1:
Check whether the given text ends with the provided string. The function performs a case-insensitive match.
When used in the following Stack expression it returns a value of type Boolean: true.
> has_end("I would like to book a vaccine", "vaccine")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_end("I would like to book a vaccine", "vaccine") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_end(\"I would like to book a vaccine\", \"vaccine\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_end(\"I would like to book a vaccine\", \"vaccine\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Returns whether the contact is part of group with the passed in UUID
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true when used with the following context:
%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}> has_group(contact.groups, "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_group(contact.groups, "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_group(contact.groups, \"b7cf0d83-f1c9-411c-96fd-c511a4cfa86d\")",
...> %{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_group(contact.groups, \"b7cf0d83-f1c9-411c-96fd-c511a4cfa86d\")",
...> %{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false when used with the following context:
%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}> has_group(contact.groups, "00000000-0000-0000-0000-000000000000")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_group(contact.groups, "00000000-0000-0000-0000-000000000000") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_group(contact.groups, \"00000000-0000-0000-0000-000000000000\")",
...> %{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_group(contact.groups, \"00000000-0000-0000-0000-000000000000\")",
...> %{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}},
...> Expression.Callbacks.Standard
...> )
"false"Return true if a list has the given item as a member
Example 1:
Check whether the given list has the item as a member
When used in the following Stack expression it returns a value of type Boolean: true.
> has_member(["A", "B", "C"], "C")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_member(["A", "B", "C"], "C") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_member([\"A\", \"B\", \"C\"], \"C\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_member([\"A\", \"B\", \"C\"], \"C\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Tests whether expression contains a number
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- number of type Float .
> has_number("the number is 42 and 5")
%{"__value__" => true, "number" => 42.0}When used as an expression in text, prepend it with an @:
> "... @has_number("the number is 42 and 5") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number(\"the number is 42 and 5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "number" => 42.0} = result
%{"__value__" => true, "number" => 42.0}
iex> Expression.evaluate_as_string!(
...> "@has_number(\"the number is 42 and 5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- number of type Float .
> has_number("العدد ٤٢")
%{"__value__" => true, "number" => 42.0}When used as an expression in text, prepend it with an @:
> "... @has_number("العدد ٤٢") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number(\"العدد ٤٢\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "number" => 42.0} = result
%{"__value__" => true, "number" => 42.0}
iex> Expression.evaluate_as_string!(
...> "@has_number(\"العدد ٤٢\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- number of type Float .
> has_number("٠.٥")
%{"__value__" => true, "number" => 0.5}When used as an expression in text, prepend it with an @:
> "... @has_number("٠.٥") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number(\"٠.٥\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "number" => 0.5} = result
%{"__value__" => true, "number" => 0.5}
iex> Expression.evaluate_as_string!(
...> "@has_number(\"٠.٥\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- number of type Float .
> has_number("0.6")
%{"__value__" => true, "number" => 0.6}When used as an expression in text, prepend it with an @:
> "... @has_number("0.6") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number(\"0.6\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "number" => 0.6} = result
%{"__value__" => true, "number" => 0.6}
iex> Expression.evaluate_as_string!(
...> "@has_number(\"0.6\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Tests whether expression contains a number equal to the value
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_eq("the number is 42", 42)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_eq("the number is 42", 42) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_eq(\"the number is 42\", 42)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_eq(\"the number is 42\", 42)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_eq("the number is 42", 42.0)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_eq("the number is 42", 42.0) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_eq(\"the number is 42\", 42.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_eq(\"the number is 42\", 42.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_eq("the number is 42", "42")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_eq("the number is 42", "42") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_eq(\"the number is 42\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_eq(\"the number is 42\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_eq("the number is 0.5", "0.5")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_eq("the number is 0.5", "0.5") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_eq(\"the number is 0.5\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_eq(\"the number is 0.5\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 5:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_eq("the number is 42.0", "42")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_eq("the number is 42.0", "42") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_eq(\"the number is 42.0\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_eq(\"the number is 42.0\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 6:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_eq("the number is 40", "42")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_eq("the number is 40", "42") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_eq(\"the number is 40\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_eq(\"the number is 40\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 7:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_eq("the number is 40", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_eq("the number is 40", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_eq(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_eq(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 8:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_eq("four hundred", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_eq("four hundred", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_eq(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_eq(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression contains a number greater than min
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gt("the number is 42", 40)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gt("the number is 42", 40) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gt(\"the number is 42\", 40)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gt(\"the number is 42\", 40)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gt("the number is 42", 40.0)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gt("the number is 42", 40.0) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gt(\"the number is 42\", 40.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gt(\"the number is 42\", 40.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gt("the number is 42", "40")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gt("the number is 42", "40") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gt(\"the number is 42\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gt(\"the number is 42\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gt("the number is 0.6", "0.5")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gt("the number is 0.6", "0.5") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gt(\"the number is 0.6\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gt(\"the number is 0.6\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 5:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gt("the number is 42.0", "40")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gt("the number is 42.0", "40") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gt(\"the number is 42.0\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gt(\"the number is 42.0\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 6:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_gt("the number is 40", "40")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_gt("the number is 40", "40") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gt(\"the number is 40\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_gt(\"the number is 40\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 7:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_gt("the number is 40", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_gt("the number is 40", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gt(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_gt(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 8:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_gt("four hundred", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_gt("four hundred", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gt(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_gt(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression contains a number greater than or equal to min
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gte("the number is 42", 42)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gte("the number is 42", 42) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gte(\"the number is 42\", 42)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gte(\"the number is 42\", 42)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gte("the number is 42", 42.0)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gte("the number is 42", 42.0) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gte(\"the number is 42\", 42.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gte(\"the number is 42\", 42.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gte("the number is 42", "42")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gte("the number is 42", "42") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gte(\"the number is 42\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gte(\"the number is 42\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_gte("the number is 0.5", "0.5")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_gte("the number is 0.5", "0.5") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gte(\"the number is 0.5\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_gte(\"the number is 0.5\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 5:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_gte("the number is 42.0", "45")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_gte("the number is 42.0", "45") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gte(\"the number is 42.0\", \"45\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_gte(\"the number is 42.0\", \"45\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 6:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_gte("the number is 40", "45")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_gte("the number is 40", "45") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gte(\"the number is 40\", \"45\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_gte(\"the number is 40\", \"45\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 7:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_gte("the number is 40", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_gte("the number is 40", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gte(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_gte(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 8:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_gte("four hundred", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_gte("four hundred", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_gte(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_gte(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression contains a number less than max
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_lt("the number is 42", 44)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_lt("the number is 42", 44) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lt(\"the number is 42\", 44)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_lt(\"the number is 42\", 44)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_lt("the number is 42", 44.0)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_lt("the number is 42", 44.0) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lt(\"the number is 42\", 44.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_lt(\"the number is 42\", 44.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lt("the number is 42", "40")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lt("the number is 42", "40") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lt(\"the number is 42\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lt(\"the number is 42\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 4:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lt("the number is 0.6", "0.5")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lt("the number is 0.6", "0.5") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lt(\"the number is 0.6\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lt(\"the number is 0.6\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 5:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lt("the number is 42.0", "40")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lt("the number is 42.0", "40") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lt(\"the number is 42.0\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lt(\"the number is 42.0\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 6:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lt("the number is 40", "40")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lt("the number is 40", "40") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lt(\"the number is 40\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lt(\"the number is 40\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 7:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lt("the number is 40", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lt("the number is 40", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lt(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lt(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 8:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lt("four hundred", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lt("four hundred", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lt(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lt(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression contains a number less than or equal to max
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_lte("the number is 42", 42)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_lte("the number is 42", 42) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lte(\"the number is 42\", 42)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_lte(\"the number is 42\", 42)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_lte("the number is 42", 42.0)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_lte("the number is 42", 42.0) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lte(\"the number is 42\", 42.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_lte(\"the number is 42\", 42.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_lte("the number is 42", "42")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_lte("the number is 42", "42") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lte(\"the number is 42\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_lte(\"the number is 42\", \"42\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_number_lte("the number is 0.5", "0.5")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_lte("the number is 0.5", "0.5") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lte(\"the number is 0.5\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_lte(\"the number is 0.5\", \"0.5\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 5:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lte("the number is 42.0", "40")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lte("the number is 42.0", "40") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lte(\"the number is 42.0\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lte(\"the number is 42.0\", \"40\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 6:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lte("the number is 40", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lte("the number is 40", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lte(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lte(\"the number is 40\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 7:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_number_lte("four hundred", "foo")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_number_lte("four hundred", "foo") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lte(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_number_lte(\"four hundred\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 8:
When used in the following Stack expression it returns a value of type Boolean: true when used with the following context:
%{"response" => 3}> has_number_lte("@response", 5)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_number_lte("@response", 5) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_number_lte(\"@response\", 5)",
...> %{"response" => 3},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_number_lte(\"@response\", 5)",
...> %{"response" => 3},
...> Expression.Callbacks.Standard
...> )
"true"Tests whether the text contains only phrase
The phrase must be the only text in the text to match
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_only_phrase("Quick Brown", "quick brown")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_only_phrase("Quick Brown", "quick brown") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_only_phrase(\"Quick Brown\", \"quick brown\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_only_phrase(\"Quick Brown\", \"quick brown\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_only_phrase("", "")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_only_phrase("", "") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_only_phrase(\"\", \"\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_only_phrase(\"\", \"\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_only_phrase("The Quick Brown Fox", "quick brown")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_only_phrase("The Quick Brown Fox", "quick brown") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_only_phrase(\"The Quick Brown Fox\", \"quick brown\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_only_phrase(\"The Quick Brown Fox\", \"quick brown\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Returns whether two text values are equal (case sensitive). In the case that they are, it will return the text as the match.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_only_text("foo", "foo")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_only_text("foo", "foo") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_only_text(\"foo\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_only_text(\"foo\", \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_only_text("", "")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_only_text("", "") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_only_text(\"\", \"\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_only_text(\"\", \"\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_only_text("foo", "FOO")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_only_text("foo", "FOO") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_only_text(\"foo\", \"FOO\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_only_text(\"foo\", \"FOO\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression matches the regex pattern
Both text values are trimmed of surrounding whitespace and matching is case-insensitive.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_pattern("Buy cheese please", "buy (\w+)")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_pattern("Buy cheese please", "buy (\w+)") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_pattern(\"Buy cheese please\", \"buy (\\w+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_pattern(\"Buy cheese please\", \"buy (\\w+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_pattern("Sell cheese please", "buy (\w+)")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_pattern("Sell cheese please", "buy (\w+)") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_pattern(\"Sell cheese please\", \"buy (\\w+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_pattern(\"Sell cheese please\", \"buy (\\w+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_pattern(nil, "buy (\w+)")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_pattern(nil, "buy (\w+)") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_pattern(nil, \"buy (\\w+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_pattern(nil, \"buy (\\w+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expresssion contains a phone number.
The optional country_code argument specifies the country to use for parsing.
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- phonenumber of type String .
> has_phone("my number is +12067799294 thanks")
%{"__value__" => true, "phonenumber" => "+12067799294"}When used as an expression in text, prepend it with an @:
> "... @has_phone("my number is +12067799294 thanks") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phone(\"my number is +12067799294 thanks\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "phonenumber" => "+12067799294"} = result
%{"__value__" => true, "phonenumber" => "+12067799294"}
iex> Expression.evaluate_as_string!(
...> "@has_phone(\"my number is +12067799294 thanks\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- phonenumber of type String .
> has_phone("my number is 2067799294 thanks", "US")
%{"__value__" => true, "phonenumber" => "+12067799294"}When used as an expression in text, prepend it with an @:
> "... @has_phone("my number is 2067799294 thanks", "US") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phone(\"my number is 2067799294 thanks\", \"US\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "phonenumber" => "+12067799294"} = result
%{"__value__" => true, "phonenumber" => "+12067799294"}
iex> Expression.evaluate_as_string!(
...> "@has_phone(\"my number is 2067799294 thanks\", \"US\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- phonenumber of type String .
> has_phone("my number is 206 779 9294 thanks", "US")
%{"__value__" => true, "phonenumber" => "+12067799294"}When used as an expression in text, prepend it with an @:
> "... @has_phone("my number is 206 779 9294 thanks", "US") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phone(\"my number is 206 779 9294 thanks\", \"US\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "phonenumber" => "+12067799294"} = result
%{"__value__" => true, "phonenumber" => "+12067799294"}
iex> Expression.evaluate_as_string!(
...> "@has_phone(\"my number is 206 779 9294 thanks\", \"US\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- phonenumber of type Null .
> has_phone("my number is none of your business", "US")
%{"__value__" => false, "phonenumber" => nil}When used as an expression in text, prepend it with an @:
> "... @has_phone("my number is none of your business", "US") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phone(\"my number is none of your business\", \"US\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "phonenumber" => nil} = result
%{"__value__" => false, "phonenumber" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_phone(\"my number is none of your business\", \"US\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 5:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- phonenumber of type Null .
> has_phone(nil, "US")
%{"__value__" => false, "phonenumber" => nil}When used as an expression in text, prepend it with an @:
> "... @has_phone(nil, "US") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phone(nil, \"US\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "phonenumber" => nil} = result
%{"__value__" => false, "phonenumber" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_phone(nil, \"US\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 6:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- phonenumber of type Null .
> has_phone("+27")
%{"__value__" => false, "phonenumber" => nil}When used as an expression in text, prepend it with an @:
> "... @has_phone("+27") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phone(\"+27\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "phonenumber" => nil} = result
%{"__value__" => false, "phonenumber" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_phone(\"+27\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 7:
When used in the following Stack expression it returns a complex Boolean type of default value:
falsewith the following fields:
- phonenumber of type Null .
> has_phone("+27", "ZA")
%{"__value__" => false, "phonenumber" => nil}When used as an expression in text, prepend it with an @:
> "... @has_phone("+27", "ZA") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phone(\"+27\", \"ZA\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "phonenumber" => nil} = result
%{"__value__" => false, "phonenumber" => nil}
iex> Expression.evaluate_as_string!(
...> "@has_phone(\"+27\", \"ZA\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether phrase is contained in expression
The words in the test phrase must appear in the same order with no other words in between.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_phrase("the quick brown fox", "brown fox")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_phrase("the quick brown fox", "brown fox") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phrase(\"the quick brown fox\", \"brown fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_phrase(\"the quick brown fox\", \"brown fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_phrase("the quick brown fox", "quick fox")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_phrase("the quick brown fox", "quick fox") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phrase(\"the quick brown fox\", \"quick fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_phrase(\"the quick brown fox\", \"quick fox\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 3:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_phrase("the quick brown fox", "")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_phrase("the quick brown fox", "") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_phrase(\"the quick brown fox\", \"\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_phrase(\"the quick brown fox\", \"\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Tests whether there the expression has any characters in it
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_text("quick brown")
trueWhen used as an expression in text, prepend it with an @:
> "... @has_text("quick brown") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_text(\"quick brown\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_text(\"quick brown\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_text("")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_text("") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_text(\"\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_text(\"\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_text("
> ")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_text("
") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_text(\" \n\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_text(\" \n\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 4:
When used in the following Stack expression it returns a value of type Boolean: true.
> has_text(123)
trueWhen used as an expression in text, prepend it with an @:
> "... @has_text(123) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_text(123)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@has_text(123)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 5:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_text(nil)
falseWhen used as an expression in text, prepend it with an @:
> "... @has_text(nil) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_text(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_text(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Tests whether expression contains a time.
Example 1:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- match of type Time .
> has_time("the time is 10:30")
%{"__value__" => true, "match" => ~T[10:30:00]}When used as an expression in text, prepend it with an @:
> "... @has_time("the time is 10:30") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_time(\"the time is 10:30\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~T[10:30:00]} = result
%{"__value__" => true, "match" => ~T[10:30:00]}
iex> Expression.evaluate_as_string!(
...> "@has_time(\"the time is 10:30\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- match of type Time .
> has_time("the time is 10:00 pm")
%{"__value__" => true, "match" => ~T[10:00:00]}When used as an expression in text, prepend it with an @:
> "... @has_time("the time is 10:00 pm") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_time(\"the time is 10:00 pm\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~T[10:00:00]} = result
%{"__value__" => true, "match" => ~T[10:00:00]}
iex> Expression.evaluate_as_string!(
...> "@has_time(\"the time is 10:00 pm\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a complex Boolean type of default value:
truewith the following fields:
- match of type Time .
> has_time("the time is 10:30:45")
%{"__value__" => true, "match" => ~T[10:30:45]}When used as an expression in text, prepend it with an @:
> "... @has_time("the time is 10:30:45") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_time(\"the time is 10:30:45\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~T[10:30:45]} = result
%{"__value__" => true, "match" => ~T[10:30:45]}
iex> Expression.evaluate_as_string!(
...> "@has_time(\"the time is 10:30:45\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a value of type Boolean: false.
> has_time("there is no time here, just the number 25")
falseWhen used as an expression in text, prepend it with an @:
> "... @has_time("there is no time here, just the number 25") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "has_time(\"there is no time here, just the number 25\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@has_time(\"there is no time here, just the number 25\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Returns only the hour of a datetime (0 to 23)
Example 1:
Get the current hour
When used in the following Stack expression it returns a value of type Integer: 23.
> hour(now())
23When used as an expression in text, prepend it with an @:
> "... @hour(now()) ..."
"23"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "hour(now())",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert 23 = result
23
..$> Expression.evaluate_as_string!(
...> "@hour(now())",
...> %{},
...> Expression.Callbacks.Standard
...> )
"23"Returns one value if the condition evaluates to true, and another value if it evaluates to false
Example 1:
When used in the following Stack expression it returns a value of type String: "Yes".
> if true do
> "Yes"
> else
> "No"
> end
>
"Yes"When used as an expression in text, prepend it with an @:
> "... @if(true, "Yes", "No") ..."
"Yes"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "if(true, \"Yes\", \"No\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "Yes" = result
"Yes"
iex> Expression.evaluate_as_string!(
...> "@if(true, \"Yes\", \"No\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"Yes"Example 2:
When used in the following Stack expression it returns a value of type String: "No".
> # Shorthand
> if(false, do: "Yes", else: "No")
"No"When used as an expression in text, prepend it with an @:
> "... @if(false, "Yes", "No") ..."
"No"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "if(false, \"Yes\", \"No\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "No" = result
"No"
iex> Expression.evaluate_as_string!(
...> "@if(false, \"Yes\", \"No\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"No"@spec is_error(Expression.Context.t(), %{required(String.t()) => term()}) :: boolean()
Checks whether value is an error
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true when used with the following context:
%{"error" => %{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "the error"}}> is_error(error)
trueWhen used as an expression in text, prepend it with an @:
> "... @is_error(error) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "is_error(error)",
...> %{"error" => %{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "the error"}},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@is_error(error)",
...> %{"error" => %{"__type__" => "expression/v1error", "__value__" => nil, "error" => true, "message" => "the error"}},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false when used with the following context:
%{}> is_error("not an error")
falseWhen used as an expression in text, prepend it with an @:
> "... @is_error("not an error") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "is_error(\"not an error\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@is_error(\"not an error\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Returns true if the argument is nil or an empty string
Example 1:
Check whether the given argument is nil or an empty string
When used in the following Stack expression it returns a value of type Boolean: true.
> is_nil_or_empty(nil)
trueWhen used as an expression in text, prepend it with an @:
> "... @is_nil_or_empty(nil) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "is_nil_or_empty(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@is_nil_or_empty(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Returns true if the argument is a boolean.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> isbool(true)
trueWhen used as an expression in text, prepend it with an @:
> "... @isbool(true) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isbool(true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@isbool(true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> isbool(false)
trueWhen used as an expression in text, prepend it with an @:
> "... @isbool(false) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isbool(false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@isbool(false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> isbool(1)
falseWhen used as an expression in text, prepend it with an @:
> "... @isbool(1) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isbool(1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@isbool(1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 4:
When used in the following Stack expression it returns a value of type Boolean: false.
> isbool(0)
falseWhen used as an expression in text, prepend it with an @:
> "... @isbool(0) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isbool(0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@isbool(0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 5:
When used in the following Stack expression it returns a value of type Boolean: false.
> isbool("true")
falseWhen used as an expression in text, prepend it with an @:
> "... @isbool("true") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isbool(\"true\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@isbool(\"true\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 6:
When used in the following Stack expression it returns a value of type Boolean: false.
> isbool("false")
falseWhen used as an expression in text, prepend it with an @:
> "... @isbool("false") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isbool(\"false\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@isbool(\"false\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Returns true if the argument is a number.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> isnumber(1)
trueWhen used as an expression in text, prepend it with an @:
> "... @isnumber(1) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isnumber(1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@isnumber(1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: true.
> isnumber(1.0)
trueWhen used as an expression in text, prepend it with an @:
> "... @isnumber(1.0) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isnumber(1.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@isnumber(1.0)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 3:
When used in the following Stack expression it returns a value of type Boolean: true.
> isnumber("1.0")
trueWhen used as an expression in text, prepend it with an @:
> "... @isnumber("1.0") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isnumber(\"1.0\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@isnumber(\"1.0\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a value of type Boolean: false.
> isnumber("a")
falseWhen used as an expression in text, prepend it with an @:
> "... @isnumber("a") ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isnumber(\"a\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@isnumber(\"a\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Returns true if the argument is a string.
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> isstring("hello")
trueWhen used as an expression in text, prepend it with an @:
> "... @isstring("hello") ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isstring(\"hello\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@isstring(\"hello\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
When used in the following Stack expression it returns a value of type Boolean: false.
> isstring(false)
falseWhen used as an expression in text, prepend it with an @:
> "... @isstring(false) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isstring(false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@isstring(false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 3:
When used in the following Stack expression it returns a value of type Boolean: false.
> isstring(1)
falseWhen used as an expression in text, prepend it with an @:
> "... @isstring(1) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "isstring(1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@isstring(1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Converts a data structure to JSON
Example 1:
When used in the following Stack expression it returns a value of type String: "{\"foo\":\"bar\"}" when used with the following context:
%{"data" => %{"foo" => "bar"}}> json(data)
"{\"foo\":\"bar\"}"When used as an expression in text, prepend it with an @:
> "... @json(data) ..."
"{"foo":"bar"}"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "json(data)",
...> %{"data" => %{"foo" => "bar"}},
...> Expression.Callbacks.Standard
...> )
iex> assert "{\"foo\":\"bar\"}" = result
"{\"foo\":\"bar\"}"
iex> Expression.evaluate_as_string!(
...> "@json(data)",
...> %{"data" => %{"foo" => "bar"}},
...> Expression.Callbacks.Standard
...> )
"{\"foo\":\"bar\"}"Returns the first characters in a text string. This is Unicode safe.
It will return nil if the given string is nil
Example 1:
When used in the following Stack expression it returns a value of type String: "foob".
> left("foobar", 4)
"foob"When used as an expression in text, prepend it with an @:
> "... @left("foobar", 4) ..."
"foob"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "left(\"foobar\", 4)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "foob" = result
"foob"
iex> Expression.evaluate_as_string!(
...> "@left(\"foobar\", 4)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"foob"Example 2:
When used in the following Stack expression it returns a value of type String: "Умерла Мадлен Олбрай".
> left("Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США", 20)
"Умерла Мадлен Олбрай"When used as an expression in text, prepend it with an @:
> "... @left("Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США", 20) ..."
"Умерла Мадлен Олбрай"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "left(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "Умерла Мадлен Олбрай" = result
"Умерла Мадлен Олбрай"
iex> Expression.evaluate_as_string!(
...> "@left(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"Умерла Мадлен Олбрай"Example 3:
When used in the following Stack expression it returns a value of type Null: null.
> left(nil, 4)
nilWhen used as an expression in text, prepend it with an @:
> "... @left(nil, 4) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "left(nil, 4)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@left(nil, 4)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Returns the number of characters in a text string, returns 0 if the string is null or empty
Example 1:
When used in the following Stack expression it returns a value of type Integer: 3.
> len("foo")
3When used as an expression in text, prepend it with an @:
> "... @len("foo") ..."
"3"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "len(\"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 3 = result
3
iex> Expression.evaluate_as_string!(
...> "@len(\"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3"Example 2:
When used in the following Stack expression it returns a value of type Integer: 3.
> len("zoë")
3When used as an expression in text, prepend it with an @:
> "... @len("zoë") ..."
"3"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "len(\"zoë\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 3 = result
3
iex> Expression.evaluate_as_string!(
...> "@len(\"zoë\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3"Example 3:
When used in the following Stack expression it returns a value of type Integer: 0.
> len(nil)
0When used as an expression in text, prepend it with an @:
> "... @len(nil) ..."
"0"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "len(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 0 = result
0
iex> Expression.evaluate_as_string!(
...> "@len(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"0"Converts a text string to lowercase
Example 1:
When used in the following Stack expression it returns a value of type String: "foo bar".
> lower("Foo Bar")
"foo bar"When used as an expression in text, prepend it with an @:
> "... @lower("Foo Bar") ..."
"foo bar"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "lower(\"Foo Bar\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "foo bar" = result
"foo bar"
iex> Expression.evaluate_as_string!(
...> "@lower(\"Foo Bar\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"foo bar"Example 2:
When used in the following Stack expression it returns a value of type Null: null.
> lower(nil)
nilWhen used as an expression in text, prepend it with an @:
> "... @lower(nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "lower(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@lower(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""map over a list of items and apply the mapper function to every item, returning the result.
Example 1:
Map over the range of numbers, create a date in January for every number
When used in the following Stack expression it returns a value of type List with values Date, Date, Date:
[
"2022-01-01",
"2022-01-02",
"2022-01-03"
].
> map(1..3, &date(2022, 1, &1))
[~D[2022-01-01], ~D[2022-01-02], ~D[2022-01-03]]When used as an expression in text, prepend it with an @:
> "... @map(1..3, &date(2022, 1, &1)) ..."
"2022-01-012022-01-022022-01-03"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "map(1..3, &date(2022, 1, &1))",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert [~D[2022-01-01], ~D[2022-01-02], ~D[2022-01-03]] = result
[~D[2022-01-01], ~D[2022-01-02], ~D[2022-01-03]]
iex> Expression.evaluate_as_string!(
...> "@map(1..3, &date(2022, 1, &1))",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2022-01-012022-01-022022-01-03"Example 2:
Map over the range of numbers, multiple each by itself and return the result
When used in the following Stack expression it returns a value of type List with values Integer, Integer, Integer:
[
1,
4,
9
].
> map(1..3, &(&1 * &1))
[1, 4, 9]When used as an expression in text, prepend it with an @:
> "... @map(1..3, &(&1 * &1)) ..."
"149"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "map(1..3, &(&1 * &1))",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert [1, 4, 9] = result
[1, 4, 9]
iex> Expression.evaluate_as_string!(
...> "@map(1..3, &(&1 * &1))",
...> %{},
...> Expression.Callbacks.Standard
...> )
"149"Returns the maximum value of all arguments
Example 1:
When used in the following Stack expression it returns a value of type Integer: 3.
> max(1, 2, 3)
3When used as an expression in text, prepend it with an @:
> "... @max(1, 2, 3) ..."
"3"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "max(1, 2, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 3 = result
3
iex> Expression.evaluate_as_string!(
...> "@max(1, 2, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3"MID extracts part of a string, starting at a specified position and for a specified length.
It correctly handles Unicode characters. For example, taking the first three characters from "héllo" returns "hél".
If the starting position is beyond the string length, it returns an empty string.
Implementation based on https://support.microsoft.com/en-us/office/mid-function-2eba57be-0c05-4bdc-bf81-5ecf4421eb8a
Example 1:
MID returns a specific number of characters from a text string, starting at the position you specify, based on the number of characters you specify.
When used in the following Stack expression it returns a value of type String: "Fluid".
> MID("Fluid", 1, 5)
"Fluid"When used as an expression in text, prepend it with an @:
> "... @MID("Fluid", 1, 5) ..."
"Fluid"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "MID(\"Fluid\", 1, 5)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "Fluid" = result
"Fluid"
iex> Expression.evaluate_as_string!(
...> "@MID(\"Fluid\", 1, 5)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"Fluid"Example 2:
When used in the following Stack expression it returns a value of type String: "Flow".
> MID("Fluid Flow", 7, 20)
"Flow"When used as an expression in text, prepend it with an @:
> "... @MID("Fluid Flow", 7, 20) ..."
"Flow"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "MID(\"Fluid Flow\", 7, 20)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "Flow" = result
"Flow"
iex> Expression.evaluate_as_string!(
...> "@MID(\"Fluid Flow\", 7, 20)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"Flow"Example 3:
When used in the following Stack expression it returns a value of type String: "".
> MID("Fluid Flow", 20, 5)
""When used as an expression in text, prepend it with an @:
> "... @MID("Fluid Flow", 20, 5) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "MID(\"Fluid Flow\", 20, 5)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...> "@MID(\"Fluid Flow\", 20, 5)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Returns the minimum value of all arguments
Example 1:
When used in the following Stack expression it returns a value of type Integer: 1.
> min(1, 2, 3)
1When used as an expression in text, prepend it with an @:
> "... @min(1, 2, 3) ..."
"1"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "min(1, 2, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 1 = result
1
iex> Expression.evaluate_as_string!(
...> "@min(1, 2, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"1"Returns only the minute of a datetime (0 to 59)
Example 1:
Get the current minute
When used in the following Stack expression it returns a value of type Integer: 41.
> minute(now())
41When used as an expression in text, prepend it with an @:
> "... @minute(now()) ..."
"41"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "minute(now())",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert 41 = result
41
..$> Expression.evaluate_as_string!(
...> "@minute(now())",
...> %{},
...> Expression.Callbacks.Standard
...> )
"41"Returns only the month of a date (1 to 12)
Example 1:
Get the current month
When used in the following Stack expression it returns a value of type Integer: 5.
> month(now())
5When used as an expression in text, prepend it with an @:
> "... @month(now()) ..."
"5"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "month(now())",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert 5 = result
5
..$> Expression.evaluate_as_string!(
...> "@month(now())",
...> %{},
...> Expression.Callbacks.Standard
...> )
"5"Returns false if the argument supplied evaluates to truth-y
Example 1:
When used in the following Stack expression it returns a value of type Boolean: true.
> not(false)
trueWhen used as an expression in text, prepend it with an @:
> "... @not(false) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "not(false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@not(false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Returns the current date time as UTC
It is currently @NOW()Example 1:
return the current timestamp as a DateTime value
When used in the following Stack expression it returns a value of type DateTime: "2025-05-06T23:41:40.747524Z".
> now()
~U[2025-05-06 23:41:40.747524Z]When used as an expression in text, prepend it with an @:
> "... @now() ..."
"2025-05-06T23:41:40.747524Z"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "now()",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert ~U[2025-05-06 23:41:40.747524Z] = result
~U[2025-05-06 23:41:40.747524Z]
..$> Expression.evaluate_as_string!(
...> "@now()",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2025-05-06T23:41:40.747524Z"Example 2:
return the current datetime and format it using
datevalue
When used in the following Stack expression it returns a complex String type of default value:
"2025-05-06"with the following fields:
- date of type DateTime .
> datevalue(now(), "%Y-%m-%d")
%{"__value__" => "2025-05-06", "date" => ~U[2025-05-06 23:41:40.833277Z]}When used as an expression in text, prepend it with an @:
> "... @datevalue(now(), "%Y-%m-%d") ..."
"2025-05-06"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "datevalue(now(), \"%Y-%m-%d\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert %{"__value__" => "2025-05-06", "date" => ~U[2025-05-06 23:41:40.833277Z]} = result
%{"__value__" => "2025-05-06", "date" => ~U[2025-05-06 23:41:40.833277Z]}
..$> Expression.evaluate_as_string!(
...> "@datevalue(now(), \"%Y-%m-%d\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2025-05-06"Returns true if any argument is true.
Returns the first truthy value found or otherwise false.
Accepts any amount of arguments for testing truthiness.
Example 1:
Return true if any of the values are true
When used in the following Stack expression it returns a value of type Boolean: true.
> true or false
trueWhen used as an expression in text, prepend it with an @:
> "... @or(true, false) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "or(true, false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@or(true, false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 2:
Return the first value that is truthy
When used in the following Stack expression it returns a value of type String: "foo".
> false or "foo"
"foo"When used as an expression in text, prepend it with an @:
> "... @or(false, "foo") ..."
"foo"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "or(false, \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "foo" = result
"foo"
iex> Expression.evaluate_as_string!(
...> "@or(false, \"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"foo"Example 3:
When used in the following Stack expression it returns a value of type Boolean: true.
> true or true
trueWhen used as an expression in text, prepend it with an @:
> "... @or(true, true) ..."
"true"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "or(true, true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...> "@or(true, true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"true"Example 4:
When used in the following Stack expression it returns a value of type Boolean: false.
> false or false
falseWhen used as an expression in text, prepend it with an @:
> "... @or(false, false) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "or(false, false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@or(false, false)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Example 5:
When used in the following Stack expression it returns a value of type String: "bee" when used with the following context:
%{"a" => false, "b" => "bee"}> a or b
"bee"When used as an expression in text, prepend it with an @:
> "... @or(a, b) ..."
"bee"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "or(a, b)",
...> %{"a" => false, "b" => "bee"},
...> Expression.Callbacks.Standard
...> )
iex> assert "bee" = result
"bee"
iex> Expression.evaluate_as_string!(
...> "@or(a, b)",
...> %{"a" => false, "b" => "bee"},
...> Expression.Callbacks.Standard
...> )
"bee"Example 6:
When used in the following Stack expression it returns a value of type String: "a" when used with the following context:
%{"a" => "a", "b" => false}> a or b
"a"When used as an expression in text, prepend it with an @:
> "... @or(a, b) ..."
"a"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "or(a, b)",
...> %{"a" => "a", "b" => false},
...> Expression.Callbacks.Standard
...> )
iex> assert "a" = result
"a"
iex> Expression.evaluate_as_string!(
...> "@or(a, b)",
...> %{"a" => "a", "b" => false},
...> Expression.Callbacks.Standard
...> )
"a"Example 7:
When used in the following Stack expression it returns a value of type Boolean: false when used with the following context:
%{}> b or b
falseWhen used as an expression in text, prepend it with an @:
> "... @or(b, b) ..."
"false"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "or(b, b)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...> "@or(b, b)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"false"Parse random dates and times with strftime patterns and return a DateTime value
when it matches.
Example 1:
Parse a date value using strftime formatting and return a DateTime
When used in the following Stack expression it returns a value of type DateTime: "2016-02-29T22:25:00Z".
> parse_datevalue("2016-02-29T22:25:00-00:00", "%FT%T%:z")
~U[2016-02-29 22:25:00Z]When used as an expression in text, prepend it with an @:
> "... @parse_datevalue("2016-02-29T22:25:00-00:00", "%FT%T%:z") ..."
"2016-02-29T22:25:00Z"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "parse_datevalue(\"2016-02-29T22:25:00-00:00\", \"%FT%T%:z\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~U[2016-02-29 22:25:00Z] = result
~U[2016-02-29 22:25:00Z]
iex> Expression.evaluate_as_string!(
...> "@parse_datevalue(\"2016-02-29T22:25:00-00:00\", \"%FT%T%:z\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2016-02-29T22:25:00Z"Example 2:
Attempt to parse a date value and return nil when failing
When used in the following Stack expression it returns a value of type Null: null.
> parse_datevalue("👻👻👻👻", "%FT%T%:z")
nilWhen used as an expression in text, prepend it with an @:
> "... @parse_datevalue("👻👻👻👻", "%FT%T%:z") ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "parse_datevalue(\"👻👻👻👻\", \"%FT%T%:z\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@parse_datevalue(\"👻👻👻👻\", \"%FT%T%:z\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Parses a string as JSON when given a String which is assumed to be JSON encoded.
Will return whatever was supplied as is when the given argument is not a String.
Example 1:
When used in the following Stack expression it returns a value of type List with values Integer, Integer, Integer:
[
1,
2,
3
].
> parse_json('[1,2,3]')
[1, 2, 3]When used as an expression in text, prepend it with an @:
> "... @parse_json('[1,2,3]') ..."
"123"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "parse_json('[1,2,3]')",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert [1, 2, 3] = result
[1, 2, 3]
iex> Expression.evaluate_as_string!(
...> "@parse_json('[1,2,3]')",
...> %{},
...> Expression.Callbacks.Standard
...> )
"123"Example 2:
When used in the following Stack expression it returns a value of type List with values Integer, Integer, Integer:
[
1,
2,
3
].
> parse_json('[1,2,3]')
[1, 2, 3]When used as an expression in text, prepend it with an @:
> "... @parse_json('[1,2,3]') ..."
"123"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "parse_json('[1,2,3]')",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert [1, 2, 3] = result
[1, 2, 3]
iex> Expression.evaluate_as_string!(
...> "@parse_json('[1,2,3]')",
...> %{},
...> Expression.Callbacks.Standard
...> )
"123"Formats a number as a percentage
Example 1:
When used in the following Stack expression it returns a value of type String: "20%".
> percent(2/10)
"20%"When used as an expression in text, prepend it with an @:
> "... @percent(2/10) ..."
"20%"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "percent(2/10)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "20%" = result
"20%"
iex> Expression.evaluate_as_string!(
...> "@percent(2/10)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"20%"Example 2:
When used in the following Stack expression it returns a value of type String: "20%".
> percent(0.2)
"20%"When used as an expression in text, prepend it with an @:
> "... @percent(0.2) ..."
"20%"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "percent(0.2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "20%" = result
"20%"
iex> Expression.evaluate_as_string!(
...> "@percent(0.2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"20%"Example 3:
When used in the following Stack expression it returns a value of type String: "20%" when used with the following context:
%{"d" => "0.2"}> percent(d)
"20%"When used as an expression in text, prepend it with an @:
> "... @percent(d) ..."
"20%"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "percent(d)",
...> %{"d" => "0.2"},
...> Expression.Callbacks.Standard
...> )
iex> assert "20%" = result
"20%"
iex> Expression.evaluate_as_string!(
...> "@percent(d)",
...> %{"d" => "0.2"},
...> Expression.Callbacks.Standard
...> )
"20%"Returns the result of a number raised to a power - equivalent to the ^ operator
Example 1:
When used in the following Stack expression it returns a value of type Float: 8.0.
> power(2, 3)
8.0When used as an expression in text, prepend it with an @:
> "... @power(2, 3) ..."
"8.0"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "power(2, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert 8.0 = result
8.0
..$> Expression.evaluate_as_string!(
...> "@power(2, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"8.0"Capitalizes the first letter of every word in a text string
Example 1:
When used in the following Stack expression it returns a value of type String: "Foo Bar".
> proper("foo bar")
"Foo Bar"When used as an expression in text, prepend it with an @:
> "... @proper("foo bar") ..."
"Foo Bar"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "proper(\"foo bar\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "Foo Bar" = result
"Foo Bar"
iex> Expression.evaluate_as_string!(
...> "@proper(\"foo bar\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"Foo Bar"Example 2:
When used in the following Stack expression it returns a value of type Null: null.
> proper(nil)
nilWhen used as an expression in text, prepend it with an @:
> "... @proper(nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "proper(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@proper(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Generate a random number between min and max
Example 1:
Generate a number between 1 and 10
When used in the following Stack expression it returns a value of type Integer: 3.
> rand_between(1, 10)
3When used as an expression in text, prepend it with an @:
> "... @rand_between(1, 10) ..."
"3"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "rand_between(1, 10)",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert 3 = result
3
..$> Expression.evaluate_as_string!(
...> "@rand_between(1, 10)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3"Formats digits in text for reading in TTS
Example 1:
When used in the following Stack expression it returns a value of type String: "plus two seven one".
> read_digits("+271")
"plus two seven one"When used as an expression in text, prepend it with an @:
> "... @read_digits("+271") ..."
"plus two seven one"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "read_digits(\"+271\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "plus two seven one" = result
"plus two seven one"
iex> Expression.evaluate_as_string!(
...> "@read_digits(\"+271\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"plus two seven one"Example 2:
When used in the following Stack expression it returns a value of type String: "".
> read_digits(nil)
""When used as an expression in text, prepend it with an @:
> "... @read_digits(nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "read_digits(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...> "@read_digits(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Reduces elements from a list by applying a function and collecting the results in an accumulator.
The first argument to the lambda function is the item from the list, the second argument is the accumulator.
Example 1:
When used in the following Stack expression it returns a value of type Integer: 6.
> reduce(1..3, 0, & &1 + &2)
6When used as an expression in text, prepend it with an @:
> "... @reduce(1..3, 0, & &1 + &2) ..."
"6"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "reduce(1..3, 0, & &1 + &2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 6 = result
6
iex> Expression.evaluate_as_string!(
...> "@reduce(1..3, 0, & &1 + &2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"6"Capture values out of a string using a regex.
Returns the list of captures in a list.
Returns nil if there was nothing to match
Example 1:
When used in the following Stack expression it returns a value of type List with values String:
[
"ing"
].
> regex_capture("testing", "test(.+)")
["ing"]When used as an expression in text, prepend it with an @:
> "... @regex_capture("testing", "test(.+)") ..."
"ing"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "regex_capture(\"testing\", \"test(.+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["ing"] = result
["ing"]
iex> Expression.evaluate_as_string!(
...> "@regex_capture(\"testing\", \"test(.+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"ing"Example 2:
When used in the following Stack expression it returns a value of type Null: null.
> regex_capture("testing", "foo(.+)")
nilWhen used as an expression in text, prepend it with an @:
> "... @regex_capture("testing", "foo(.+)") ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "regex_capture(\"testing\", \"foo(.+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@regex_capture(\"testing\", \"foo(.+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Captures named values out of a string using a regex.
In contrast to regex_capture() this returns a map
where the keys are the names of the captures and the
values are the captured values.
Example 1:
When used in the following Stack expression it returns a value of type Map:
{
"match": "ing"
}.
> regex_named_capture("testing", "test(?P<match>.+)")
%{"match" => "ing"}When used as an expression in text, prepend it with an @:
> "... @regex_named_capture("testing", "test(?P<match>.+)") ..."
"%{"match" => "ing"}"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "regex_named_capture(\"testing\", \"test(?P<match>.+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{"match" => "ing"} = result
%{"match" => "ing"}
iex> Expression.evaluate_as_string!(
...> "@regex_named_capture(\"testing\", \"test(?P<match>.+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"%{\"match\" => \"ing\"}"Example 2:
When used in the following Stack expression it returns a value of type Map: {}.
> regex_named_capture("testing", "foo(?P<match>.+)")
%{}When used as an expression in text, prepend it with an @:
> "... @regex_named_capture("testing", "foo(?P<match>.+)") ..."
"%{}"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "regex_named_capture(\"testing\", \"foo(?P<match>.+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert %{} = result
%{}
iex> Expression.evaluate_as_string!(
...> "@regex_named_capture(\"testing\", \"foo(?P<match>.+)\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"%{}"Rejects elements from a list by returning a new list that contains only the
elements for which reject_fun is truthy.
Example 1:
When used in the following Stack expression it returns a value of type List with values String, String:
[
"A",
"C"
].
> reject(["A", "B", "C", "B"], & &1 == "B")
["A", "C"]When used as an expression in text, prepend it with an @:
> "... @reject(["A", "B", "C", "B"], & &1 == "B") ..."
"AC"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "reject([\"A\", \"B\", \"C\", \"B\"], & &1 == \"B\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["A", "C"] = result
["A", "C"]
iex> Expression.evaluate_as_string!(
...> "@reject([\"A\", \"B\", \"C\", \"B\"], & &1 == \"B\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"AC"Return the division remainder of two integers.
Example 1:
When used in the following Stack expression it returns a value of type Integer: 0.
> rem(4, 2)
0When used as an expression in text, prepend it with an @:
> "... @rem(4, 2) ..."
"0"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "rem(4, 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 0 = result
0
iex> Expression.evaluate_as_string!(
...> "@rem(4, 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"0"Example 2:
When used in the following Stack expression it returns a value of type Integer: 1.
> rem(85, 3)
1When used as an expression in text, prepend it with an @:
> "... @rem(85, 3) ..."
"1"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "rem(85, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 1 = result
1
iex> Expression.evaluate_as_string!(
...> "@rem(85, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"1"Removes the first word from the given text. The remaining text will be unchanged
Example 1:
When used in the following Stack expression it returns a value of type String: "bar".
> remove_first_word("foo bar")
"bar"When used as an expression in text, prepend it with an @:
> "... @remove_first_word("foo bar") ..."
"bar"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "remove_first_word(\"foo bar\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "bar" = result
"bar"
iex> Expression.evaluate_as_string!(
...> "@remove_first_word(\"foo bar\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"bar"Example 2:
When used in the following Stack expression it returns a value of type String: "bar".
> remove_first_word("foo-bar", "-")
"bar"When used as an expression in text, prepend it with an @:
> "... @remove_first_word("foo-bar", "-") ..."
"bar"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "remove_first_word(\"foo-bar\", \"-\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "bar" = result
"bar"
iex> Expression.evaluate_as_string!(
...> "@remove_first_word(\"foo-bar\", \"-\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"bar"Example 3:
When used in the following Stack expression it returns a value of type String: "".
> remove_first_word(nil)
""When used as an expression in text, prepend it with an @:
> "... @remove_first_word(nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "remove_first_word(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...> "@remove_first_word(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Example 4:
When used in the following Stack expression it returns a value of type String: "".
> remove_first_word(nil, "-")
""When used as an expression in text, prepend it with an @:
> "... @remove_first_word(nil, "-") ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "remove_first_word(nil, \"-\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...> "@remove_first_word(nil, \"-\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Example 1:
Remove the last word from a list of words, using the specified separator
When used in the following Stack expression it returns a value of type String: "foo".
> remove_last_word("foo-bar", "-")
"foo"When used as an expression in text, prepend it with an @:
> "... @remove_last_word("foo-bar", "-") ..."
"foo"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "remove_last_word(\"foo-bar\", \"-\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "foo" = result
"foo"
iex> Expression.evaluate_as_string!(
...> "@remove_last_word(\"foo-bar\", \"-\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"foo"Example 2:
Remove the last word from a list of words, using spaces as separator between words
When used in the following Stack expression it returns a value of type String: "foo".
> remove_last_word("foo bar")
"foo"When used as an expression in text, prepend it with an @:
> "... @remove_last_word("foo bar") ..."
"foo"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "remove_last_word(\"foo bar\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "foo" = result
"foo"
iex> Expression.evaluate_as_string!(
...> "@remove_last_word(\"foo bar\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"foo"Repeats text a given number of times
Example 1:
When used in the following Stack expression it returns a value of type String: "**********".
> rept("*", 10)
"**********"When used as an expression in text, prepend it with an @:
> "... @rept("*", 10) ..."
"**********"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "rept(\"*\", 10)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "**********" = result
"**********"
iex> Expression.evaluate_as_string!(
...> "@rept(\"*\", 10)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"**********"Example 2:
When used in the following Stack expression it returns a value of type Null: null.
> rept(nil, 10)
nilWhen used as an expression in text, prepend it with an @:
> "... @rept(nil, 10) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "rept(nil, 10)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@rept(nil, 10)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Returns the last characters in a text string. This is Unicode safe.
Example 1:
When used in the following Stack expression it returns a value of type String: "ing".
> right("testing", 3)
"ing"When used as an expression in text, prepend it with an @:
> "... @right("testing", 3) ..."
"ing"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "right(\"testing\", 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "ing" = result
"ing"
iex> Expression.evaluate_as_string!(
...> "@right(\"testing\", 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"ing"Example 2:
When used in the following Stack expression it returns a value of type String: "ту главы Госдепа США".
> right("Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США", 20)
"ту главы Госдепа США"When used as an expression in text, prepend it with an @:
> "... @right("Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США", 20) ..."
"ту главы Госдепа США"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "right(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "ту главы Госдепа США" = result
"ту главы Госдепа США"
iex> Expression.evaluate_as_string!(
...> "@right(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"ту главы Госдепа США"Example 3:
When used in the following Stack expression it returns a value of type Null: null.
> right(nil, 3)
nilWhen used as an expression in text, prepend it with an @:
> "... @right(nil, 3) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "right(nil, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@right(nil, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Example 1:
The ROUND function rounds a number to a specified number of digits. For example, if cell A1 contains 23.7825, and you want to round that value to two decimal places you can do ROUND(23.7825, 2)
When used in the following Stack expression it returns a value of type String: "23.78".
> ROUND(23.7825, 2)
"23.78"When used as an expression in text, prepend it with an @:
> "... @ROUND(23.7825, 2) ..."
"23.78"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "ROUND(23.7825, 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "23.78" = result
"23.78"
iex> Expression.evaluate_as_string!(
...> "@ROUND(23.7825, 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"23.78"Example 2:
The ROUND function rounds a number to a specified number of digits. For example, if cell A1 contains 23.7825, and you want to round that value to zero decimal places you can do ROUND(23.7825)
When used in the following Stack expression it returns a value of type String: "24".
> ROUND(23.7825)
"24"When used as an expression in text, prepend it with an @:
> "... @ROUND(23.7825) ..."
"24"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "ROUND(23.7825)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "24" = result
"24"
iex> Expression.evaluate_as_string!(
...> "@ROUND(23.7825)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"24"Returns only the second of a datetime (0 to 59)
Example 1:
When used in the following Stack expression it returns a value of type Integer: 40 when used with the following context:
%{"now" => ~U[2025-05-06 23:41:40.833526Z]}> second(now)
40When used as an expression in text, prepend it with an @:
> "... @second(now) ..."
"40"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "second(now)",
...> %{"now" => ~U[2025-05-06 23:41:40.833526Z]},
...> Expression.Callbacks.Standard
...> )
..$> assert 40 = result
40
..$> Expression.evaluate_as_string!(
...> "@second(now)",
...> %{"now" => ~U[2025-05-06 23:41:40.833526Z]},
...> Expression.Callbacks.Standard
...> )
"40"Sorts a list of values using the result of the sorter function
Example 1:
When used in the following Stack expression it returns a value of type List with values String, String, String:
[
"b",
"c",
"a"
].
> sort_by(["a", "b", "c"], &rand_between(1, 5))
["b", "c", "a"]When used as an expression in text, prepend it with an @:
> "... @sort_by(["a", "b", "c"], &rand_between(1, 5)) ..."
"bca"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "sort_by([\"a\", \"b\", \"c\"], &rand_between(1, 5))",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert ["b", "c", "a"] = result
["b", "c", "a"]
..$> Expression.evaluate_as_string!(
...> "@sort_by([\"a\", \"b\", \"c\"], &rand_between(1, 5))",
...> %{},
...> Expression.Callbacks.Standard
...> )
"bca"Split a string into an array using the pattern as separator. Defaults to split the string using a space.
Example 1:
When used in the following Stack expression it returns a value of type List with values String, String:
[
"testing",
"something"
].
> split("testing something")
["testing", "something"]When used as an expression in text, prepend it with an @:
> "... @split("testing something") ..."
"testingsomething"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "split(\"testing something\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["testing", "something"] = result
["testing", "something"]
iex> Expression.evaluate_as_string!(
...> "@split(\"testing something\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"testingsomething"Example 2:
When used in the following Stack expression it returns a value of type List with values String, String, String:
[
"t",
"sting som",
"thing"
].
> split("testing something", "e")
["t", "sting som", "thing"]When used as an expression in text, prepend it with an @:
> "... @split("testing something", "e") ..."
"tsting somthing"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "split(\"testing something\", \"e\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["t", "sting som", "thing"] = result
["t", "sting som", "thing"]
iex> Expression.evaluate_as_string!(
...> "@split(\"testing something\", \"e\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"tsting somthing"Substitutes new_text for old_text in a text string. If instance_num is given, then only that instance will be substituted
Example 1:
When used in the following Stack expression it returns a value of type String: "I can do".
> substitute("I can't", "can't", "can do")
"I can do"When used as an expression in text, prepend it with an @:
> "... @substitute("I can't", "can't", "can do") ..."
"I can do"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "substitute(\"I can't\", \"can't\", \"can do\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "I can do" = result
"I can do"
iex> Expression.evaluate_as_string!(
...> "@substitute(\"I can't\", \"can't\", \"can do\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"I can do"Example 2:
When used in the following Stack expression it returns a value of type Null: null.
> substitute(nil, "can't", "can do")
nilWhen used as an expression in text, prepend it with an @:
> "... @substitute(nil, "can't", "can do") ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "substitute(nil, \"can't\", \"can do\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@substitute(nil, \"can't\", \"can do\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Returns the sum of all arguments, equivalent to the + operator
You have @SUM(contact.reports, contact.forms) reports and formsExample 1:
When used in the following Stack expression it returns a value of type Integer: 6.
> sum(1, 2, 3)
6When used as an expression in text, prepend it with an @:
> "... @sum(1, 2, 3) ..."
"6"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "sum(1, 2, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 6 = result
6
iex> Expression.evaluate_as_string!(
...> "@sum(1, 2, 3)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"6"Example 1:
The SWITCH function evaluates one value (called the expression) against a list of values, and returns the result corresponding to the first matching value. If there is no match, an optional default value (the last one in the list if the list is odd) may be returned
When used in the following Stack expression it returns a value of type String: "Sunday".
> SWITCH(1, 1, "Sunday", 2, "Monday", 3, "Tuesday", "No match")
"Sunday"When used as an expression in text, prepend it with an @:
> "... @SWITCH(1, 1, "Sunday", 2, "Monday", 3, "Tuesday", "No match") ..."
"Sunday"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "SWITCH(1, 1, \"Sunday\", 2, \"Monday\", 3, \"Tuesday\", \"No match\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "Sunday" = result
"Sunday"
iex> Expression.evaluate_as_string!(
...> "@SWITCH(1, 1, \"Sunday\", 2, \"Monday\", 3, \"Tuesday\", \"No match\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"Sunday"Example 2:
The SWITCH function evaluates one value (called the expression) against a list of values, and returns the result corresponding to the first matching value. If there is no match, an optional default value (the last one in the list if the list is odd) may be returned
When used in the following Stack expression it returns a value of type String: "No match".
> SWITCH(5, 1, "Sunday", 2, "Monday", 3, "Tuesday", "No match")
"No match"When used as an expression in text, prepend it with an @:
> "... @SWITCH(5, 1, "Sunday", 2, "Monday", 3, "Tuesday", "No match") ..."
"No match"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "SWITCH(5, 1, \"Sunday\", 2, \"Monday\", 3, \"Tuesday\", \"No match\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "No match" = result
"No match"
iex> Expression.evaluate_as_string!(
...> "@SWITCH(5, 1, \"Sunday\", 2, \"Monday\", 3, \"Tuesday\", \"No match\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"No match"Defines a time value which can be used for time arithmetic
Example 1:
When used in the following Stack expression it returns a value of type Time: "12:13:14".
> time(12, 13, 14)
~T[12:13:14]When used as an expression in text, prepend it with an @:
> "... @time(12, 13, 14) ..."
"~T[12:13:14]"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "time(12, 13, 14)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~T[12:13:14] = result
~T[12:13:14]
iex> Expression.evaluate_as_string!(
...> "@time(12, 13, 14)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"~T[12:13:14]"Converts time stored in text to an actual time
Example 1:
When used in the following Stack expression it returns a value of type Time: "02:30:00".
> timevalue("2:30")
~T[02:30:00]When used as an expression in text, prepend it with an @:
> "... @timevalue("2:30") ..."
"~T[02:30:00]"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "timevalue(\"2:30\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~T[02:30:00] = result
~T[02:30:00]
iex> Expression.evaluate_as_string!(
...> "@timevalue(\"2:30\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"~T[02:30:00]"Example 2:
When used in the following Stack expression it returns a value of type Time: "02:30:55".
> timevalue("2:30:55")
~T[02:30:55]When used as an expression in text, prepend it with an @:
> "... @timevalue("2:30:55") ..."
"~T[02:30:55]"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "timevalue(\"2:30:55\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ~T[02:30:55] = result
~T[02:30:55]
iex> Expression.evaluate_as_string!(
...> "@timevalue(\"2:30:55\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"~T[02:30:55]"Returns the current date
Example 1:
When used in the following Stack expression it returns a value of type Date: "2025-05-06".
> today()
~D[2025-05-06]When used as an expression in text, prepend it with an @:
> "... @today() ..."
"2025-05-06"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "today()",
...> %{},
...> Expression.Callbacks.Standard
...> )
..$> assert ~D[2025-05-06] = result
~D[2025-05-06]
..$> Expression.evaluate_as_string!(
...> "@today()",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2025-05-06"Returns the unicode character specified by a number
Example 1:
When used in the following Stack expression it returns a value of type String: "A".
> unichar(65)
"A"When used as an expression in text, prepend it with an @:
> "... @unichar(65) ..."
"A"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "unichar(65)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "A" = result
"A"
iex> Expression.evaluate_as_string!(
...> "@unichar(65)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"A"Example 2:
When used in the following Stack expression it returns a value of type String: "é".
> unichar(233)
"é"When used as an expression in text, prepend it with an @:
> "... @unichar(233) ..."
"é"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "unichar(233)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "é" = result
"é"
iex> Expression.evaluate_as_string!(
...> "@unichar(233)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"é"Returns a numeric code for the first character in a text string
Example 1:
When used in the following Stack expression it returns a value of type Integer: 65.
> unicode("A")
65When used as an expression in text, prepend it with an @:
> "... @unicode("A") ..."
"65"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "unicode(\"A\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 65 = result
65
iex> Expression.evaluate_as_string!(
...> "@unicode(\"A\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"65"Example 2:
When used in the following Stack expression it returns a value of type Integer: 233.
> unicode("é")
233When used as an expression in text, prepend it with an @:
> "... @unicode("é") ..."
"233"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "unicode(\"é\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 233 = result
233
iex> Expression.evaluate_as_string!(
...> "@unicode(\"é\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"233"Removes duplicate values from a list.
Example 1:
When used in the following Stack expression it returns a value of type List with values String, String, String:
[
"A",
"B",
"C"
].
> uniq(["A", "B", "C", "B"])
["A", "B", "C"]When used as an expression in text, prepend it with an @:
> "... @uniq(["A", "B", "C", "B"]) ..."
"ABC"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "uniq([\"A\", \"B\", \"C\", \"B\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert ["A", "B", "C"] = result
["A", "B", "C"]
iex> Expression.evaluate_as_string!(
...> "@uniq([\"A\", \"B\", \"C\", \"B\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"ABC"Converts a text string to uppercase
Example 1:
When used in the following Stack expression it returns a value of type String: "FOO".
> upper("foo")
"FOO"When used as an expression in text, prepend it with an @:
> "... @upper("foo") ..."
"FOO"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "upper(\"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "FOO" = result
"FOO"
iex> Expression.evaluate_as_string!(
...> "@upper(\"foo\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"FOO"Example 2:
When used in the following Stack expression it returns a value of type Null: null.
> upper(nil)
nilWhen used as an expression in text, prepend it with an @:
> "... @upper(nil) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "upper(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...> "@upper(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""URL decode an expression
Example 1:
When used in the following Stack expression it returns a value of type String: "hello world".
> url_decode("hello%20world")
"hello world"When used as an expression in text, prepend it with an @:
> "... @url_decode("hello%20world") ..."
"hello world"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "url_decode(\"hello%20world\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "hello world" = result
"hello world"
iex> Expression.evaluate_as_string!(
...> "@url_decode(\"hello%20world\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"hello world"URL encode an expression
Example 1:
When used in the following Stack expression it returns a value of type String: "hello%20world".
> url_encode("hello world")
"hello%20world"When used as an expression in text, prepend it with an @:
> "... @url_encode("hello world") ..."
"hello%20world"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "url_encode(\"hello world\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "hello%20world" = result
"hello%20world"
iex> Expression.evaluate_as_string!(
...> "@url_encode(\"hello world\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"hello%20world"Returns the day of the week of a date (1 for Sunday to 7 for Saturday)
Example 1:
When used in the following Stack expression it returns a value of type Integer: 1 when used with the following context:
%{"today" => ~D[2022-11-06]}> weekday(today)
1When used as an expression in text, prepend it with an @:
> "... @weekday(today) ..."
"1"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "weekday(today)",
...> %{"today" => ~D[2022-11-06]},
...> Expression.Callbacks.Standard
...> )
iex> assert 1 = result
1
iex> Expression.evaluate_as_string!(
...> "@weekday(today)",
...> %{"today" => ~D[2022-11-06]},
...> Expression.Callbacks.Standard
...> )
"1"Example 2:
When used in the following Stack expression it returns a value of type Integer: 3 when used with the following context:
%{"today" => ~D[2022-11-01]}> weekday(today)
3When used as an expression in text, prepend it with an @:
> "... @weekday(today) ..."
"3"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "weekday(today)",
...> %{"today" => ~D[2022-11-01]},
...> Expression.Callbacks.Standard
...> )
iex> assert 3 = result
3
iex> Expression.evaluate_as_string!(
...> "@weekday(today)",
...> %{"today" => ~D[2022-11-01]},
...> Expression.Callbacks.Standard
...> )
"3"Wraps each item of the list in a new list with the item itself and its index in the original list.
Example 1:
When used in the following Stack expression it returns a value of type List with values List with values String, Integer, List with values String, Integer, List with values String, Integer:
[
[
"A",
0
],
[
"B",
1
],
[
"C",
2
]
].
> with_index(["A", "B", "C"])
[["A", 0], ["B", 1], ["C", 2]]When used as an expression in text, prepend it with an @:
> "... @with_index(["A", "B", "C"]) ..."
"A0B1C2"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "with_index([\"A\", \"B\", \"C\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert [["A", 0], ["B", 1], ["C", 2]] = result
[["A", 0], ["B", 1], ["C", 2]]
iex> Expression.evaluate_as_string!(
...> "@with_index([\"A\", \"B\", \"C\"])",
...> %{},
...> Expression.Callbacks.Standard
...> )
"A0B1C2"Extracts the nth word from the given text string. If stop is a negative number,
then it is treated as count backwards from the end of the text. If by_spaces is
specified and is true then the function splits the text into words only by spaces.
Otherwise the text is split by punctuation characters as well
Example 1:
When used in the following Stack expression it returns a value of type String: "cow".
> word("hello cow-boy", 2)
"cow"When used as an expression in text, prepend it with an @:
> "... @word("hello cow-boy", 2) ..."
"cow"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word(\"hello cow-boy\", 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "cow" = result
"cow"
iex> Expression.evaluate_as_string!(
...> "@word(\"hello cow-boy\", 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"cow"Example 2:
When used in the following Stack expression it returns a value of type String: "cow-boy".
> word("hello cow-boy", 2, true)
"cow-boy"When used as an expression in text, prepend it with an @:
> "... @word("hello cow-boy", 2, true) ..."
"cow-boy"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word(\"hello cow-boy\", 2, true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "cow-boy" = result
"cow-boy"
iex> Expression.evaluate_as_string!(
...> "@word(\"hello cow-boy\", 2, true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"cow-boy"Example 3:
When used in the following Stack expression it returns a value of type String: "boy".
> word("hello cow-boy", -1)
"boy"When used as an expression in text, prepend it with an @:
> "... @word("hello cow-boy", -1) ..."
"boy"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word(\"hello cow-boy\", -1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "boy" = result
"boy"
iex> Expression.evaluate_as_string!(
...> "@word(\"hello cow-boy\", -1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"boy"Example 4:
When used in the following Stack expression it returns a value of type String: "".
> word(nil, 1)
""When used as an expression in text, prepend it with an @:
> "... @word(nil, 1) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word(nil, 1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...> "@word(nil, 1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Returns the number of words in the given text string. If by_spaces is specified and is true then the function splits the text into words only by spaces. Otherwise the text is split by punctuation characters as well
> You entered @word_count("one two three") words
You entered 3 wordsExample 1:
When used in the following Stack expression it returns a value of type Integer: 3.
> word_count("hello cow-boy")
3When used as an expression in text, prepend it with an @:
> "... @word_count("hello cow-boy") ..."
"3"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word_count(\"hello cow-boy\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 3 = result
3
iex> Expression.evaluate_as_string!(
...> "@word_count(\"hello cow-boy\")",
...> %{},
...> Expression.Callbacks.Standard
...> )
"3"Example 2:
When used in the following Stack expression it returns a value of type Integer: 2.
> word_count("hello cow-boy", true)
2When used as an expression in text, prepend it with an @:
> "... @word_count("hello cow-boy", true) ..."
"2"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word_count(\"hello cow-boy\", true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 2 = result
2
iex> Expression.evaluate_as_string!(
...> "@word_count(\"hello cow-boy\", true)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"2"Example 3:
When used in the following Stack expression it returns a value of type Integer: 0.
> word_count(nil)
0When used as an expression in text, prepend it with an @:
> "... @word_count(nil) ..."
"0"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word_count(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert 0 = result
0
iex> Expression.evaluate_as_string!(
...> "@word_count(nil)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"0"Extracts a substring of the words beginning at start, and up to but not-including stop.
If stop is omitted then the substring will be all words from start until the end of the text.
If stop is a negative number, then it is treated as count backwards from the end of the text.
If by_spaces is specified and is true then the function splits the text into words only by spaces.
Otherwise the text is split by punctuation characters as well
Example 1:
When used in the following Stack expression it returns a value of type String: "expressions are".
> word_slice("FLOIP expressions are fun", 2, 4)
"expressions are"When used as an expression in text, prepend it with an @:
> "... @word_slice("FLOIP expressions are fun", 2, 4) ..."
"expressions are"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word_slice(\"FLOIP expressions are fun\", 2, 4)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "expressions are" = result
"expressions are"
iex> Expression.evaluate_as_string!(
...> "@word_slice(\"FLOIP expressions are fun\", 2, 4)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"expressions are"Example 2:
When used in the following Stack expression it returns a value of type String: "expressions are fun".
> word_slice("FLOIP expressions are fun", 2)
"expressions are fun"When used as an expression in text, prepend it with an @:
> "... @word_slice("FLOIP expressions are fun", 2) ..."
"expressions are fun"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word_slice(\"FLOIP expressions are fun\", 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "expressions are fun" = result
"expressions are fun"
iex> Expression.evaluate_as_string!(
...> "@word_slice(\"FLOIP expressions are fun\", 2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"expressions are fun"Example 3:
When used in the following Stack expression it returns a value of type String: "FLOIP expressions".
> word_slice("FLOIP expressions are fun", 1, -2)
"FLOIP expressions"When used as an expression in text, prepend it with an @:
> "... @word_slice("FLOIP expressions are fun", 1, -2) ..."
"FLOIP expressions"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word_slice(\"FLOIP expressions are fun\", 1, -2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "FLOIP expressions" = result
"FLOIP expressions"
iex> Expression.evaluate_as_string!(
...> "@word_slice(\"FLOIP expressions are fun\", 1, -2)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"FLOIP expressions"Example 4:
When used in the following Stack expression it returns a value of type String: "fun".
> word_slice("FLOIP expressions are fun", -1)
"fun"When used as an expression in text, prepend it with an @:
> "... @word_slice("FLOIP expressions are fun", -1) ..."
"fun"iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word_slice(\"FLOIP expressions are fun\", -1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "fun" = result
"fun"
iex> Expression.evaluate_as_string!(
...> "@word_slice(\"FLOIP expressions are fun\", -1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
"fun"Example 5:
When used in the following Stack expression it returns a value of type String: "".
> word_slice(nil, -1)
""When used as an expression in text, prepend it with an @:
> "... @word_slice(nil, -1) ..."
""iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...> "word_slice(nil, -1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...> "@word_slice(nil, -1)",
...> %{},
...> Expression.Callbacks.Standard
...> )
""Returns only the year of a date
Example 1:
When used in the following Stack expression it returns a value of type Integer: 2025 when used with the following context:
%{"now" => ~U[2025-05-06 23:41:40.836945Z]}> year(now)
2025When used as an expression in text, prepend it with an @:
> "... @year(now) ..."
"2025"..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...> "year(now)",
...> %{"now" => ~U[2025-05-06 23:41:40.836945Z]},
...> Expression.Callbacks.Standard
...> )
..$> assert 2025 = result
2025
..$> Expression.evaluate_as_string!(
...> "@year(now)",
...> %{"now" => ~U[2025-05-06 23:41:40.836945Z]},
...> Expression.Callbacks.Standard
...> )
"2025"