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"

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"

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"

See Expression.V2.Callbacks.callback/4.

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"

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"

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"

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"

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"

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

> day(now())
12

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

> "... @day(now()) ..."
"12"

..$> # 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 ", 12, " impact"] = result
["chat for ", 12, " impact"]
..$>
..$> # Evaluate a standalone expression block
..$> result = Expression.V2.eval_block(
...>   "day(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
..$>
..$> assert 12 = result
12
..$>
..$> # Evaluate a string with expressions into a single string
..$> Expression.V2.eval_as_string(
...>   "@day(now())",
...>   Expression.V2.Context.new(%{}, Expression.V2.Callbacks.Standard)
...> )
"12"

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}"

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"

Return a list of all functions annotated with @expression_docs

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"

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"

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"

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"

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"