Expressions Reference
abs(number)
Returns the absolute value of a number
Example 1:
When used as a Stack expression it returns a value of type Integer: 1
.
card MyCard do
my_var = abs(-1)
# When used in a piece of text prefix it with an `@`
my_var = "@abs(-1)"
end
and(argument1, argument2, argument3)
Returns true
if and only if all its arguments evaluate to true
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
when used with the following context:
%{"contact" => %{"age" => 32, "gender" => "?"}}
card MyCard do
my_var = contact.gender = "F" and contact.age >= 18
# When used in a piece of text prefix it with an `@`
my_var = "@and(contact.gender = \"F\", contact.age >= 18)"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
when used with the following context:
%{"contact" => %{"age" => 32, "gender" => "F"}}
card MyCard do
my_var = contact.gender = "F" and contact.age >= 18
# When used in a piece of text prefix it with an `@`
my_var = "@and(contact.gender = \"F\", contact.age >= 18)"
end
char(code)
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 as a Stack expression it returns a value of type String: "A"
.
card MyCard do
my_var = char(65)
# When used in a piece of text prefix it with an `@`
my_var = "@char(65)"
end
clean(binary)
Removes all non-printable characters from a text string
Example 1:
When used as a Stack expression it returns a value of type String: "ABC"
when used with the following context:
%{"value" => <<65, 0, 66, 0, 67>>}
card MyCard do
my_var = clean(value)
# When used in a piece of text prefix it with an `@`
my_var = "@clean(value)"
end
code(code_ast)
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 as a Stack expression it returns a value of type Integer: 65
.
card MyCard do
my_var = code("A")
# When used in a piece of text prefix it with an `@`
my_var = "@code(\"A\")"
end
concatenate(argument1, argument2, argument3)
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 as a Stack expression it returns a value of type String: "name surname"
when used with the following context:
%{"contact" => %{"first_name" => "name", "last_name" => "surname"}}
card MyCard do
my_var = concatenate(contact.first_name, " ", contact.last_name)
# When used in a piece of text prefix it with an `@`
my_var = "@concatenate(contact.first_name, \" \", contact.last_name)"
end
count(term)
Return the number of entries in a list, string, or a map.
Example 1:
When used as a Stack expression it returns a value of type Integer: 1
when used with the following context:
%{"map" => %{"foo" => "bar"}}
card MyCard do
my_var = count(map)
# When used in a piece of text prefix it with an `@`
my_var = "@count(map)"
end
Example 2:
When used as a Stack expression it returns a value of type Integer: 3
.
card MyCard do
my_var = count("zoë")
# When used in a piece of text prefix it with an `@`
my_var = "@count(\"zoë\")"
end
Example 3:
When used as a Stack expression it returns a value of type Integer: 3
.
card MyCard do
my_var = count([1, 2, 3])
# When used in a piece of text prefix it with an `@`
my_var = "@count([1, 2, 3])"
end
date(year, month, day)
Defines a new date value
Example 1: Construct a date from year, month, and day integers
When used as a Stack expression it returns a value of type Date: ~D[2022-01-31]
when used with the following context:
%{"day" => 31, "month" => 1, "year" => 2022}
card MyCard do
my_var = date(year, month, day)
# When used in a piece of text prefix it with an `@`
my_var = "@date(year, month, day)"
end
datetime_add(datetime, offset, unit)
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: Negative offsets
When used as a Stack expression it returns a value of type DateTime: ~U[2020-02-28 00:00:00.000000Z]
.
card MyCard do
my_var = datetime_add(date(2020, 02, 29), -1, "D")
# When used in a piece of text prefix it with an `@`
my_var = "@datetime_add(date(2020, 02, 29), -1, \"D\")"
end
Example 2: Leap year handling outside of a leap year.
When used as a Stack expression it returns a value of type DateTime: ~U[2021-03-01 00:00:00.000000Z]
.
card MyCard do
my_var = datetime_add(date(2021, 02, 28), 1, "D")
# When used in a piece of text prefix it with an `@`
my_var = "@datetime_add(date(2021, 02, 28), 1, \"D\")"
end
Example 3: Leap year handling in a leap year.
When used as a Stack expression it returns a value of type DateTime: ~U[2020-02-29 00:00:00.000000Z]
.
card MyCard do
my_var = datetime_add(date(2020, 02, 28), 1, "D")
# When used in a piece of text prefix it with an `@`
my_var = "@datetime_add(date(2020, 02, 28), 1, \"D\")"
end
Example 4: Calculates a new datetime based on the offset and unit provided.
When used as a Stack expression it returns a value of type DateTime: ~U[2022-08-31 00:00:00Z]
when used with the following context:
%{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => "1", "unit" => "M"}
card MyCard do
my_var = datetime_add(datetime, offset, unit)
# When used in a piece of text prefix it with an `@`
my_var = "@datetime_add(datetime, offset, unit)"
end
datetime_next(desired_day, time, base_date)
Calculates a new datetime based on a base date, a desired day and a desired time.
Example 1: If the day of the week is the same as the base date, the next occurrence is 7 days later.
When used as a Stack expression it returns a value of type DateTime: #DateTime<2023-02-09 10:30:00-03:00 -03 America/Sao_Paulo>
when used with the following context:
%{"base_date" => ~U[2023-02-02 20:18:03Z], "contact" => %{"whatsapp_id" => "552197295926"}}
card MyCard do
my_var = datetime_next("thursday", "10:30", base_date)
# When used in a piece of text prefix it with an `@`
my_var = "@datetime_next(\"thursday\", \"10:30\", base_date)"
end
Example 2: Shifts a datetime to the next occurrence of a given day of the week and a set time.
When used as a Stack expression it returns a value of type DateTime: #DateTime<2023-02-06 10:00:00-03:00 -03 America/Sao_Paulo>
when used with the following context:
%{"base_date" => ~U[2023-02-03 20:18:03Z], "contact" => %{"whatsapp_id" => "552197295926"}}
card MyCard do
my_var = datetime_next("monday", "10:00", base_date)
# When used in a piece of text prefix it with an `@`
my_var = "@datetime_next(\"monday\", \"10:00\", base_date)"
end
datetime_next(desired_day, time)
Calculates a new datetime based on today's date and time, a desired day and a desired time.
Example 1:
When used as a Stack expression it returns a value of type DateTime: #DateTime<2023-03-11 13:45:00-03:00 -03 America/Sao_Paulo>
when used with the following context:
%{"contact" => %{"whatsapp_id" => "552197295926"}}
card MyCard do
my_var = datetime_next("saturday", "13:45")
# When used in a piece of text prefix it with an `@`
my_var = "@datetime_next(\"saturday\", \"13:45\")"
end
datevalue(date, format)
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 value and read the date field
When used as a Stack expression it returns a value of type Date: ~D[2022-01-01]
.
card MyCard do
my_var = datevalue(date(2022, 1, 1)).date
# When used in a piece of text prefix it with an `@`
my_var = "@datevalue(date(2022, 1, 1)).date"
end
Example 2: Convert a date from a piece of text and read the date field
When used as a Stack expression it returns a value of type Date: ~D[2022-01-01]
.
card MyCard do
my_var = datevalue("2022-01-01").date
# When used in a piece of text prefix it with an `@`
my_var = "@datevalue(\"2022-01-01\").date"
end
Example 3: Convert a date from a piece of text to a formatted date string
When used as a 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.
card MyCard do
my_var = datevalue("2022-01-01")
# When used in a piece of text prefix it with an `@`
my_var = "@datevalue(\"2022-01-01\")"
end
datevalue(date)
day(date)
Returns only the day of the month of a date (1 to 31)
Example 1: Getting today's day of the month
When used as a Stack expression it returns a value of type Integer: 6
.
card MyCard do
my_var = day(now())
# When used in a piece of text prefix it with an `@`
my_var = "@day(now())"
end
Example 2: Getting today's day of the month
When used as a Stack expression it returns a value of type Integer: 10
.
card MyCard do
my_var = day(date(2022, 9, 10))
# When used in a piece of text prefix it with an `@`
my_var = "@day(date(2022, 9, 10))"
end
edate(date, months)
Moves a date by the given number of months
Example 1: Move the date store in a piece of text by 1 month
When used as a Stack expression it returns a value of type Date: ~D[2022-11-10]
.
card MyCard do
my_var = edate("2022-10-10", 1)
# When used in a piece of text prefix it with an `@`
my_var = "@edate(\"2022-10-10\", 1)"
end
Example 2: Move the date in a date object by 1 month
When used as a Stack expression it returns a value of type DateTime: ~U[2022-02-01 00:00:00Z]
when used with the following context:
%{right_now: ~U[2022-01-01 00:00:00Z]}
card MyCard do
my_var = edate(right_now, 1)
# When used in a piece of text prefix it with an `@`
my_var = "@edate(right_now, 1)"
end
filter(enumerable, filter_fun)
Filters a list by returning a new list that contains only the
elements for which filter_fun
is truthy.
Example 1:
When used as a Stack expression it returns a value of type List with values String, String: ["B", "B"]
.
card MyCard do
my_var = filter(["A", "B", "C", "B"], & &1 == "B")
# When used in a piece of text prefix it with an `@`
my_var = "@filter([\"A\", \"B\", \"C\", \"B\"], & &1 == \"B\")"
end
find(enumerable, find_fun)
Finds the first element in the list for which filter_fun
is truthy.
Example 1:
When used as a Stack expression it returns a value of type List with values String, String: ["Hi", "World"]
.
card MyCard do
my_var = find([["Hello", "World"], ["Hi", "World"]], & &1[0] == "Hi")
# When used in a piece of text prefix it with an `@`
my_var = "@find([[\"Hello\", \"World\"], [\"Hi\", \"World\"]], & &1[0] == \"Hi\")"
end
find_exact_match(input, keyword_set)
Find if there is an exact match to keyword set. The keywords may be numbers.
Example 1:
When used as a Stack expression it returns a value of type String: "apple"
.
card MyCard do
my_var = find_exact_match("apple", ["apple", "orange", "beets"])
# When used in a piece of text prefix it with an `@`
my_var = "@find_exact_match(\"apple\", [\"apple\", \"orange\", \"beets\"])"
end
find_fuzzy_matches(input, keyword_threshold_set)
Find the fuzzy matches to the keyword_threshold set. Each keyword has its own threshold.
Example 1:
When used as a Stack expression it returns a complex String type of default value:
"apple"
with the following fields:
- match of type String
- others of type List with values Map
- threshold of type Integer.
card MyCard do
my_var = find_fuzzy_matches("appls", [["apple", 1], ["app", 2]])
# When used in a piece of text prefix it with an `@`
my_var = "@find_fuzzy_matches(\"appls\", [[\"apple\", 1], [\"app\", 2]])"
end
find_fuzzy_matches(input, keyword_set, threshold)
Find the fuzzy matches to the keywords using the same threshold for all keywords
Example 1:
When used as a Stack expression it returns a complex String type of default value:
"pear"
with the following fields:
- match of type String
- others of type List with values
- threshold of type Integer.
card MyCard do
my_var = find_fuzzy_matches("pork", ["apple", "orange", "pear"], 3)
# When used in a piece of text prefix it with an `@`
my_var = "@find_fuzzy_matches(\"pork\", [\"apple\", \"orange\", \"pear\"], 3)"
end
first_word(binary)
Returns the first word in the given text - equivalent to WORD(text, 1)
Example 1:
When used as a Stack expression it returns a value of type String: "foo"
.
card MyCard do
my_var = first_word("foo bar baz")
# When used in a piece of text prefix it with an `@`
my_var = "@first_word(\"foo bar baz\")"
end
fixed(number, precision)
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 as a Stack expression it returns a value of type String: "3.80"
.
card MyCard do
my_var = fixed(3.7979, 2)
# When used in a piece of text prefix it with an `@`
my_var = "@fixed(3.7979, 2)"
end
Example 2:
When used as a Stack expression it returns a value of type String: "3.80"
.
card MyCard do
my_var = fixed(3.7979, 2, false)
# When used in a piece of text prefix it with an `@`
my_var = "@fixed(3.7979, 2, false)"
end
Example 3:
When used as a Stack expression it returns a value of type String: "4,000.4242"
.
card MyCard do
my_var = fixed(4000.424242, 4, true)
# When used in a piece of text prefix it with an `@`
my_var = "@fixed(4000.424242, 4, true)"
end
Example 4:
When used as a Stack expression it returns a value of type String: "4.21"
.
card MyCard do
my_var = fixed(4.209922, 2, false)
# When used in a piece of text prefix it with an `@`
my_var = "@fixed(4.209922, 2, false)"
end
fixed(number, precision, no_commas)
get_brief(phrase)
Extract the first few characters of the utterance, defaults to 20 characters
Example 1:
When used as a Stack expression it returns a value of type String: "this is a very lo..."
.
card MyCard do
my_var = get_brief("this is a very long sentence")
# When used in a piece of text prefix it with an `@`
my_var = "@get_brief(\"this is a very long sentence\")"
end
get_brief(phrase, num_chars)
Extract the first few characters of the utterance until the limit specified
Example 1:
When used as a Stack expression it returns a value of type String: "this is..."
.
card MyCard do
my_var = get_brief("this is a very long sentence", 10)
# When used in a piece of text prefix it with an `@`
my_var = "@get_brief(\"this is a very long sentence\", 10)"
end
get_collected_data()
Capture all data related to the current flow execution such as processed messages, contact details and number information.
> get_collected_data()
%{
"contacts" => [
%{"profile" => %{"name" => "John Doe"}, "wa_id" => "1234567890"}
],
"messages" => [
%{"text" => %{"body" => "hi"}},
%{
"type" => "image",
"image" => %{
"caption" => "What is your name?"
}
},
%{"text" => %{"body" => "user message"}}
],
"thread" => %{"contact" => %{"name" => "John Doe"}}
}
get_write_results_data(=)
Get the flow results captured for the current contact in the current stack.
This only works for production numbers.
The simulator does not write a %StackContainerState{}
record and so this
query fails in the simulator if we attempt to load flow results for it.
The second implementation of this function, further down, handles the scenario where there is no session-uuid supplied which is the case for the simulator.
> get_write_results_data()
%{
"chat" => "current chat...",
"contact" => "current contact...",
"number" => "current number...",
"stack" => "current stack...",
"session" => "current session object...",
"results" => [
%{
"question_id" => "question unique-id...",
"question" => "the question...",
"response" => "the response...",
"response_metadata" => "the response metadata..."
}
]
}
get_write_results_data()
has_all_words(haystack, words)
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 as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_all_words("the quick brown FOX", "red fox")
# When used in a piece of text prefix it with an `@`
my_var = "@has_all_words(\"the quick brown FOX\", \"red fox\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_all_words("the quick brown FOX", "the fox")
# When used in a piece of text prefix it with an `@`
my_var = "@has_all_words(\"the quick brown FOX\", \"the fox\")"
end
has_any_word(haystack, words)
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 as a Stack expression it returns a complex Boolean type of default value:
false
with the following fields:
- match of type Null.
card MyCard do
my_var = has_any_word("The Quick Brown Fox", "yellow")
# When used in a piece of text prefix it with an `@`
my_var = "@has_any_word(\"The Quick Brown Fox\", \"yellow\")"
end
Example 2:
When used as a Stack expression it returns a complex Boolean type of default value:
true
with the following fields:
- match of type String.
card MyCard do
my_var = has_any_word("The Quick Brown Fox", "fox quick")
# When used in a piece of text prefix it with an `@`
my_var = "@has_any_word(\"The Quick Brown Fox\", \"fox quick\")"
end
has_beginning(text, beginning)
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 as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_beginning("The Quick Brown", "quick brown")
# When used in a piece of text prefix it with an `@`
my_var = "@has_beginning(\"The Quick Brown\", \"quick brown\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_beginning("The Quick Brown", "the quick")
# When used in a piece of text prefix it with an `@`
my_var = "@has_beginning(\"The Quick Brown\", \"the quick\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_beginning("The Quick Brown", "the quick")
# When used in a piece of text prefix it with an `@`
my_var = "@has_beginning(\"The Quick Brown\", \"the quick\")"
end
has_date(expression)
Tests whether expression
contains a date formatted according to our environment
This is very naively implemented with a regular expression.
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_date("there is no date here, just a year 2017")
# When used in a piece of text prefix it with an `@`
my_var = "@has_date(\"there is no date here, just a year 2017\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_date("the date is 15/01/2017")
# When used in a piece of text prefix it with an `@`
my_var = "@has_date(\"the date is 15/01/2017\")"
end
has_date_eq(expression, date_string)
Tests whether expression
is a date equal to date_string
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_date_eq("there is no date here, just a year 2017", "2017-01-15")
# When used in a piece of text prefix it with an `@`
my_var = "@has_date_eq(\"there is no date here, just a year 2017\", \"2017-01-15\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_date_eq("the date is 15/01/2017", "2017-01-15")
# When used in a piece of text prefix it with an `@`
my_var = "@has_date_eq(\"the date is 15/01/2017\", \"2017-01-15\")"
end
has_date_gt(expression, date_string)
Tests whether expression
is a date after the date date_string
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_date_gt("the date is 15/01/2017", "2017-03-15")
# When used in a piece of text prefix it with an `@`
my_var = "@has_date_gt(\"the date is 15/01/2017\", \"2017-03-15\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_date_gt("the date is 15/01/2017", "2017-01-01")
# When used in a piece of text prefix it with an `@`
my_var = "@has_date_gt(\"the date is 15/01/2017\", \"2017-01-01\")"
end
has_date_lt(expression, date_string)
Tests whether expression
contains a date before the date date_string
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_date_lt("the date is 15/01/2021", "2017-03-15")
# When used in a piece of text prefix it with an `@`
my_var = "@has_date_lt(\"the date is 15/01/2021\", \"2017-03-15\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_date_lt("the date is 15/01/2017", "2017-06-01")
# When used in a piece of text prefix it with an `@`
my_var = "@has_date_lt(\"the date is 15/01/2017\", \"2017-06-01\")"
end
has_email(expression)
Tests whether an email is contained in text
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_email("i'm not sharing my email")
# When used in a piece of text prefix it with an `@`
my_var = "@has_email(\"i'm not sharing my email\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_email("my email is foo1@bar.com, please respond")
# When used in a piece of text prefix it with an `@`
my_var = "@has_email(\"my email is foo1@bar.com, please respond\")"
end
has_group(groups, uuid)
Returns whether the contact is part of group with the passed in UUID
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
when used with the following context:
%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}
card MyCard do
my_var = has_group(contact.groups, "00000000-0000-0000-0000-000000000000")
# When used in a piece of text prefix it with an `@`
my_var = "@has_group(contact.groups, \"00000000-0000-0000-0000-000000000000\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
when used with the following context:
%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}
card MyCard do
my_var = has_group(contact.groups, "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d")
# When used in a piece of text prefix it with an `@`
my_var = "@has_group(contact.groups, \"b7cf0d83-f1c9-411c-96fd-c511a4cfa86d\")"
end
has_number(expression)
Tests whether expression
contains a number
Example 1:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number("0.6")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number(\"0.6\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number("٠.٥")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number(\"٠.٥\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number("العدد ٤٢")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number(\"العدد ٤٢\")"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number("the number is 42 and 5")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number(\"the number is 42 and 5\")"
end
has_number_eq(expression, float)
Tests whether expression
contains a number equal to the value
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_eq("four hundred", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_eq(\"four hundred\", \"foo\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_eq("the number is 40", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_eq(\"the number is 40\", \"foo\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_eq("the number is 40", "42")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_eq(\"the number is 40\", \"42\")"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_eq("the number is 42.0", "42")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_eq(\"the number is 42.0\", \"42\")"
end
Example 5:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_eq("the number is 42", "42")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_eq(\"the number is 42\", \"42\")"
end
Example 6:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_eq("the number is 42", 42.0)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_eq(\"the number is 42\", 42.0)"
end
Example 7:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_eq("the number is 42", 42)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_eq(\"the number is 42\", 42)"
end
has_number_gt(expression, float)
Tests whether expression
contains a number greater than min
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_gt("four hundred", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gt(\"four hundred\", \"foo\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_gt("the number is 40", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gt(\"the number is 40\", \"foo\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_gt("the number is 40", "40")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gt(\"the number is 40\", \"40\")"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_gt("the number is 42.0", "40")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gt(\"the number is 42.0\", \"40\")"
end
Example 5:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_gt("the number is 42", "40")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gt(\"the number is 42\", \"40\")"
end
Example 6:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_gt("the number is 42", 40.0)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gt(\"the number is 42\", 40.0)"
end
Example 7:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_gt("the number is 42", 40)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gt(\"the number is 42\", 40)"
end
has_number_gte(expression, float)
Tests whether expression
contains a number greater than or equal to min
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_gte("four hundred", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gte(\"four hundred\", \"foo\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_gte("the number is 40", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gte(\"the number is 40\", \"foo\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_gte("the number is 40", "45")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gte(\"the number is 40\", \"45\")"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_gte("the number is 42.0", "45")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gte(\"the number is 42.0\", \"45\")"
end
Example 5:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_gte("the number is 42", "42")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gte(\"the number is 42\", \"42\")"
end
Example 6:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_gte("the number is 42", 42.0)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gte(\"the number is 42\", 42.0)"
end
Example 7:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_gte("the number is 42", 42)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_gte(\"the number is 42\", 42)"
end
has_number_lt(expression, float)
Tests whether expression
contains a number less than max
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_lt("four hundred", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lt(\"four hundred\", \"foo\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_lt("the number is 40", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lt(\"the number is 40\", \"foo\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_lt("the number is 40", "40")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lt(\"the number is 40\", \"40\")"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_lt("the number is 42.0", "40")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lt(\"the number is 42.0\", \"40\")"
end
Example 5:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_lt("the number is 42", "40")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lt(\"the number is 42\", \"40\")"
end
Example 6:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_lt("the number is 42", 44.0)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lt(\"the number is 42\", 44.0)"
end
Example 7:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_lt("the number is 42", 44)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lt(\"the number is 42\", 44)"
end
has_number_lte(expression, float)
Tests whether expression
contains a number less than or equal to max
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_lte("four hundred", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lte(\"four hundred\", \"foo\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_lte("the number is 40", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lte(\"the number is 40\", \"foo\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_number_lte("the number is 42.0", "40")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lte(\"the number is 42.0\", \"40\")"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_lte("the number is 42", "42")
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lte(\"the number is 42\", \"42\")"
end
Example 5:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_lte("the number is 42", 42.0)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lte(\"the number is 42\", 42.0)"
end
Example 6:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_number_lte("the number is 42", 42)
# When used in a piece of text prefix it with an `@`
my_var = "@has_number_lte(\"the number is 42\", 42)"
end
has_only_phrase(expression, phrase)
Tests whether the text contains only phrase
The phrase must be the only text in the text to match
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_only_phrase("The Quick Brown Fox", "quick brown")
# When used in a piece of text prefix it with an `@`
my_var = "@has_only_phrase(\"The Quick Brown Fox\", \"quick brown\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_only_phrase("", "")
# When used in a piece of text prefix it with an `@`
my_var = "@has_only_phrase(\"\", \"\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_only_phrase("Quick Brown", "quick brown")
# When used in a piece of text prefix it with an `@`
my_var = "@has_only_phrase(\"Quick Brown\", \"quick brown\")"
end
has_only_text(expression_one, expression_two)
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 as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_only_text("foo", "FOO")
# When used in a piece of text prefix it with an `@`
my_var = "@has_only_text(\"foo\", \"FOO\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_only_text("", "")
# When used in a piece of text prefix it with an `@`
my_var = "@has_only_text(\"\", \"\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_only_text("foo", "foo")
# When used in a piece of text prefix it with an `@`
my_var = "@has_only_text(\"foo\", \"foo\")"
end
has_pattern(expression, pattern)
Tests whether expression
matches the regex pattern
Both text values are trimmed of surrounding whitespace and matching is case-insensitive.
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_pattern("Sell cheese please", "buy (\w+)")
# When used in a piece of text prefix it with an `@`
my_var = "@has_pattern(\"Sell cheese please\", \"buy (\w+)\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_pattern("Buy cheese please", "buy (\w+)")
# When used in a piece of text prefix it with an `@`
my_var = "@has_pattern(\"Buy cheese please\", \"buy (\w+)\")"
end
has_phone(expression)
Tests whether expresssion
contains a phone number.
The optional country_code argument specifies the country to use for parsing.
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_phone("my number is none of your business", "US")
# When used in a piece of text prefix it with an `@`
my_var = "@has_phone(\"my number is none of your business\", \"US\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_phone("my number is 206 779 9294 thanks", "US")
# When used in a piece of text prefix it with an `@`
my_var = "@has_phone(\"my number is 206 779 9294 thanks\", \"US\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_phone("my number is 2067799294 thanks", "US")
# When used in a piece of text prefix it with an `@`
my_var = "@has_phone(\"my number is 2067799294 thanks\", \"US\")"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_phone("my number is +12067799294 thanks")
# When used in a piece of text prefix it with an `@`
my_var = "@has_phone(\"my number is +12067799294 thanks\")"
end
has_phone(expression, country_code)
has_phrase(expression, phrase)
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 as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_phrase("the quick brown fox", "")
# When used in a piece of text prefix it with an `@`
my_var = "@has_phrase(\"the quick brown fox\", \"\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_phrase("the quick brown fox", "quick fox")
# When used in a piece of text prefix it with an `@`
my_var = "@has_phrase(\"the quick brown fox\", \"quick fox\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_phrase("the quick brown fox", "brown fox")
# When used in a piece of text prefix it with an `@`
my_var = "@has_phrase(\"the quick brown fox\", \"brown fox\")"
end
has_text(expression)
Tests whether there the expression
has any characters in it
Example 1:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_text(123)
# When used in a piece of text prefix it with an `@`
my_var = "@has_text(123)"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_text("
")
# When used in a piece of text prefix it with an `@`
my_var = "@has_text(\"
\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_text("")
# When used in a piece of text prefix it with an `@`
my_var = "@has_text(\"\")"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = has_text("quick brown")
# When used in a piece of text prefix it with an `@`
my_var = "@has_text(\"quick brown\")"
end
has_time(expression)
Tests whether expression
contains a time.
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = has_time("there is no time here, just the number 25")
# When used in a piece of text prefix it with an `@`
my_var = "@has_time(\"there is no time here, just the number 25\")"
end
Example 2:
When used as a Stack expression it returns a complex Boolean type of default value:
true
with the following fields:
- match of type Time.
card MyCard do
my_var = has_time("the time is 10:30:45")
# When used in a piece of text prefix it with an `@`
my_var = "@has_time(\"the time is 10:30:45\")"
end
Example 3:
When used as a Stack expression it returns a complex Boolean type of default value:
true
with the following fields:
- match of type Time.
card MyCard do
my_var = has_time("the time is 10:00 pm")
# When used in a piece of text prefix it with an `@`
my_var = "@has_time(\"the time is 10:00 pm\")"
end
Example 4:
When used as a Stack expression it returns a complex Boolean type of default value:
true
with the following fields:
- match of type Time.
card MyCard do
my_var = has_time("the time is 10:30")
# When used in a piece of text prefix it with an `@`
my_var = "@has_time(\"the time is 10:30\")"
end
hour(date)
Returns only the hour of a datetime (0 to 23)
Example 1: Get the current hour
When used as a Stack expression it returns a value of type Integer: 0
.
card MyCard do
my_var = hour(now())
# When used in a piece of text prefix it with an `@`
my_var = "@hour(now())"
end
html_to_markdown(html)
Does a best effort at converting an HTML fragment into Markdown suitable for use in a WhatsApp conversation
Example 1:
When used as a Stack expression it returns a value of type String: "*hi*"
when used with the following context:
%{"html" => "<b>hi</b>"}
card MyCard do
my_var = html_to_markdown(html)
# When used in a piece of text prefix it with an `@`
my_var = "@html_to_markdown(html)"
end
if(condition, yes, no)
Returns one value if the condition evaluates to true
, and another value if it evaluates to false
Example 1:
When used as a Stack expression it returns a value of type String: "No"
.
card MyCard do
my_var = # Shorthand
if(false, do: "Yes", else: "No")
# When used in a piece of text prefix it with an `@`
my_var = "@if(false, \"Yes\", \"No\")"
end
Example 2:
When used as a Stack expression it returns a value of type String: "Yes"
.
card MyCard do
my_var = if true do
"Yes"
else
"No"
end
# When used in a piece of text prefix it with an `@`
my_var = "@if(true, \"Yes\", \"No\")"
end
isbool(var)
Returns true
if the argument is a boolean.
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = isbool("false")
# When used in a piece of text prefix it with an `@`
my_var = "@isbool(\"false\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = isbool("true")
# When used in a piece of text prefix it with an `@`
my_var = "@isbool(\"true\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = isbool(0)
# When used in a piece of text prefix it with an `@`
my_var = "@isbool(0)"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = isbool(1)
# When used in a piece of text prefix it with an `@`
my_var = "@isbool(1)"
end
Example 5:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = isbool(false)
# When used in a piece of text prefix it with an `@`
my_var = "@isbool(false)"
end
Example 6:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = isbool(true)
# When used in a piece of text prefix it with an `@`
my_var = "@isbool(true)"
end
isnumber(var)
Returns true
if the argument is a number.
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = isnumber("a")
# When used in a piece of text prefix it with an `@`
my_var = "@isnumber(\"a\")"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = isnumber("1.0")
# When used in a piece of text prefix it with an `@`
my_var = "@isnumber(\"1.0\")"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = isnumber(1.0)
# When used in a piece of text prefix it with an `@`
my_var = "@isnumber(1.0)"
end
Example 4:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = isnumber(1)
# When used in a piece of text prefix it with an `@`
my_var = "@isnumber(1)"
end
isstring(binary)
Returns true
if the argument is a string.
Example 1:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = isstring(1)
# When used in a piece of text prefix it with an `@`
my_var = "@isstring(1)"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = isstring(false)
# When used in a piece of text prefix it with an `@`
my_var = "@isstring(false)"
end
Example 3:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = isstring("hello")
# When used in a piece of text prefix it with an `@`
my_var = "@isstring(\"hello\")"
end
json(data)
Converts a data structure to JSON
Example 1:
When used as a Stack expression it returns a value of type String: "{\"foo\":\"bar\"}"
when used with the following context:
%{"data" => %{"foo" => "bar"}}
card MyCard do
my_var = json(data)
# When used in a piece of text prefix it with an `@`
my_var = "@json(data)"
end
left(binary, size)
Returns the first characters in a text string. This is Unicode safe.
Example 1:
When used as a Stack expression it returns a value of type String: "Умерла Мадлен Олбрай"
.
card MyCard do
my_var = left("Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США", 20)
# When used in a piece of text prefix it with an `@`
my_var = "@left(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20)"
end
Example 2:
When used as a Stack expression it returns a value of type String: "foob"
.
card MyCard do
my_var = left("foobar", 4)
# When used in a piece of text prefix it with an `@`
my_var = "@left(\"foobar\", 4)"
end
len(binary)
Returns the number of characters in a text string
Example 1:
When used as a Stack expression it returns a value of type Integer: 3
.
card MyCard do
my_var = len("zoë")
# When used in a piece of text prefix it with an `@`
my_var = "@len(\"zoë\")"
end
Example 2:
When used as a Stack expression it returns a value of type Integer: 3
.
card MyCard do
my_var = len("foo")
# When used in a piece of text prefix it with an `@`
my_var = "@len(\"foo\")"
end
levenshtein_distance(first_phrase, second_phrase)
Calculate the Levenshtein edit distance.
Example 1:
When used as a Stack expression it returns a value of type Integer: 3
.
card MyCard do
my_var = levenshtein_distance("shalom", "salaam")
# When used in a piece of text prefix it with an `@`
my_var = "@levenshtein_distance(\"shalom\", \"salaam\")"
end
lower(binary)
Converts a text string to lowercase
Example 1:
When used as a Stack expression it returns a value of type String: "foo bar"
.
card MyCard do
my_var = lower("Foo Bar")
# When used in a piece of text prefix it with an `@`
my_var = "@lower(\"Foo Bar\")"
end
map(enumerable, mapper)
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, multiple each by itself and return the result
When used as a Stack expression it returns a value of type List with values Integer, Integer, Integer: [1, 4, 9]
.
card MyCard do
my_var = map(1..3, &(&1 * &1))
# When used in a piece of text prefix it with an `@`
my_var = "@map(1..3, &(&1 * &1))"
end
Example 2: Map over the range of numbers, create a date in January for every number
When used as a Stack expression it returns a value of type List with values Date, Date, Date: [~D[2022-01-01], ~D[2022-01-02], ~D[2022-01-03]]
.
card MyCard do
my_var = map(1..3, &date(2022, 1, &1))
# When used in a piece of text prefix it with an `@`
my_var = "@map(1..3, &date(2022, 1, &1))"
end
max(argument1, argument2, argument3)
Returns the maximum value of all arguments
Example 1:
When used as a Stack expression it returns a value of type Integer: 3
.
card MyCard do
my_var = max(1, 2, 3)
# When used in a piece of text prefix it with an `@`
my_var = "@max(1, 2, 3)"
end
min(argument1, argument2, argument3)
Returns the minimum value of all arguments
Example 1:
When used as a Stack expression it returns a value of type Integer: 1
.
card MyCard do
my_var = min(1, 2, 3)
# When used in a piece of text prefix it with an `@`
my_var = "@min(1, 2, 3)"
end
minute(date)
Returns only the minute of a datetime (0 to 59)
Example 1: Get the current minute
When used as a Stack expression it returns a value of type Integer: 51
.
card MyCard do
my_var = minute(now())
# When used in a piece of text prefix it with an `@`
my_var = "@minute(now())"
end
month(date)
Returns only the month of a date (1 to 12)
Example 1: Get the current month
When used as a Stack expression it returns a value of type Integer: 3
.
card MyCard do
my_var = month(now())
# When used in a piece of text prefix it with an `@`
my_var = "@month(now())"
end
normalise_text(phrase)
Normalize text using Unicode NFKC (Normalisation Form Compatibility Composition) normalisation.
Accepts unicode multibyte characters and attempts to normalise them.
Example 1:
When used as a Stack expression it returns a value of type String: "abcABC"
when used with the following context:
%{"phrase" => "abcABC"}
card MyCard do
my_var = normalise_text(phrase)
# When used in a piece of text prefix it with an `@`
my_var = "@normalise_text(phrase)"
end
normalise_whitespace(phrase)
Normalise whitespace by replacing spans of whitespace with a single space
Example 1:
When used as a Stack expression it returns a value of type String: "hello world"
.
card MyCard do
my_var = normalise_whitespace("hello world")
# When used in a piece of text prefix it with an `@`
my_var = "@normalise_whitespace(\"hello world\")"
end
not(argument)
Returns false
if the argument supplied evaluates to truth-y
Example 1:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = not(false)
# When used in a piece of text prefix it with an `@`
my_var = "@not(false)"
end
now()
Returns the current date time as UTC
It is currently @NOW()
Example 1: return the current datetime and format it using datevalue
When used as a Stack expression it returns a complex String type of default value:
"2023-03-06"
with the following fields:
- date of type DateTime.
card MyCard do
my_var = datevalue(now(), "%Y-%m-%d")
# When used in a piece of text prefix it with an `@`
my_var = "@datevalue(now(), \"%Y-%m-%d\")"
end
Example 2: return the current timestamp as a DateTime value
When used as a Stack expression it returns a value of type DateTime: ~U[2023-03-06 00:51:16.144292Z]
.
card MyCard do
my_var = now()
# When used in a piece of text prefix it with an `@`
my_var = "@now()"
end
or(argument1, argument2, argument3)
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:
When used as a Stack expression it returns a value of type Boolean: false
.
card MyCard do
my_var = false or false
# When used in a piece of text prefix it with an `@`
my_var = "@or(false, false)"
end
Example 2:
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = true or true
# When used in a piece of text prefix it with an `@`
my_var = "@or(true, true)"
end
Example 3: Return the first value that is truthy
When used as a Stack expression it returns a value of type String: "foo"
.
card MyCard do
my_var = false or "foo"
# When used in a piece of text prefix it with an `@`
my_var = "@or(false, \"foo\")"
end
Example 4: Return true if any of the values are true
When used as a Stack expression it returns a value of type Boolean: true
.
card MyCard do
my_var = true or false
# When used in a piece of text prefix it with an `@`
my_var = "@or(true, false)"
end
parse_float(number)
parse_float(binary)
parse_json(data)
Parses a string as JSON
Example 1:
When used as a Stack expression it returns a value of type List with values Integer, Integer, Integer: [1, 2, 3]
.
card MyCard do
my_var = parse_json('[1,2,3]')
# When used in a piece of text prefix it with an `@`
my_var = "@parse_json('[1,2,3]')"
end
percent(float)
Formats a number as a percentage
Example 1:
When used as a Stack expression it returns a value of type String: "20%"
when used with the following context:
%{"d" => "0.2"}
card MyCard do
my_var = percent(d)
# When used in a piece of text prefix it with an `@`
my_var = "@percent(d)"
end
Example 2:
When used as a Stack expression it returns a value of type String: "20%"
.
card MyCard do
my_var = percent(0.2)
# When used in a piece of text prefix it with an `@`
my_var = "@percent(0.2)"
end
Example 3:
When used as a Stack expression it returns a value of type String: "20%"
.
card MyCard do
my_var = percent(2/10)
# When used in a piece of text prefix it with an `@`
my_var = "@percent(2/10)"
end
power(a, b)
Returns the result of a number raised to a power - equivalent to the ^ operator
Example 1:
When used as a Stack expression it returns a value of type Float: 8.0
.
card MyCard do
my_var = power(2, 3)
# When used in a piece of text prefix it with an `@`
my_var = "@power(2, 3)"
end
proper(binary)
Capitalizes the first letter of every word in a text string
Example 1:
When used as a Stack expression it returns a value of type String: "Foo Bar"
.
card MyCard do
my_var = proper("foo bar")
# When used in a piece of text prefix it with an `@`
my_var = "@proper(\"foo bar\")"
end
rand_between(min, max)
Generate a random number between min
and max
Example 1: Generate a number between 1 and 10
When used as a Stack expression it returns a value of type Integer: 8
.
card MyCard do
my_var = rand_between(1, 10)
# When used in a piece of text prefix it with an `@`
my_var = "@rand_between(1, 10)"
end
read_digits(binary)
Formats digits in text for reading in TTS
Example 1:
When used as a Stack expression it returns a value of type String: "plus two seven one"
.
card MyCard do
my_var = read_digits("+271")
# When used in a piece of text prefix it with an `@`
my_var = "@read_digits(\"+271\")"
end
reduce(enumerable, accumulator, reducer)
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 as a Stack expression it returns a value of type Integer: 6
.
card MyCard do
my_var = reduce(1..3, 0, & &1 + &2)
# When used in a piece of text prefix it with an `@`
my_var = "@reduce(1..3, 0, & &1 + &2)"
end
regex_capture(binary, pattern)
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 as a Stack expression it returns a value of type Null: nil
.
card MyCard do
my_var = regex_capture("testing", "foo(.+)")
# When used in a piece of text prefix it with an `@`
my_var = "@regex_capture(\"testing\", \"foo(.+)\")"
end
Example 2:
When used as a Stack expression it returns a value of type List with values String: ["ing"]
.
card MyCard do
my_var = regex_capture("testing", "test(.+)")
# When used in a piece of text prefix it with an `@`
my_var = "@regex_capture(\"testing\", \"test(.+)\")"
end
regex_named_capture(binary, pattern)
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 as a Stack expression it returns a value of type Map: %{}
.
card MyCard do
my_var = regex_named_capture("testing", "foo(?P<match>.+)")
# When used in a piece of text prefix it with an `@`
my_var = "@regex_named_capture(\"testing\", \"foo(?P<match>.+)\")"
end
Example 2:
When used as a Stack expression it returns a value of type Map: %{"match" => "ing"}
.
card MyCard do
my_var = regex_named_capture("testing", "test(?P<match>.+)")
# When used in a piece of text prefix it with an `@`
my_var = "@regex_named_capture(\"testing\", \"test(?P<match>.+)\")"
end
reject(enumerable, reject_fun)
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 as a Stack expression it returns a value of type List with values String, String: ["A", "C"]
.
card MyCard do
my_var = reject(["A", "B", "C", "B"], & &1 == "B")
# When used in a piece of text prefix it with an `@`
my_var = "@reject([\"A\", \"B\", \"C\", \"B\"], & &1 == \"B\")"
end
rem(integer1, integer2)
Return the division remainder of two integers.
Example 1:
When used as a Stack expression it returns a value of type Integer: 1
.
card MyCard do
my_var = rem(85, 3)
# When used in a piece of text prefix it with an `@`
my_var = "@rem(85, 3)"
end
Example 2:
When used as a Stack expression it returns a value of type Integer: 0
.
card MyCard do
my_var = rem(4, 2)
# When used in a piece of text prefix it with an `@`
my_var = "@rem(4, 2)"
end
remove_emojis(phrase)
Remove emojis from a string. Replaces it with a symbol rather than remove it completely for the following emojis: 0️⃣ 1️⃣ 2️⃣ 3️⃣ 4️⃣ 5️⃣ 6️⃣ 7️⃣ 8️⃣ 9️⃣ #️⃣ *️⃣ ©️ ®️
Example 1:
When used as a Stack expression it returns a value of type String: "1 2 3 Turn loves you "
.
card MyCard do
my_var = remove_emojis("1️⃣ 2️⃣ 3️⃣ Turn loves you ❤️")
# When used in a piece of text prefix it with an `@`
my_var = "@remove_emojis(\"1️⃣ 2️⃣ 3️⃣ Turn loves you ❤️\")"
end
remove_first_word(binary)
Removes the first word from the given text. The remaining text will be unchanged
Example 1:
When used as a Stack expression it returns a value of type String: "bar"
.
card MyCard do
my_var = remove_first_word("foo-bar", "-")
# When used in a piece of text prefix it with an `@`
my_var = "@remove_first_word(\"foo-bar\", \"-\")"
end
Example 2:
When used as a Stack expression it returns a value of type String: "bar"
.
card MyCard do
my_var = remove_first_word("foo bar")
# When used in a piece of text prefix it with an `@`
my_var = "@remove_first_word(\"foo bar\")"
end
remove_first_word(binary, separator)
remove_numbers(phrase)
Remove numbers
Example 1:
When used as a Stack expression it returns a value of type String: "counting down "
.
card MyCard do
my_var = remove_numbers("counting down 3 2 1")
# When used in a piece of text prefix it with an `@`
my_var = "@remove_numbers(\"counting down 3 2 1\")"
end
remove_punc(phrase)
Remove punctuation without substitution
Example 1:
When used as a Stack expression it returns a value of type String: "hello world"
.
card MyCard do
my_var = remove_punc("hello? world!")
# When used in a piece of text prefix it with an `@`
my_var = "@remove_punc(\"hello? world!\")"
end
replace_punc(phrase)
Replace punctuation marks with spaces
Example 1:
When used as a Stack expression it returns a value of type String: "hello world "
.
card MyCard do
my_var = replace_punc("hello? world!")
# When used in a piece of text prefix it with an `@`
my_var = "@replace_punc(\"hello? world!\")"
end
rept(value, amount)
Repeats text a given number of times
Example 1:
When used as a Stack expression it returns a value of type String: "**********"
.
card MyCard do
my_var = rept("*", 10)
# When used in a piece of text prefix it with an `@`
my_var = "@rept(\"*\", 10)"
end
right(binary, size)
Returns the last characters in a text string. This is Unicode safe.
Example 1:
When used as a Stack expression it returns a value of type String: "ту главы Госдепа США"
.
card MyCard do
my_var = right("Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США", 20)
# When used in a piece of text prefix it with an `@`
my_var = "@right(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20)"
end
Example 2:
When used as a Stack expression it returns a value of type String: "ing"
.
card MyCard do
my_var = right("testing", 3)
# When used in a piece of text prefix it with an `@`
my_var = "@right(\"testing\", 3)"
end
second(date)
Returns only the second of a datetime (0 to 59)
Example 1:
When used as a Stack expression it returns a value of type Integer: 13
when used with the following context:
%{"now" => ~U[2023-03-03 01:54:13.491227Z]}
card MyCard do
my_var = second(now)
# When used in a piece of text prefix it with an `@`
my_var = "@second(now)"
end
sort_by(enumerable, sorter_fun)
Sorts a list of values using the result of the sorter function
Example 1:
When used as a Stack expression it returns a value of type List with values String, String, String: ["b", "a", "c"]
.
card MyCard do
my_var = sort_by(["a", "b", "c"], &rand_between(1, 5))
# When used in a piece of text prefix it with an `@`
my_var = "@sort_by([\"a\", \"b\", \"c\"], &rand_between(1, 5))"
end
split(binary)
Split a string into an array using the pattern as separator. Defaults to split the string using a space.
Example 1:
When used as a Stack expression it returns a value of type List with values String, String, String: ["t", "sting som", "thing"]
.
card MyCard do
my_var = split("testing something", "e")
# When used in a piece of text prefix it with an `@`
my_var = "@split(\"testing something\", \"e\")"
end
Example 2:
When used as a Stack expression it returns a value of type List with values String, String: ["testing", "something"]
.
card MyCard do
my_var = split("testing something")
# When used in a piece of text prefix it with an `@`
my_var = "@split(\"testing something\")"
end
split(binary, pattern)
substitute(subject, pattern, replacement)
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 as a Stack expression it returns a value of type String: "I can do"
.
card MyCard do
my_var = substitute("I can't", "can't", "can do")
# When used in a piece of text prefix it with an `@`
my_var = "@substitute(\"I can't\", \"can't\", \"can do\")"
end
sum(argument1, argument2, argument3)
Returns the sum of all arguments, equivalent to the + operator
You have @SUM(contact.reports, contact.forms) reports and forms
Example 1:
When used as a Stack expression it returns a value of type Integer: 6
.
card MyCard do
my_var = sum(1, 2, 3)
# When used in a piece of text prefix it with an `@`
my_var = "@sum(1, 2, 3)"
end
time(hours, minutes, seconds)
Defines a time value which can be used for time arithmetic
Example 1:
When used as a Stack expression it returns a value of type Time: ~T[12:13:14]
.
card MyCard do
my_var = time(12, 13, 14)
# When used in a piece of text prefix it with an `@`
my_var = "@time(12, 13, 14)"
end
timevalue(expression)
Converts time stored in text to an actual time
Example 1:
When used as a Stack expression it returns a value of type Time: ~T[02:30:55]
.
card MyCard do
my_var = timevalue("2:30:55")
# When used in a piece of text prefix it with an `@`
my_var = "@timevalue(\"2:30:55\")"
end
Example 2:
When used as a Stack expression it returns a value of type Time: ~T[02:30:00]
.
card MyCard do
my_var = timevalue("2:30")
# When used in a piece of text prefix it with an `@`
my_var = "@timevalue(\"2:30\")"
end
today()
Returns the current date
Example 1:
When used as a Stack expression it returns a value of type Date: ~D[2023-03-06]
.
card MyCard do
my_var = today()
# When used in a piece of text prefix it with an `@`
my_var = "@today()"
end
unichar(code)
Returns the unicode character specified by a number
Example 1:
When used as a Stack expression it returns a value of type String: "é"
.
card MyCard do
my_var = unichar(233)
# When used in a piece of text prefix it with an `@`
my_var = "@unichar(233)"
end
Example 2:
When used as a Stack expression it returns a value of type String: "A"
.
card MyCard do
my_var = unichar(65)
# When used in a piece of text prefix it with an `@`
my_var = "@unichar(65)"
end
unicode(letter)
Returns a numeric code for the first character in a text string
Example 1:
When used as a Stack expression it returns a value of type Integer: 233
.
card MyCard do
my_var = unicode("é")
# When used in a piece of text prefix it with an `@`
my_var = "@unicode(\"é\")"
end
Example 2:
When used as a Stack expression it returns a value of type Integer: 65
.
card MyCard do
my_var = unicode("A")
# When used in a piece of text prefix it with an `@`
my_var = "@unicode(\"A\")"
end
uniq(enumerable)
Removes duplicate values from a list.
Example 1:
When used as a Stack expression it returns a value of type List with values String, String, String: ["A", "B", "C"]
.
card MyCard do
my_var = uniq(["A", "B", "C", "B"])
# When used in a piece of text prefix it with an `@`
my_var = "@uniq([\"A\", \"B\", \"C\", \"B\"])"
end
upper(binary)
Converts a text string to uppercase
Example 1:
When used as a Stack expression it returns a value of type String: "FOO"
.
card MyCard do
my_var = upper("foo")
# When used in a piece of text prefix it with an `@`
my_var = "@upper(\"foo\")"
end
weekday(date)
Returns the day of the week of a date (1 for Sunday to 7 for Saturday)
Example 1:
When used as a Stack expression it returns a value of type Integer: 3
when used with the following context:
%{"today" => ~D[2022-11-01]}
card MyCard do
my_var = weekday(today)
# When used in a piece of text prefix it with an `@`
my_var = "@weekday(today)"
end
Example 2:
When used as a Stack expression it returns a value of type Integer: 1
when used with the following context:
%{"today" => ~D[2022-11-06]}
card MyCard do
my_var = weekday(today)
# When used in a piece of text prefix it with an `@`
my_var = "@weekday(today)"
end
with_index(enumerable)
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 as a 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]]
.
card MyCard do
my_var = with_index(["A", "B", "C"])
# When used in a piece of text prefix it with an `@`
my_var = "@with_index([\"A\", \"B\", \"C\"])"
end
word(binary, n)
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 as a Stack expression it returns a value of type String: "boy"
.
card MyCard do
my_var = word("hello cow-boy", -1)
# When used in a piece of text prefix it with an `@`
my_var = "@word(\"hello cow-boy\", -1)"
end
Example 2:
When used as a Stack expression it returns a value of type String: "cow-boy"
.
card MyCard do
my_var = word("hello cow-boy", 2, true)
# When used in a piece of text prefix it with an `@`
my_var = "@word(\"hello cow-boy\", 2, true)"
end
Example 3:
When used as a Stack expression it returns a value of type String: "cow"
.
card MyCard do
my_var = word("hello cow-boy", 2)
# When used in a piece of text prefix it with an `@`
my_var = "@word(\"hello cow-boy\", 2)"
end
word(binary, n, by_spaces)
word_count(binary)
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 words
Example 1:
When used as a Stack expression it returns a value of type Integer: 2
.
card MyCard do
my_var = word_count("hello cow-boy", true)
# When used in a piece of text prefix it with an `@`
my_var = "@word_count(\"hello cow-boy\", true)"
end
Example 2:
When used as a Stack expression it returns a value of type Integer: 3
.
card MyCard do
my_var = word_count("hello cow-boy")
# When used in a piece of text prefix it with an `@`
my_var = "@word_count(\"hello cow-boy\")"
end
word_count(binary, by_spaces)
word_slice(binary, start)
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 as a Stack expression it returns a value of type String: "fun"
.
card MyCard do
my_var = word_slice("FLOIP expressions are fun", -1)
# When used in a piece of text prefix it with an `@`
my_var = "@word_slice(\"FLOIP expressions are fun\", -1)"
end
Example 2:
When used as a Stack expression it returns a value of type String: "FLOIP expressions"
.
card MyCard do
my_var = word_slice("FLOIP expressions are fun", 1, -2)
# When used in a piece of text prefix it with an `@`
my_var = "@word_slice(\"FLOIP expressions are fun\", 1, -2)"
end
Example 3:
When used as a Stack expression it returns a value of type String: "expressions are fun"
.
card MyCard do
my_var = word_slice("FLOIP expressions are fun", 2)
# When used in a piece of text prefix it with an `@`
my_var = "@word_slice(\"FLOIP expressions are fun\", 2)"
end
Example 4:
When used as a Stack expression it returns a value of type String: "expressions are"
.
card MyCard do
my_var = word_slice("FLOIP expressions are fun", 2, 4)
# When used in a piece of text prefix it with an `@`
my_var = "@word_slice(\"FLOIP expressions are fun\", 2, 4)"
end
word_slice(binary, start, stop)
word_slice(binary, start, stop, by_spaces)
year(date)
Returns only the year of a date
Example 1:
When used as a Stack expression it returns a value of type Integer: 2023
when used with the following context:
%{"now" => ~U[2023-03-03 01:54:13.503091Z]}
card MyCard do
my_var = year(now)
# When used in a piece of text prefix it with an `@`
my_var = "@year(now)"
end