Expression.V2.Callbacks.Standard (expression v2.33.1)

Callback functions to be used in Expressions.

This is the same idea as Expression.Callbacks.Standard but it's in a rough shape, mostly to just prove that this all works.

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.

Returns the character specified by a number

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

Defines a new date value

Calculates a new datetime based on the offset and unit provided.

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

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

Tests whether all the words are contained in text

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

Returns whether the contact is part of group with the passed in UUID

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 expression 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 true if the argument is a boolean.

Returns true if the argument is a number.

Returns true if the argument is a string.

Returns the first characters in a text string. This is Unicode safe.

Returns the number of characters in a text string

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

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.

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

Formats digits in text for reading in TTS

Return the division remainder of two integers.

Removes the first word from the given text. The remaining text will be unchanged

Repeats text a given number of times

Returns the last characters in a text string. This is Unicode safe.

Returns only the second of a datetime (0 to 59)

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

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

Converts a text string to uppercase

Returns the day of the week of a date (1 for Sunday to 7 for Saturday)

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

Link to this function

abs(ctx, number)

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)
1

When used as an expression in text, prepend it with an @:

> "... @abs(-1) ..."
"1"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @abs(-1) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", 1, " impact"] = result
["chat for ", 1, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "abs(-1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert 1 = result
1
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@abs(-1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"1"

Link to this function

and_vargs(ctx, arguments)

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
true

When used as an expression in text, prepend it with an @:

> "... @and(contact.gender = "F", contact.age >= 18) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @and(contact.gender = \"F\", contact.age >= 18) impact",
...>   Expression.V2.Context.new(%{"contact" => %{"age" => 32, "gender" => "F"}}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "and(contact.gender = \"F\", contact.age >= 18)",
...>   Expression.V2.Context.new(%{"contact" => %{"age" => 32, "gender" => "F"}}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@and(contact.gender = \"F\", contact.age >= 18)",
...>   Expression.V2.Context.new(%{"contact" => %{"age" => 32, "gender" => "F"}}, Expression.V2.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
false

When used as an expression in text, prepend it with an @:

> "... @and(contact.gender = "F", contact.age >= 18) ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @and(contact.gender = \"F\", contact.age >= 18) impact",
...>   Expression.V2.Context.new(%{"contact" => %{"age" => 32, "gender" => "?"}}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "and(contact.gender = \"F\", contact.age >= 18)",
...>   Expression.V2.Context.new(%{"contact" => %{"age" => 32, "gender" => "?"}}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@and(contact.gender = \"F\", contact.age >= 18)",
...>   Expression.V2.Context.new(%{"contact" => %{"age" => 32, "gender" => "?"}}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

append(ctx, list, payload)

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @append([\"A\", \"B\"], \"C\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ["A", "B", "C"], " impact"] = result
["chat for ", ["A", "B", "C"], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "append([\"A\", \"B\"], \"C\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ["A", "B", "C"] = result
["A", "B", "C"]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@append([\"A\", \"B\"], \"C\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @append([\"A\", \"B\"], [\"C\", \"B\"]) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ["A", "B", "C", "B"], " impact"] = result
["chat for ", ["A", "B", "C", "B"], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "append([\"A\", \"B\"], [\"C\", \"B\"])",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ["A", "B", "C", "B"] = result
["A", "B", "C", "B"]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@append([\"A\", \"B\"], [\"C\", \"B\"])",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"ABCB"

Link to this function

callback(module \\ __MODULE__, context, function_name, args)

See Expression.V2.Callbacks.callback/4.

Link to this function

char(ctx, 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 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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @char(65) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "A", " impact"] = result
["chat for ", "A", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "char(65)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "A" = result
"A"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@char(65)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"A"

Link to this function

clean(ctx, binary)

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @clean(value) impact",
...>   Expression.V2.Context.new(%{"value" => <<65, 0, 66, 0, 67>>}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "ABC", " impact"] = result
["chat for ", "ABC", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "clean(value)",
...>   Expression.V2.Context.new(%{"value" => <<65, 0, 66, 0, 67>>}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "ABC" = result
"ABC"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@clean(value)",
...>   Expression.V2.Context.new(%{"value" => <<65, 0, 66, 0, 67>>}, Expression.V2.Callbacks.Standard)
...> )
"ABC"

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")
65

When used as an expression in text, prepend it with an @:

> "... @code("A") ..."
"65"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @code(\"A\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", 65, " impact"] = result
["chat for ", 65, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "code(\"A\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert 65 = result
65
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@code(\"A\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"65"

Link to this function

concatenate_vargs(ctx, arguments)

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @concatenate(contact.first_name, \" \", contact.last_name) impact",
...>   Expression.V2.Context.new(%{"contact" => %{"first_name" => "name", "last_name" => "surname"}}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "name surname", " impact"] = result
["chat for ", "name surname", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "concatenate(contact.first_name, \" \", contact.last_name)",
...>   Expression.V2.Context.new(%{"contact" => %{"first_name" => "name", "last_name" => "surname"}}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "name surname" = result
"name surname"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@concatenate(contact.first_name, \" \", contact.last_name)",
...>   Expression.V2.Context.new(%{"contact" => %{"first_name" => "name", "last_name" => "surname"}}, Expression.V2.Callbacks.Standard)
...> )
"name surname"

Link to this function

date(ctx, year, month, day)

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: ~D[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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @date(year, month, day) impact",
...>   Expression.V2.Context.new(%{"day" => 31, "month" => 1, "year" => 2022}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~D[2022-01-31], " impact"] = result
["chat for ", ~D[2022-01-31], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "date(year, month, day)",
...>   Expression.V2.Context.new(%{"day" => 31, "month" => 1, "year" => 2022}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~D[2022-01-31] = result
~D[2022-01-31]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@date(year, month, day)",
...>   Expression.V2.Context.new(%{"day" => 31, "month" => 1, "year" => 2022}, Expression.V2.Callbacks.Standard)
...> )
"2022-01-31"

Link to this function

datetime_add(ctx, 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:

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: ~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"}
> 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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @datetime_add(datetime, offset, unit) impact",
...>   Expression.V2.Context.new(%{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => 1, "unit" => "M"}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~U[2022-08-31 00:00:00Z], " impact"] = result
["chat for ", ~U[2022-08-31 00:00:00Z], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "datetime_add(datetime, offset, unit)",
...>   Expression.V2.Context.new(%{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => 1, "unit" => "M"}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~U[2022-08-31 00:00:00Z] = result
~U[2022-08-31 00:00:00Z]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@datetime_add(datetime, offset, unit)",
...>   Expression.V2.Context.new(%{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => 1, "unit" => "M"}, Expression.V2.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: ~U[2020-02-29 00: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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @datetime_add(date(2020, 02, 28), 1, \"D\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~U[2020-02-29 00:00:00.000000Z], " impact"] = result
["chat for ", ~U[2020-02-29 00:00:00.000000Z], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "datetime_add(date(2020, 02, 28), 1, \"D\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~U[2020-02-29 00:00:00.000000Z] = result
~U[2020-02-29 00:00:00.000000Z]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@datetime_add(date(2020, 02, 28), 1, \"D\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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: ~U[2021-03-01 00: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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @datetime_add(date(2021, 02, 28), 1, \"D\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~U[2021-03-01 00:00:00.000000Z], " impact"] = result
["chat for ", ~U[2021-03-01 00:00:00.000000Z], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "datetime_add(date(2021, 02, 28), 1, \"D\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~U[2021-03-01 00:00:00.000000Z] = result
~U[2021-03-01 00:00:00.000000Z]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@datetime_add(date(2021, 02, 28), 1, \"D\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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: ~U[2020-02-28 00: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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @datetime_add(date(2020, 02, 29), -1, \"D\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~U[2020-02-28 00:00:00.000000Z], " impact"] = result
["chat for ", ~U[2020-02-28 00:00:00.000000Z], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "datetime_add(date(2020, 02, 29), -1, \"D\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~U[2020-02-28 00:00:00.000000Z] = result
~U[2020-02-28 00:00:00.000000Z]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@datetime_add(date(2020, 02, 29), -1, \"D\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"2020-02-28T00:00:00.000000Z"

Link to this function

datevalue(ctx, date, format \\ "%Y-%m-%d %H:%M:%S")

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 .
> datevalue("2022-01-01")
%{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01]}

When used as an expression in text, prepend it with an @:

> "... @datevalue("2022-01-01") ..."
"2022-01-01 00:00:00"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @datevalue(\"2022-01-01\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", %{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01]}, " impact"] = result
["chat for ", %{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01]}, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "datevalue(\"2022-01-01\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert %{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01]} = result
%{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01]}
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@datevalue(\"2022-01-01\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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: ~D[2022-01-02].

> datevalue("2022-01-02").date
~D[2022-01-02]

When used as an expression in text, prepend it with an @:

> "... @datevalue("2022-01-02").date ..."
"2022-01-02"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @datevalue(\"2022-01-02\").date impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~D[2022-01-02], " impact"] = result
["chat for ", ~D[2022-01-02], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "datevalue(\"2022-01-02\").date",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~D[2022-01-02] = result
~D[2022-01-02]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@datevalue(\"2022-01-02\").date",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"2022-01-02"

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: ~D[2022-01-03].

> datevalue(date(2022, 1, 3)).date
~D[2022-01-03]

When used as an expression in text, prepend it with an @:

> "... @datevalue(date(2022, 1, 3)).date ..."
"2022-01-03"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @datevalue(date(2022, 1, 3)).date impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~D[2022-01-03], " impact"] = result
["chat for ", ~D[2022-01-03], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "datevalue(date(2022, 1, 3)).date",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~D[2022-01-03] = result
~D[2022-01-03]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@datevalue(date(2022, 1, 3)).date",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"2022-01-03"

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))
10

When used as an expression in text, prepend it with an @:

> "... @day(date(2022, 9, 10)) ..."
"10"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @day(date(2022, 9, 10)) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", 10, " impact"] = result
["chat for ", 10, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "day(date(2022, 9, 10))",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert 10 = result
10
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@day(date(2022, 9, 10))",
...>   Expression.V2.Context.new(%{}, Expression.V2.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: 22.

> day(now())
22

When used as an expression in text, prepend it with an @:

> "... @day(now()) ..."
"22"
..$> # Evaluate a string with expressions
..$> import ExUnit.Assertions
..$> result = Expression.V2.eval(
...>   "chat for @day(now()) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$> assert ["chat for ", 22, " impact"] = result
["chat for ", 22, " impact"]
..$>
..$> # Evaluate a standalone expression block
..$> result = Expression.V2.eval_block(
...>   "day(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$>
..$> assert 22 = result
22
..$>
..$> # Evaluate a string with expressions into a single string
..$> Expression.V2.eval_as_string(
...>   "@day(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"22"

Link to this function

delete(ctx, map, key)

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @delete(patient, \"gender\") impact",
...>   Expression.V2.Context.new(%{"patient" => %{"age" => 32, "gender" => "?"}}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", %{"age" => 32}, " impact"] = result
["chat for ", %{"age" => 32}, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "delete(patient, \"gender\")",
...>   Expression.V2.Context.new(%{"patient" => %{"age" => 32, "gender" => "?"}}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert %{"age" => 32} = result
%{"age" => 32}
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@delete(patient, \"gender\")",
...>   Expression.V2.Context.new(%{"patient" => %{"age" => 32, "gender" => "?"}}, Expression.V2.Callbacks.Standard)
...> )
"%{\"age\" => 32}"

Link to this function

edate(ctx, date, months)

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: ~U[2022-02-01 00: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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @edate(right_now, 1) impact",
...>   Expression.V2.Context.new(%{"right_now" => ~U[2022-01-01 00:00:00Z]}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~U[2022-02-01 00:00:00Z], " impact"] = result
["chat for ", ~U[2022-02-01 00:00:00Z], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "edate(right_now, 1)",
...>   Expression.V2.Context.new(%{"right_now" => ~U[2022-01-01 00:00:00Z]}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~U[2022-02-01 00:00:00Z] = result
~U[2022-02-01 00:00:00Z]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@edate(right_now, 1)",
...>   Expression.V2.Context.new(%{"right_now" => ~U[2022-01-01 00:00:00Z]}, Expression.V2.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: ~D[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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @edate(\"2022-10-10\", 1) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", ~D[2022-11-10], " impact"] = result
["chat for ", ~D[2022-11-10], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "edate(\"2022-10-10\", 1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert ~D[2022-11-10] = result
~D[2022-11-10]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@edate(\"2022-10-10\", 1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"2022-11-10"

Link to this function

expression_docs()

Return a list of all functions annotated with @expression_docs

Link to this function

first_word(ctx, binary)

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @first_word(\"foo bar baz\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "foo", " impact"] = result
["chat for ", "foo", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "first_word(\"foo bar baz\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "foo" = result
"foo"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@first_word(\"foo bar baz\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"foo"

Link to this function

fixed(ctx, number, precision, no_commas \\ false)

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @fixed(4.209922, 2, false) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "4.21", " impact"] = result
["chat for ", "4.21", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "fixed(4.209922, 2, false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "4.21" = result
"4.21"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@fixed(4.209922, 2, false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"4.21"

Example 2:

When used in the following Stack expression it returns a value of type String: "4,000.4242".

> fixed(4000.424242, 4, true)
"4,000.4242"

When used as an expression in text, prepend it with an @:

> "... @fixed(4000.424242, 4, true) ..."
"4,000.4242"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @fixed(4000.424242, 4, true) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "4,000.4242", " impact"] = result
["chat for ", "4,000.4242", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "fixed(4000.424242, 4, true)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "4,000.4242" = result
"4,000.4242"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@fixed(4000.424242, 4, true)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"4,000.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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @fixed(3.7979, 2, false) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "3.80", " impact"] = result
["chat for ", "3.80", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "fixed(3.7979, 2, false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "3.80" = result
"3.80"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@fixed(3.7979, 2, false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @fixed(3.7979, 2) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "3.80", " impact"] = result
["chat for ", "3.80", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "fixed(3.7979, 2)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "3.80" = result
"3.80"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@fixed(3.7979, 2)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"3.80"

Link to this function

has_all_words(ctx, 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 in the following Stack expression it returns a value of type Boolean: true.

> has_all_words("the quick brown FOX", "the fox")
true

When used as an expression in text, prepend it with an @:

> "... @has_all_words("the quick brown FOX", "the fox") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_all_words(\"the quick brown FOX\", \"the fox\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_all_words(\"the quick brown FOX\", \"the fox\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_all_words(\"the quick brown FOX\", \"the fox\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_all_words("the quick brown FOX", "red fox") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_all_words(\"the quick brown FOX\", \"red fox\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_all_words(\"the quick brown FOX\", \"red fox\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_all_words(\"the quick brown FOX\", \"red fox\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_any_word(ctx, 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 in the following Stack expression it returns a complex Boolean type of default value:

true

with 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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_any_word(\"The Quick Brown Fox\", \"fox quick\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", %{"__value__" => true, "match" => "Quick Fox"}, " impact"] = result
["chat for ", %{"__value__" => true, "match" => "Quick Fox"}, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_any_word(\"The Quick Brown Fox\", \"fox quick\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert %{"__value__" => true, "match" => "Quick Fox"} = result
%{"__value__" => true, "match" => "Quick Fox"}
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_any_word(\"The Quick Brown Fox\", \"fox quick\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a complex Boolean type of default value:

false

with 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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_any_word(\"The Quick Brown Fox\", \"yellow\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", %{"__value__" => false, "match" => nil}, " impact"] = result
["chat for ", %{"__value__" => false, "match" => nil}, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_any_word(\"The Quick Brown Fox\", \"yellow\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert %{"__value__" => false, "match" => nil} = result
%{"__value__" => false, "match" => nil}
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_any_word(\"The Quick Brown Fox\", \"yellow\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_beginning(ctx, 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 in the following Stack expression it returns a value of type Boolean: true.

> has_beginning("The Quick Brown", "the quick")
true

When used as an expression in text, prepend it with an @:

> "... @has_beginning("The Quick Brown", "the quick") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_beginning(\"The Quick Brown\", \"the quick\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_beginning(\"The Quick Brown\", \"the quick\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_beginning(\"The Quick Brown\", \"the quick\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_beginning("The Quick Brown", "the    quick") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_beginning(\"The Quick Brown\", \"the    quick\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_beginning(\"The Quick Brown\", \"the    quick\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_beginning(\"The Quick Brown\", \"the    quick\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_beginning("The Quick Brown", "quick brown") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_beginning(\"The Quick Brown\", \"quick brown\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_beginning(\"The Quick Brown\", \"quick brown\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_beginning(\"The Quick Brown\", \"quick brown\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_date(ctx, 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 in the following Stack expression it returns a value of type Boolean: true.

> has_date("the date is 15/01/2017")
true

When used as an expression in text, prepend it with an @:

> "... @has_date("the date is 15/01/2017") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_date(\"the date is 15/01/2017\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_date(\"the date is 15/01/2017\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_date(\"the date is 15/01/2017\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_date("there is no date here, just a year 2017")
false

When used as an expression in text, prepend it with an @:

> "... @has_date("there is no date here, just a year 2017") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_date(\"there is no date here, just a year 2017\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_date(\"there is no date here, just a year 2017\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_date(\"there is no date here, just a year 2017\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_date_eq(ctx, expression, date_string)

Tests whether expression is a date equal to date_string

Example 1:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_date_eq("the date is 15/01/2017", "2017-01-15")
true

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_date_eq(\"the date is 15/01/2017\", \"2017-01-15\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_date_eq(\"the date is 15/01/2017\", \"2017-01-15\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_date_eq(\"the date is 15/01/2017\", \"2017-01-15\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_date_eq("there is no date here, just a year 2017", "2017-01-15")
false

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_date_eq(\"there is no date here, just a year 2017\", \"2017-01-15\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_date_eq(\"there is no date here, just a year 2017\", \"2017-01-15\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_date_eq(\"there is no date here, just a year 2017\", \"2017-01-15\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_date_gt(ctx, expression, date_string)

Tests whether expression is a date after the date date_string

Example 1:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_date_gt("the date is 15/01/2017", "2017-01-01")
true

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_date_gt(\"the date is 15/01/2017\", \"2017-01-01\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_date_gt(\"the date is 15/01/2017\", \"2017-01-01\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_date_gt(\"the date is 15/01/2017\", \"2017-01-01\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_date_gt("the date is 15/01/2017", "2017-03-15")
false

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_date_gt(\"the date is 15/01/2017\", \"2017-03-15\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_date_gt(\"the date is 15/01/2017\", \"2017-03-15\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_date_gt(\"the date is 15/01/2017\", \"2017-03-15\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_date_lt(ctx, expression, date_string)

Tests whether expression contains a date before the date date_string

Example 1:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_date_lt("the date is 15/01/2017", "2017-06-01")
true

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_date_lt(\"the date is 15/01/2017\", \"2017-06-01\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_date_lt(\"the date is 15/01/2017\", \"2017-06-01\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_date_lt(\"the date is 15/01/2017\", \"2017-06-01\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_date_lt("the date is 15/01/2021", "2017-03-15")
false

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_date_lt(\"the date is 15/01/2021\", \"2017-03-15\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_date_lt(\"the date is 15/01/2021\", \"2017-03-15\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_date_lt(\"the date is 15/01/2021\", \"2017-03-15\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_email(ctx, expression)

Tests whether an email is contained in text

Example 1:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_email("my email is foo1@bar.com, please respond")
true

When used as an expression in text, prepend it with an @:

> "... @has_email("my email is foo1@bar.com, please respond") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_email(\"my email is foo1@bar.com, please respond\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_email(\"my email is foo1@bar.com, please respond\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_email(\"my email is foo1@bar.com, please respond\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_email("i'm not sharing my email")
false

When used as an expression in text, prepend it with an @:

> "... @has_email("i'm not sharing my email") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_email(\"i'm not sharing my email\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_email(\"i'm not sharing my email\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_email(\"i'm not sharing my email\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_group(ctx, groups, uuid)

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")
true

When used as an expression in text, prepend it with an @:

> "... @has_group(contact.groups, "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_group(contact.groups, \"b7cf0d83-f1c9-411c-96fd-c511a4cfa86d\") impact",
...>   Expression.V2.Context.new(%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_group(contact.groups, \"b7cf0d83-f1c9-411c-96fd-c511a4cfa86d\")",
...>   Expression.V2.Context.new(%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_group(contact.groups, \"b7cf0d83-f1c9-411c-96fd-c511a4cfa86d\")",
...>   Expression.V2.Context.new(%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_group(contact.groups, "00000000-0000-0000-0000-000000000000") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_group(contact.groups, \"00000000-0000-0000-0000-000000000000\") impact",
...>   Expression.V2.Context.new(%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_group(contact.groups, \"00000000-0000-0000-0000-000000000000\")",
...>   Expression.V2.Context.new(%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_group(contact.groups, \"00000000-0000-0000-0000-000000000000\")",
...>   Expression.V2.Context.new(%{"contact" => %{"groups" => [%{"uuid" => "b7cf0d83-f1c9-411c-96fd-c511a4cfa86d"}]}}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_number(ctx, expression)

Tests whether expression contains a number

Example 1:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_number("the number is 42 and 5")
true

When used as an expression in text, prepend it with an @:

> "... @has_number("the number is 42 and 5") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number(\"the number is 42 and 5\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number(\"the number is 42 and 5\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number(\"the number is 42 and 5\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_number("العدد ٤٢")
true

When used as an expression in text, prepend it with an @:

> "... @has_number("العدد ٤٢") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number(\"العدد ٤٢\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number(\"العدد ٤٢\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number(\"العدد ٤٢\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 3:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_number("٠.٥")
true

When used as an expression in text, prepend it with an @:

> "... @has_number("٠.٥") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number(\"٠.٥\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number(\"٠.٥\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number(\"٠.٥\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 4:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_number("0.6")
true

When used as an expression in text, prepend it with an @:

> "... @has_number("0.6") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number(\"0.6\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number(\"0.6\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number(\"0.6\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Link to this function

has_number_eq(ctx, expression, float)

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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_eq("the number is 42", 42) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_eq(\"the number is 42\", 42) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_eq(\"the number is 42\", 42)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_eq(\"the number is 42\", 42)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_eq("the number is 42", 42.0) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_eq(\"the number is 42\", 42.0) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_eq(\"the number is 42\", 42.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_eq(\"the number is 42\", 42.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
true

When used as an expression in text, prepend it with an @:

> "... @has_number_eq("the number is 42", "42") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_eq(\"the number is 42\", \"42\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_eq(\"the number is 42\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_eq(\"the number is 42\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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 42.0", "42")
true

When used as an expression in text, prepend it with an @:

> "... @has_number_eq("the number is 42.0", "42") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_eq(\"the number is 42.0\", \"42\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_eq(\"the number is 42.0\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_eq(\"the number is 42.0\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 5:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_eq("the number is 40", "42")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_eq("the number is 40", "42") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_eq(\"the number is 40\", \"42\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_eq(\"the number is 40\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_eq(\"the number is 40\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 6:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_eq("the number is 40", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_eq("the number is 40", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_eq(\"the number is 40\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_eq(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_eq(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 7:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_eq("four hundred", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_eq("four hundred", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_eq(\"four hundred\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_eq(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_eq(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_number_gt(ctx, expression, float)

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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_gt("the number is 42", 40) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gt(\"the number is 42\", 40) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gt(\"the number is 42\", 40)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gt(\"the number is 42\", 40)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_gt("the number is 42", 40.0) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gt(\"the number is 42\", 40.0) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gt(\"the number is 42\", 40.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gt(\"the number is 42\", 40.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
true

When used as an expression in text, prepend it with an @:

> "... @has_number_gt("the number is 42", "40") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gt(\"the number is 42\", \"40\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gt(\"the number is 42\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gt(\"the number is 42\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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 42.0", "40")
true

When used as an expression in text, prepend it with an @:

> "... @has_number_gt("the number is 42.0", "40") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gt(\"the number is 42.0\", \"40\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gt(\"the number is 42.0\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gt(\"the number is 42.0\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 5:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_gt("the number is 40", "40")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_gt("the number is 40", "40") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gt(\"the number is 40\", \"40\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gt(\"the number is 40\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gt(\"the number is 40\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 6:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_gt("the number is 40", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_gt("the number is 40", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gt(\"the number is 40\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gt(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gt(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 7:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_gt("four hundred", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_gt("four hundred", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gt(\"four hundred\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gt(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gt(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_number_gte(ctx, expression, float)

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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_gte("the number is 42", 42) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gte(\"the number is 42\", 42) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gte(\"the number is 42\", 42)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gte(\"the number is 42\", 42)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_gte("the number is 42", 42.0) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gte(\"the number is 42\", 42.0) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gte(\"the number is 42\", 42.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gte(\"the number is 42\", 42.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
true

When used as an expression in text, prepend it with an @:

> "... @has_number_gte("the number is 42", "42") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gte(\"the number is 42\", \"42\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gte(\"the number is 42\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gte(\"the number is 42\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 4:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_gte("the number is 42.0", "45")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_gte("the number is 42.0", "45") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gte(\"the number is 42.0\", \"45\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gte(\"the number is 42.0\", \"45\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gte(\"the number is 42.0\", \"45\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 5:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_gte("the number is 40", "45")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_gte("the number is 40", "45") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gte(\"the number is 40\", \"45\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gte(\"the number is 40\", \"45\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gte(\"the number is 40\", \"45\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_gte("the number is 40", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gte(\"the number is 40\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gte(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gte(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 7:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_gte("four hundred", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_gte("four hundred", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_gte(\"four hundred\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_gte(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_gte(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_number_lt(ctx, expression, float)

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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_lt("the number is 42", 44) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lt(\"the number is 42\", 44) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lt(\"the number is 42\", 44)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lt(\"the number is 42\", 44)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_lt("the number is 42", 44.0) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lt(\"the number is 42\", 44.0) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lt(\"the number is 42\", 44.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lt(\"the number is 42\", 44.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_lt("the number is 42", "40") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lt(\"the number is 42\", \"40\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lt(\"the number is 42\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lt(\"the number is 42\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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 42.0", "40")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_lt("the number is 42.0", "40") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lt(\"the number is 42.0\", \"40\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lt(\"the number is 42.0\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lt(\"the number is 42.0\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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 40", "40")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_lt("the number is 40", "40") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lt(\"the number is 40\", \"40\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lt(\"the number is 40\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lt(\"the number is 40\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_lt("the number is 40", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lt(\"the number is 40\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lt(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lt(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 7:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_lt("four hundred", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_lt("four hundred", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lt(\"four hundred\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lt(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lt(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_number_lte(ctx, expression, float)

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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_lte("the number is 42", 42) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lte(\"the number is 42\", 42) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lte(\"the number is 42\", 42)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lte(\"the number is 42\", 42)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_lte("the number is 42", 42.0) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lte(\"the number is 42\", 42.0) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lte(\"the number is 42\", 42.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lte(\"the number is 42\", 42.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
true

When used as an expression in text, prepend it with an @:

> "... @has_number_lte("the number is 42", "42") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lte(\"the number is 42\", \"42\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lte(\"the number is 42\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lte(\"the number is 42\", \"42\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 4:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_lte("the number is 42.0", "40")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_lte("the number is 42.0", "40") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lte(\"the number is 42.0\", \"40\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lte(\"the number is 42.0\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lte(\"the number is 42.0\", \"40\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 5:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_lte("the number is 40", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_lte("the number is 40", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lte(\"the number is 40\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lte(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lte(\"the number is 40\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 6:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_number_lte("four hundred", "foo")
false

When used as an expression in text, prepend it with an @:

> "... @has_number_lte("four hundred", "foo") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lte(\"four hundred\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lte(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lte(\"four hundred\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 7:

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)
true

When used as an expression in text, prepend it with an @:

> "... @has_number_lte(response, 5) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_number_lte(response, 5) impact",
...>   Expression.V2.Context.new(%{"response" => 3}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_number_lte(response, 5)",
...>   Expression.V2.Context.new(%{"response" => 3}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_number_lte(response, 5)",
...>   Expression.V2.Context.new(%{"response" => 3}, Expression.V2.Callbacks.Standard)
...> )
"true"

Link to this function

has_only_phrase(ctx, 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 in the following Stack expression it returns a value of type Boolean: true.

> has_only_phrase("Quick Brown", "quick brown")
true

When used as an expression in text, prepend it with an @:

> "... @has_only_phrase("Quick Brown", "quick brown") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_only_phrase(\"Quick Brown\", \"quick brown\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_only_phrase(\"Quick Brown\", \"quick brown\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_only_phrase(\"Quick Brown\", \"quick brown\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_only_phrase("", " ")
true

When used as an expression in text, prepend it with an @:

> "... @has_only_phrase("", " ") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_only_phrase(\"\", \" \") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_only_phrase(\"\", \" \")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_only_phrase(\"\", \" \")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_only_phrase("The Quick Brown Fox", "quick brown") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_only_phrase(\"The Quick Brown Fox\", \"quick brown\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_only_phrase(\"The Quick Brown Fox\", \"quick brown\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_only_phrase(\"The Quick Brown Fox\", \"quick brown\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_only_text(ctx, 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 in the following Stack expression it returns a value of type Boolean: true.

> has_only_text("foo", "foo")
true

When used as an expression in text, prepend it with an @:

> "... @has_only_text("foo", "foo") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_only_text(\"foo\", \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_only_text(\"foo\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_only_text(\"foo\", \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_only_text("", "")
true

When used as an expression in text, prepend it with an @:

> "... @has_only_text("", "") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_only_text(\"\", \"\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_only_text(\"\", \"\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_only_text(\"\", \"\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_only_text("foo", "FOO") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_only_text(\"foo\", \"FOO\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_only_text(\"foo\", \"FOO\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_only_text(\"foo\", \"FOO\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_pattern(ctx, 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 in the following Stack expression it returns a value of type Boolean: true.

> has_pattern("Buy cheese please", "buy (\w+)")
true

When used as an expression in text, prepend it with an @:

> "... @has_pattern("Buy cheese please", "buy (\w+)") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_pattern(\"Buy cheese please\", \"buy (\\w+)\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_pattern(\"Buy cheese please\", \"buy (\\w+)\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_pattern(\"Buy cheese please\", \"buy (\\w+)\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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+)")
false

When used as an expression in text, prepend it with an @:

> "... @has_pattern("Sell cheese please", "buy (\w+)") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_pattern(\"Sell cheese please\", \"buy (\\w+)\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_pattern(\"Sell cheese please\", \"buy (\\w+)\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_pattern(\"Sell cheese please\", \"buy (\\w+)\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_phone(ctx, expression)

Tests whether expression 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 value of type Boolean: true.

> has_phone("my number is +12067799294 thanks")
true

When used as an expression in text, prepend it with an @:

> "... @has_phone("my number is +12067799294 thanks") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_phone(\"my number is +12067799294 thanks\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_phone(\"my number is +12067799294 thanks\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_phone(\"my number is +12067799294 thanks\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_phone("my number is 2067799294 thanks", "US")
true

When used as an expression in text, prepend it with an @:

> "... @has_phone("my number is 2067799294 thanks", "US") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_phone(\"my number is 2067799294 thanks\", \"US\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_phone(\"my number is 2067799294 thanks\", \"US\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_phone(\"my number is 2067799294 thanks\", \"US\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 3:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_phone("my number is 206 779 9294 thanks", "US")
true

When used as an expression in text, prepend it with an @:

> "... @has_phone("my number is 206 779 9294 thanks", "US") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_phone(\"my number is 206 779 9294 thanks\", \"US\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_phone(\"my number is 206 779 9294 thanks\", \"US\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_phone(\"my number is 206 779 9294 thanks\", \"US\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 4:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_phone("my number is none of your business", "US")
false

When used as an expression in text, prepend it with an @:

> "... @has_phone("my number is none of your business", "US") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_phone(\"my number is none of your business\", \"US\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_phone(\"my number is none of your business\", \"US\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_phone(\"my number is none of your business\", \"US\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

has_phone(ctx, expression, country_code)

Link to this function

has_phrase(ctx, 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 in the following Stack expression it returns a value of type Boolean: true.

> has_phrase("the quick brown fox", "brown fox")
true

When used as an expression in text, prepend it with an @:

> "... @has_phrase("the quick brown fox", "brown fox") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_phrase(\"the quick brown fox\", \"brown fox\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_phrase(\"the quick brown fox\", \"brown fox\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_phrase(\"the quick brown fox\", \"brown fox\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_phrase("the quick brown fox", "quick fox") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_phrase(\"the quick brown fox\", \"quick fox\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_phrase(\"the quick brown fox\", \"quick fox\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_phrase(\"the quick brown fox\", \"quick fox\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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", "")
true

When used as an expression in text, prepend it with an @:

> "... @has_phrase("the quick brown fox", "") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_phrase(\"the quick brown fox\", \"\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_phrase(\"the quick brown fox\", \"\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_phrase(\"the quick brown fox\", \"\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Link to this function

has_text(ctx, expression)

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")
true

When used as an expression in text, prepend it with an @:

> "... @has_text("quick brown") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_text(\"quick brown\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_text(\"quick brown\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_text(\"quick brown\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_text("")
false

When used as an expression in text, prepend it with an @:

> "... @has_text("") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_text(\"\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_text(\"\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_text(\"\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 3:

When used in the following Stack expression it returns a value of type Boolean: false.

> has_text(" 
> ")
false

When used as an expression in text, prepend it with an @:

> "... @has_text(" 
") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_text(\" \n\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_text(\" \n\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_text(\" \n\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 4:

When used in the following Stack expression it returns a value of type Boolean: true.

> has_text(123)
true

When used as an expression in text, prepend it with an @:

> "... @has_text(123) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_text(123) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_text(123)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_text(123)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Link to this function

has_time(ctx, expression)

Tests whether expression contains a time.

Example 1:

When used in the following Stack expression it returns a complex Boolean type of default value:

true

with 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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_time(\"the time is 10:30\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", %{"__value__" => true, "match" => ~T[10:30:00]}, " impact"] = result
["chat for ", %{"__value__" => true, "match" => ~T[10:30:00]}, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_time(\"the time is 10:30\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert %{"__value__" => true, "match" => ~T[10:30:00]} = result
%{"__value__" => true, "match" => ~T[10:30:00]}
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_time(\"the time is 10:30\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a complex Boolean type of default value:

true

with 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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_time(\"the time is 10:00 pm\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", %{"__value__" => true, "match" => ~T[10:00:00]}, " impact"] = result
["chat for ", %{"__value__" => true, "match" => ~T[10:00:00]}, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_time(\"the time is 10:00 pm\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert %{"__value__" => true, "match" => ~T[10:00:00]} = result
%{"__value__" => true, "match" => ~T[10:00:00]}
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_time(\"the time is 10:00 pm\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 3:

When used in the following Stack expression it returns a complex Boolean type of default value:

true

with 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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_time(\"the time is 10:30:45\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", %{"__value__" => true, "match" => ~T[10:30:45]}, " impact"] = result
["chat for ", %{"__value__" => true, "match" => ~T[10:30:45]}, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_time(\"the time is 10:30:45\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert %{"__value__" => true, "match" => ~T[10:30:45]} = result
%{"__value__" => true, "match" => ~T[10:30:45]}
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_time(\"the time is 10:30:45\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.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")
false

When used as an expression in text, prepend it with an @:

> "... @has_time("there is no time here, just the number 25") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @has_time(\"there is no time here, just the number 25\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "has_time(\"there is no time here, just the number 25\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@has_time(\"there is no time here, just the number 25\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

hour(ctx, date)

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: 14.

> hour(now())
14

When used as an expression in text, prepend it with an @:

> "... @hour(now()) ..."
"14"
..$> # Evaluate a string with expressions
..$> import ExUnit.Assertions
..$> result = Expression.V2.eval(
...>   "chat for @hour(now()) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$> assert ["chat for ", 14, " impact"] = result
["chat for ", 14, " impact"]
..$>
..$> # Evaluate a standalone expression block
..$> result = Expression.V2.eval_block(
...>   "hour(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$>
..$> assert 14 = result
14
..$>
..$> # Evaluate a string with expressions into a single string
..$> Expression.V2.eval_as_string(
...>   "@hour(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"14"

Link to this function

isbool(ctx, var)

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)
true

When used as an expression in text, prepend it with an @:

> "... @isbool(true) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isbool(true) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isbool(true)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isbool(true)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: true.

> isbool(false)
true

When used as an expression in text, prepend it with an @:

> "... @isbool(false) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isbool(false) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isbool(false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isbool(false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 3:

When used in the following Stack expression it returns a value of type Boolean: false.

> isbool(1)
false

When used as an expression in text, prepend it with an @:

> "... @isbool(1) ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isbool(1) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isbool(1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isbool(1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 4:

When used in the following Stack expression it returns a value of type Boolean: false.

> isbool(0)
false

When used as an expression in text, prepend it with an @:

> "... @isbool(0) ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isbool(0) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isbool(0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isbool(0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 5:

When used in the following Stack expression it returns a value of type Boolean: false.

> isbool("true")
false

When used as an expression in text, prepend it with an @:

> "... @isbool("true") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isbool(\"true\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isbool(\"true\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isbool(\"true\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 6:

When used in the following Stack expression it returns a value of type Boolean: false.

> isbool("false")
false

When used as an expression in text, prepend it with an @:

> "... @isbool("false") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isbool(\"false\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isbool(\"false\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isbool(\"false\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

isnumber(ctx, var)

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)
true

When used as an expression in text, prepend it with an @:

> "... @isnumber(1) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isnumber(1) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isnumber(1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isnumber(1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: true.

> isnumber(1.0)
true

When used as an expression in text, prepend it with an @:

> "... @isnumber(1.0) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isnumber(1.0) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isnumber(1.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isnumber(1.0)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 3:

When used in the following Stack expression it returns a value of type Boolean: true.

> isnumber("1.0")
true

When used as an expression in text, prepend it with an @:

> "... @isnumber("1.0") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isnumber(\"1.0\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isnumber(\"1.0\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isnumber(\"1.0\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 4:

When used in the following Stack expression it returns a value of type Boolean: false.

> isnumber("a")
false

When used as an expression in text, prepend it with an @:

> "... @isnumber("a") ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isnumber(\"a\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isnumber(\"a\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isnumber(\"a\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

isstring(ctx, binary)

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")
true

When used as an expression in text, prepend it with an @:

> "... @isstring("hello") ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isstring(\"hello\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isstring(\"hello\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isstring(\"hello\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Boolean: false.

> isstring(false)
false

When used as an expression in text, prepend it with an @:

> "... @isstring(false) ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isstring(false) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isstring(false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isstring(false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Example 3:

When used in the following Stack expression it returns a value of type Boolean: false.

> isstring(1)
false

When used as an expression in text, prepend it with an @:

> "... @isstring(1) ..."
"false"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @isstring(1) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", false, " impact"] = result
["chat for ", false, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "isstring(1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> refute result
false
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@isstring(1)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"false"

Link to this function

left(ctx, binary, size)

Returns the first 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: "foob".

> left("foobar", 4)
"foob"

When used as an expression in text, prepend it with an @:

> "... @left("foobar", 4) ..."
"foob"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @left(\"foobar\", 4) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "foob", " impact"] = result
["chat for ", "foob", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "left(\"foobar\", 4)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "foob" = result
"foob"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@left(\"foobar\", 4)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @left(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "Умерла Мадлен Олбрай", " impact"] = result
["chat for ", "Умерла Мадлен Олбрай", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "left(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "Умерла Мадлен Олбрай" = result
"Умерла Мадлен Олбрай"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@left(\"Умерла Мадлен Олбрайт - первая женщина на посту главы Госдепа США\", 20)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"Умерла Мадлен Олбрай"

Link to this function

len(ctx, binary)

Returns the number of characters in a text string

Example 1:

When used in the following Stack expression it returns a value of type Integer: 3.

> len("foo")
3

When used as an expression in text, prepend it with an @:

> "... @len("foo") ..."
"3"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @len(\"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", 3, " impact"] = result
["chat for ", 3, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "len(\"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert 3 = result
3
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@len(\"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"3"

Example 2:

When used in the following Stack expression it returns a value of type Integer: 3.

> len("zoë")
3

When used as an expression in text, prepend it with an @:

> "... @len("zoë") ..."
"3"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @len(\"zoë\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", 3, " impact"] = result
["chat for ", 3, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "len(\"zoë\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert 3 = result
3
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@len(\"zoë\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"3"

Link to this function

lower(ctx, binary)

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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @lower(\"Foo Bar\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "foo bar", " impact"] = result
["chat for ", "foo bar", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "lower(\"Foo Bar\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "foo bar" = result
"foo bar"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@lower(\"Foo Bar\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"foo bar"

Link to this function

map(ctx, 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, 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: [~D[2022-01-01], ~D[2022-01-02], ~D[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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @map(1..3, &date(2022, 1, &1)) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", [~D[2022-01-01], ~D[2022-01-02], ~D[2022-01-03]], " impact"] = result
["chat for ", [~D[2022-01-01], ~D[2022-01-02], ~D[2022-01-03]], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "map(1..3, &date(2022, 1, &1))",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
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>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@map(1..3, &date(2022, 1, &1))",
...>   Expression.V2.Context.new(%{}, Expression.V2.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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @map(1..3, &(&1 * &1)) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", [1, 4, 9], " impact"] = result
["chat for ", [1, 4, 9], " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "map(1..3, &(&1 * &1))",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert [1, 4, 9] = result
[1, 4, 9]
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@map(1..3, &(&1 * &1))",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"149"

Link to this function

max_vargs(ctx, arguments)

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)
3

When used as an expression in text, prepend it with an @:

> "... @max(1, 2, 3) ..."
"3"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @max(1, 2, 3) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", 3, " impact"] = result
["chat for ", 3, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "max(1, 2, 3)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert 3 = result
3
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@max(1, 2, 3)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"3"

Link to this function

min_vargs(ctx, arguments)

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)
1

When used as an expression in text, prepend it with an @:

> "... @min(1, 2, 3) ..."
"1"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @min(1, 2, 3) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", 1, " impact"] = result
["chat for ", 1, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "min(1, 2, 3)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert 1 = result
1
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@min(1, 2, 3)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"1"

Link to this function

minute(ctx, date)

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: 57.

> minute(now())
57

When used as an expression in text, prepend it with an @:

> "... @minute(now()) ..."
"57"
..$> # Evaluate a string with expressions
..$> import ExUnit.Assertions
..$> result = Expression.V2.eval(
...>   "chat for @minute(now()) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$> assert ["chat for ", 57, " impact"] = result
["chat for ", 57, " impact"]
..$>
..$> # Evaluate a standalone expression block
..$> result = Expression.V2.eval_block(
...>   "minute(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$>
..$> assert 57 = result
57
..$>
..$> # Evaluate a string with expressions into a single string
..$> Expression.V2.eval_as_string(
...>   "@minute(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"57"

Link to this function

month(ctx, date)

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: 4.

> month(now())
4

When used as an expression in text, prepend it with an @:

> "... @month(now()) ..."
"4"
..$> # Evaluate a string with expressions
..$> import ExUnit.Assertions
..$> result = Expression.V2.eval(
...>   "chat for @month(now()) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$> assert ["chat for ", 4, " impact"] = result
["chat for ", 4, " impact"]
..$>
..$> # Evaluate a standalone expression block
..$> result = Expression.V2.eval_block(
...>   "month(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$>
..$> assert 4 = result
4
..$>
..$> # Evaluate a string with expressions into a single string
..$> Expression.V2.eval_as_string(
...>   "@month(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"4"

Link to this function

not_(ctx, argument)

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)
true

When used as an expression in text, prepend it with an @:

> "... @not(false) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @not(false) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "not(false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@not(false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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: ~U[2024-04-22 14:57:07.564220Z].

> now()
~U[2024-04-22 14:57:07.564220Z]

When used as an expression in text, prepend it with an @:

> "... @now() ..."
"2024-04-22T14:57:07.564220Z"
..$> # Evaluate a string with expressions
..$> import ExUnit.Assertions
..$> result = Expression.V2.eval(
...>   "chat for @now() impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$> assert ["chat for ", ~U[2024-04-22 14:57:07.564220Z], " impact"] = result
["chat for ", ~U[2024-04-22 14:57:07.564220Z], " impact"]
..$>
..$> # Evaluate a standalone expression block
..$> result = Expression.V2.eval_block(
...>   "now()",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$>
..$> assert ~U[2024-04-22 14:57:07.564220Z] = result
~U[2024-04-22 14:57:07.564220Z]
..$>
..$> # Evaluate a string with expressions into a single string
..$> Expression.V2.eval_as_string(
...>   "@now()",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"2024-04-22T14:57:07.564220Z"

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:

"2024-04-22"

with the following fields:

  • date of type DateTime .
> datevalue(now(), "%Y-%m-%d")
%{"__value__" => "2024-04-22", "date" => ~U[2024-04-22 14:57:07.617646Z]}

When used as an expression in text, prepend it with an @:

> "... @datevalue(now(), "%Y-%m-%d") ..."
"2024-04-22"
..$> # Evaluate a string with expressions
..$> import ExUnit.Assertions
..$> result = Expression.V2.eval(
...>   "chat for @datevalue(now(), \"%Y-%m-%d\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$> assert ["chat for ", %{"__value__" => "2024-04-22", "date" => ~U[2024-04-22 14:57:07.617646Z]}, " impact"] = result
["chat for ", %{"__value__" => "2024-04-22", "date" => ~U[2024-04-22 14:57:07.617646Z]}, " impact"]
..$>
..$> # Evaluate a standalone expression block
..$> result = Expression.V2.eval_block(
...>   "datevalue(now(), \"%Y-%m-%d\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$>
..$> assert %{"__value__" => "2024-04-22", "date" => ~U[2024-04-22 14:57:07.617646Z]} = result
%{"__value__" => "2024-04-22", "date" => ~U[2024-04-22 14:57:07.617646Z]}
..$>
..$> # Evaluate a string with expressions into a single string
..$> Expression.V2.eval_as_string(
...>   "@datevalue(now(), \"%Y-%m-%d\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"2024-04-22"

Link to this function

or_vargs(ctx, arguments)

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
true

When used as an expression in text, prepend it with an @:

> "... @or(true, false) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @or(true, false) impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", true, " impact"] = result
["chat for ", true, " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "or(true, false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert true = result
true
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@or(true, false)",
...>   Expression.V2.Context.new(%{}, Expression.V2.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> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @or(false, \"foo\") impact",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex> assert ["chat for ", "foo", " impact"] = result
["chat for ", "foo", " impact"]
iex>
iex> # Evaluate a standalone expression block
iex> result = Expression.V2.eval_block(
...>   "or(false, \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
iex>
iex> assert "foo" = result
"foo"
iex>
iex> # Evaluate a string with expressions into a single string
iex> Expression.V2.eval_as_string(
...>   "@or(false, \"foo\")",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"foo"

Example 3:

When used in the following Stack expression it returns a value of type Boolean: true.

> true or true
true

When used as an expression in text, prepend it with an @:

> "... @or(true, true) ..."
"true"
iex> # Evaluate a string with expressions
iex> import ExUnit.Assertions
iex> result = Expression.V2.eval(
...>   "chat for @or(true, true) impact",
...>