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> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "abs(-1)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert 1 = result
1
iex> Expression.evaluate_as_string!(
...>   "@abs(-1)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"1"

Example 2:

When used in the following Stack expression it returns a value of type Float: 0.5.

> abs(-0.5)
0.5

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

> "... @abs(-0.5) ..."
"0.5"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "abs(-0.5)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert 0.5 = result
0.5
iex> Expression.evaluate_as_string!(
...>   "@abs(-0.5)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"0.5"

Returns true if and only if all its arguments evaluate to true

Example 1:

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

%{"contact" => %{"age" => 32, "gender" => "F"}}

> contact.gender = "F" and contact.age >= 18
true

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

> "... @and(contact.gender = "F", contact.age >= 18) ..."
"true"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "and(contact.gender = \"F\", contact.age >= 18)",
...>   %{"contact" => %{"age" => 32, "gender" => "F"}},
...>   Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...>   "@and(contact.gender = \"F\", contact.age >= 18)",
...>   %{"contact" => %{"age" => 32, "gender" => "F"}},
...>   Expression.Callbacks.Standard
...> )
"true"

Example 2:

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

%{"contact" => %{"age" => 32, "gender" => "?"}}

> contact.gender = "F" and contact.age >= 18
false

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

> "... @and(contact.gender = "F", contact.age >= 18) ..."
"false"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "and(contact.gender = \"F\", contact.age >= 18)",
...>   %{"contact" => %{"age" => 32, "gender" => "?"}},
...>   Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...>   "@and(contact.gender = \"F\", contact.age >= 18)",
...>   %{"contact" => %{"age" => 32, "gender" => "?"}},
...>   Expression.Callbacks.Standard
...> )
"false"

Appends an item or a list of items to a given list.

Example 1:

When used in the following Stack expression it returns a value of type List with values String, String, String:

[
  "A",
  "B",
  "C"
]

.

> append(["A", "B"], "C")
["A", "B", "C"]

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

> "... @append(["A", "B"], "C") ..."
"ABC"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "append([\"A\", \"B\"], \"C\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ["A", "B", "C"] = result
["A", "B", "C"]
iex> Expression.evaluate_as_string!(
...>   "@append([\"A\", \"B\"], \"C\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"ABC"

Example 2:

When used in the following Stack expression it returns a value of type List with values String, String, String, String:

[
  "A",
  "B",
  "C",
  "B"
]

.

> append(["A", "B"], ["C", "B"])
["A", "B", "C", "B"]

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

> "... @append(["A", "B"], ["C", "B"]) ..."
"ABCB"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "append([\"A\", \"B\"], [\"C\", \"B\"])",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ["A", "B", "C", "B"] = result
["A", "B", "C", "B"]
iex> Expression.evaluate_as_string!(
...>   "@append([\"A\", \"B\"], [\"C\", \"B\"])",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"ABCB"

Returns the character specified by a number

> "As easy as @char(65), @char(66), @char(67)"
"As easy as A, B, C"

Example 1:

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

> char(65)
"A"

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

> "... @char(65) ..."
"A"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "char(65)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "A" = result
"A"
iex> Expression.evaluate_as_string!(
...>   "@char(65)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"A"

Removes all non-printable characters from a text string

Example 1:

When used in the following Stack expression it returns a value of type String: "ABC" when used with the following context:

%{"value" => <<65, 0, 66, 0, 67>>}

> clean(value)
"ABC"

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

> "... @clean(value) ..."
"ABC"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "clean(value)",
...>   %{"value" => <<65, 0, 66, 0, 67>>},
...>   Expression.Callbacks.Standard
...> )
iex> assert "ABC" = result
"ABC"
iex> Expression.evaluate_as_string!(
...>   "@clean(value)",
...>   %{"value" => <<65, 0, 66, 0, 67>>},
...>   Expression.Callbacks.Standard
...> )
"ABC"

Example 2:

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

> clean(nil)
""

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

> "... @clean(nil) ..."
""

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "clean(nil)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...>   "@clean(nil)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
""

Returns a numeric code for the first character in a text string

> "The numeric code of A is @CODE(\"A\")"
"The numeric code of A is 65"

Example 1:

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

> code("A")
65

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

> "... @code("A") ..."
"65"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "code(\"A\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert 65 = result
65
iex> Expression.evaluate_as_string!(
...>   "@code(\"A\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"65"

Example 2:

When used in the following Stack expression it returns a value of type Null: null.

> code(nil)
nil

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

> "... @code(nil) ..."
""

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "code(nil)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> refute result
nil
iex> Expression.evaluate_as_string!(
...>   "@code(nil)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
""

Joins text strings into one text string

> "Your name is @CONCATENATE(contact.first_name, \" \", contact.last_name)"
"Your name is name surname"

Example 1:

When used in the following Stack expression it returns a value of type String: "name surname" when used with the following context:

%{"contact" => %{"first_name" => "name", "last_name" => "surname"}}

> concatenate(contact.first_name, " ", contact.last_name)
"name surname"

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

> "... @concatenate(contact.first_name, " ", contact.last_name) ..."
"name surname"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "concatenate(contact.first_name, \" \", contact.last_name)",
...>   %{"contact" => %{"first_name" => "name", "last_name" => "surname"}},
...>   Expression.Callbacks.Standard
...> )
iex> assert "name surname" = result
"name surname"
iex> Expression.evaluate_as_string!(
...>   "@concatenate(contact.first_name, \" \", contact.last_name)",
...>   %{"contact" => %{"first_name" => "name", "last_name" => "surname"}},
...>   Expression.Callbacks.Standard
...> )
"name surname"

Defines a new date value

Example 1:

Construct a date from year, month, and day integers

When used in the following Stack expression it returns a value of type Date: "2022-01-31" when used with the following context:

%{"day" => 31, "month" => 1, "year" => 2022}

> date(year, month, day)
~D[2022-01-31]

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

> "... @date(year, month, day) ..."
"2022-01-31"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "date(year, month, day)",
...>   %{"day" => 31, "month" => 1, "year" => 2022},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~D[2022-01-31] = result
~D[2022-01-31]
iex> Expression.evaluate_as_string!(
...>   "@date(year, month, day)",
...>   %{"day" => 31, "month" => 1, "year" => 2022},
...>   Expression.Callbacks.Standard
...> )
"2022-01-31"

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

The unit can be any of the following values:

• "Y" for years
• "M" for months
• "W" for weeks
• "D" for days
• "h" for hours
• "m" for minutes
• "s" for seconds

Specifying a negative offset results in date calculations back in time.

Example 1:

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

When used in the following Stack expression it returns a value of type DateTime: "2022-08-31T00:00:00Z" when used with the following context:

%{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => "1", "unit" => "M"}

> datetime_add(datetime, offset, unit)
~U[2022-08-31 00:00:00Z]

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

> "... @datetime_add(datetime, offset, unit) ..."
"2022-08-31T00:00:00Z"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "datetime_add(datetime, offset, unit)",
...>   %{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => "1", "unit" => "M"},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~U[2022-08-31 00:00:00Z] = result
~U[2022-08-31 00:00:00Z]
iex> Expression.evaluate_as_string!(
...>   "@datetime_add(datetime, offset, unit)",
...>   %{"datetime" => ~U[2022-07-31 00:00:00Z], "offset" => "1", "unit" => "M"},
...>   Expression.Callbacks.Standard
...> )
"2022-08-31T00:00:00Z"

Example 2:

Leap year handling in a leap year.

When used in the following Stack expression it returns a value of type DateTime: "2020-02-29T00:00:00.000000Z".

> datetime_add(date(2020, 02, 28), 1, "D")
~U[2020-02-29 00:00:00.000000Z]

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

> "... @datetime_add(date(2020, 02, 28), 1, "D") ..."
"2020-02-29T00:00:00.000000Z"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "datetime_add(date(2020, 02, 28), 1, \"D\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~U[2020-02-29 00:00:00.000000Z] = result
~U[2020-02-29 00:00:00.000000Z]
iex> Expression.evaluate_as_string!(
...>   "@datetime_add(date(2020, 02, 28), 1, \"D\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2020-02-29T00:00:00.000000Z"

Example 3:

Leap year handling outside of a leap year.

When used in the following Stack expression it returns a value of type DateTime: "2021-03-01T00:00:00.000000Z".

> datetime_add(date(2021, 02, 28), 1, "D")
~U[2021-03-01 00:00:00.000000Z]

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

> "... @datetime_add(date(2021, 02, 28), 1, "D") ..."
"2021-03-01T00:00:00.000000Z"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "datetime_add(date(2021, 02, 28), 1, \"D\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~U[2021-03-01 00:00:00.000000Z] = result
~U[2021-03-01 00:00:00.000000Z]
iex> Expression.evaluate_as_string!(
...>   "@datetime_add(date(2021, 02, 28), 1, \"D\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2021-03-01T00:00:00.000000Z"

Example 4:

Negative offsets

When used in the following Stack expression it returns a value of type DateTime: "2020-02-28T00:00:00.000000Z".

> datetime_add(date(2020, 02, 29), -1, "D")
~U[2020-02-28 00:00:00.000000Z]

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

> "... @datetime_add(date(2020, 02, 29), -1, "D") ..."
"2020-02-28T00:00:00.000000Z"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "datetime_add(date(2020, 02, 29), -1, \"D\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~U[2020-02-28 00:00:00.000000Z] = result
~U[2020-02-28 00:00:00.000000Z]
iex> Expression.evaluate_as_string!(
...>   "@datetime_add(date(2020, 02, 29), -1, \"D\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2020-02-28T00:00:00.000000Z"

Example 5:

Invalid date inputs

When used in the following Stack expression it returns a value of type Map:

{
  "__type__": "expression/v1error",
  "error": true,
  "message": "Invalid date"
}

when used with the following context:

%{}

> datetime_add("_..[0]._", 0, "h")
%{"__type__" => "expression/v1error", "error" => true, "message" => "Invalid date"}

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

> "... @datetime_add("_..[0]._", 0, "h") ..."
"%{"__type__" => "expression/v1error", "error" => true, "message" => "Invalid date"}"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "datetime_add(\"_..[0]._\", 0, \"h\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__type__" => "expression/v1error", "error" => true, "message" => "Invalid date"} = result
%{"__type__" => "expression/v1error", "error" => true, "message" => "Invalid date"}
iex> Expression.evaluate_as_string!(
...>   "@datetime_add(\"_..[0]._\", 0, \"h\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"%{\"__type__\" => \"expression/v1error\", \"error\" => true, \"message\" => \"Invalid date\"}"

Converts date stored in text to an actual date object and formats it using strftime formatting.

It will fallback to "%Y-%m-%d %H:%M:%S" if no formatting is supplied

Example 1:

Convert a date from a piece of text to a formatted date string

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

"2022-01-01 00:00:00"

with the following fields:

• date of type Date
• datetime of type DateTime .

> datevalue("2022-01-01")
%{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01], "datetime" => ~U[2022-01-01 00:00:00Z]}

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

> "... @datevalue("2022-01-01") ..."
"2022-01-01 00:00:00"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "datevalue(\"2022-01-01\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01], "datetime" => ~U[2022-01-01 00:00:00Z]} = result
%{"__value__" => "2022-01-01 00:00:00", "date" => ~D[2022-01-01], "datetime" => ~U[2022-01-01 00:00:00Z]}
iex> Expression.evaluate_as_string!(
...>   "@datevalue(\"2022-01-01\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2022-01-01 00:00:00"

Example 2:

Convert a date from a piece of text and read the date field

When used in the following Stack expression it returns a value of type Date: "2022-01-01".

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

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

> "... @datevalue("2022-01-01").date ..."
"2022-01-01"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "datevalue(\"2022-01-01\").date",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~D[2022-01-01] = result
~D[2022-01-01]
iex> Expression.evaluate_as_string!(
...>   "@datevalue(\"2022-01-01\").date",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2022-01-01"

Example 3:

Convert a date value and read the date field

When used in the following Stack expression it returns a value of type Date: "2022-01-01".

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

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

> "... @datevalue(date(2022, 1, 1)).date ..."
"2022-01-01"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "datevalue(date(2022, 1, 1)).date",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~D[2022-01-01] = result
~D[2022-01-01]
iex> Expression.evaluate_as_string!(
...>   "@datevalue(date(2022, 1, 1)).date",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2022-01-01"

Returns only the day of the month of a date (1 to 31)

Example 1:

Getting today's day of the month

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

> day(date(2022, 9, 10))
10

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

> "... @day(date(2022, 9, 10)) ..."
"10"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "day(date(2022, 9, 10))",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert 10 = result
10
iex> Expression.evaluate_as_string!(
...>   "@day(date(2022, 9, 10))",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"10"

Example 2:

Getting today's day of the month

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

> day(now())
12

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

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

..$> import ExUnit.Assertions
..$> result = Expression.evaluate_block!(
...>   "day(now())",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
..$> assert 12 = result
12
..$> Expression.evaluate_as_string!(
...>   "@day(now())",
...>   %{},
...>   Expression.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> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "delete(patient, \"gender\")",
...>   %{"patient" => %{"age" => 32, "gender" => "?"}},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"age" => 32} = result
%{"age" => 32}
iex> Expression.evaluate_as_string!(
...>   "@delete(patient, \"gender\")",
...>   %{"patient" => %{"age" => 32, "gender" => "?"}},
...>   Expression.Callbacks.Standard
...> )
"%{\"age\" => 32}"

Moves a date by the given number of months

Example 1:

Move the date in a date object by 1 month

When used in the following Stack expression it returns a value of type DateTime: "2022-02-01T00:00:00Z" when used with the following context:

%{right_now: ~U[2022-01-01 00:00:00Z]}

> edate(right_now, 1)
~U[2022-02-01 00:00:00Z]

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

> "... @edate(right_now, 1) ..."
"2022-02-01T00:00:00Z"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "edate(right_now, 1)",
...>   %{right_now: ~U[2022-01-01 00:00:00Z]},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~U[2022-02-01 00:00:00Z] = result
~U[2022-02-01 00:00:00Z]
iex> Expression.evaluate_as_string!(
...>   "@edate(right_now, 1)",
...>   %{right_now: ~U[2022-01-01 00:00:00Z]},
...>   Expression.Callbacks.Standard
...> )
"2022-02-01T00:00:00Z"

Example 2:

Move the date store in a piece of text by 1 month

When used in the following Stack expression it returns a value of type Date: "2022-11-10".

> edate("2022-10-10", 1)
~D[2022-11-10]

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

> "... @edate("2022-10-10", 1) ..."
"2022-11-10"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "edate(\"2022-10-10\", 1)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~D[2022-11-10] = result
~D[2022-11-10]
iex> Expression.evaluate_as_string!(
...>   "@edate(\"2022-10-10\", 1)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2022-11-10"

Return a list of all functions annotated with @expression_docs

Returns the first word in the given text - equivalent to WORD(text, 1)

Example 1:

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

> first_word("foo bar baz")
"foo"

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

> "... @first_word("foo bar baz") ..."
"foo"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "first_word(\"foo bar baz\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "foo" = result
"foo"
iex> Expression.evaluate_as_string!(
...>   "@first_word(\"foo bar baz\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"foo"

Example 2:

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

> first_word(nil)
""

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

> "... @first_word(nil) ..."
""

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "first_word(nil)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "" = result
""
iex> Expression.evaluate_as_string!(
...>   "@first_word(nil)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
""

Formats the given number in decimal format using a period and commas

> You have @fixed(contact.balance, 2) in your account
"You have 4.21 in your account"

Example 1:

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

> fixed(4.209922, 2, false)
"4.21"

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

> "... @fixed(4.209922, 2, false) ..."
"4.21"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "fixed(4.209922, 2, false)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "4.21" = result
"4.21"
iex> Expression.evaluate_as_string!(
...>   "@fixed(4.209922, 2, false)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"4.21"

Example 2:

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

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

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

> "... @fixed(4000.424242, 4, true) ..."
"4000.4242"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "fixed(4000.424242, 4, true)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "4000.4242" = result
"4000.4242"
iex> Expression.evaluate_as_string!(
...>   "@fixed(4000.424242, 4, true)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"4000.4242"

Example 3:

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

> fixed(3.7979, 2, false)
"3.80"

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

> "... @fixed(3.7979, 2, false) ..."
"3.80"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "fixed(3.7979, 2, false)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "3.80" = result
"3.80"
iex> Expression.evaluate_as_string!(
...>   "@fixed(3.7979, 2, false)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"3.80"

Example 4:

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

> fixed(3.7979, 2)
"3.80"

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

> "... @fixed(3.7979, 2) ..."
"3.80"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "fixed(3.7979, 2)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "3.80" = result
"3.80"
iex> Expression.evaluate_as_string!(
...>   "@fixed(3.7979, 2)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"3.80"

Example 5:

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

> fixed(0.0909, 2)
"0.09"

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

> "... @fixed(0.0909, 2) ..."
"0.09"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "fixed(0.0909, 2)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert "0.09" = result
"0.09"
iex> Expression.evaluate_as_string!(
...>   "@fixed(0.0909, 2)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"0.09"

See Expression.Callbacks.handle/4.

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> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_all_words(\"the quick brown FOX\", \"the fox\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...>   "@has_all_words(\"the quick brown FOX\", \"the fox\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"true"

Example 2:

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

> has_all_words("the quick brown FOX", "red fox")
false

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

> "... @has_all_words("the quick brown FOX", "red fox") ..."
"false"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_all_words(\"the quick brown FOX\", \"red fox\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...>   "@has_all_words(\"the quick brown FOX\", \"red fox\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

Example 3:

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

> has_all_words(nil, "red fox")
false

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

> "... @has_all_words(nil, "red fox") ..."
"false"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_all_words(nil, \"red fox\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...>   "@has_all_words(nil, \"red fox\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

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> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_any_word(\"The Quick Brown Fox\", \"fox quick\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => "Quick Fox"} = result
%{"__value__" => true, "match" => "Quick Fox"}
iex> Expression.evaluate_as_string!(
...>   "@has_any_word(\"The Quick Brown Fox\", \"fox quick\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"true"

Example 2:

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

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> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_any_word(\"The Quick Brown Fox\", \"yellow\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "match" => nil} = result
%{"__value__" => false, "match" => nil}
iex> Expression.evaluate_as_string!(
...>   "@has_any_word(\"The Quick Brown Fox\", \"yellow\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

Tests whether text starts with beginning

Both text values are trimmed of surrounding whitespace, but otherwise matching is strict without any tokenization.

Example 1:

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

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

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

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

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_beginning(\"The Quick Brown\", \"the quick\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert true = result
true
iex> Expression.evaluate_as_string!(
...>   "@has_beginning(\"The Quick Brown\", \"the quick\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"true"

Example 2:

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

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

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

> "... @has_beginning("The Quick Brown", "the    quick") ..."
"false"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_beginning(\"The Quick Brown\", \"the    quick\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...>   "@has_beginning(\"The Quick Brown\", \"the    quick\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

Example 3:

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

> has_beginning("The Quick Brown", "quick brown")
false

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

> "... @has_beginning("The Quick Brown", "quick brown") ..."
"false"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_beginning(\"The Quick Brown\", \"quick brown\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> refute result
false
iex> Expression.evaluate_as_string!(
...>   "@has_beginning(\"The Quick Brown\", \"quick brown\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

Tests whether expression contains a date formatted according to our environment

This is very naively implemented with a regular expression.

Example 1:

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

true

with the following fields:

• date of type Date
• datetime of type DateTime
• match of type DateTime .

> has_date("the date is 15/01/2017 05:50")
%{"__value__" => true, "date" => ~D[2017-01-15], "datetime" => ~U[2017-01-15 05:50:00Z], "match" => ~U[2017-01-15 05:50:00Z]}

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

> "... @has_date("the date is 15/01/2017 05:50") ..."
"true"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date(\"the date is 15/01/2017 05:50\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "date" => ~D[2017-01-15], "datetime" => ~U[2017-01-15 05:50:00Z], "match" => ~U[2017-01-15 05:50:00Z]} = result
%{"__value__" => true, "date" => ~D[2017-01-15], "datetime" => ~U[2017-01-15 05:50:00Z], "match" => ~U[2017-01-15 05:50:00Z]}
iex> Expression.evaluate_as_string!(
...>   "@has_date(\"the date is 15/01/2017 05:50\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"true"

Example 2:

When used in the following Stack expression it returns a value of type Date: "2017-01-15".

> has_date("the date is 15/01/2017").date
~D[2017-01-15]

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

> "... @has_date("the date is 15/01/2017").date ..."
"2017-01-15"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date(\"the date is 15/01/2017\").date",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~D[2017-01-15] = result
~D[2017-01-15]
iex> Expression.evaluate_as_string!(
...>   "@has_date(\"the date is 15/01/2017\").date",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2017-01-15"

Example 3:

When used in the following Stack expression it returns a value of type DateTime: "2017-01-15T05:50:00Z".

> has_date("the date is 15/01/2017 05:50").datetime
~U[2017-01-15 05:50:00Z]

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

> "... @has_date("the date is 15/01/2017 05:50").datetime ..."
"2017-01-15T05:50:00Z"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date(\"the date is 15/01/2017 05:50\").datetime",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert ~U[2017-01-15 05:50:00Z] = result
~U[2017-01-15 05:50:00Z]
iex> Expression.evaluate_as_string!(
...>   "@has_date(\"the date is 15/01/2017 05:50\").datetime",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"2017-01-15T05:50:00Z"

Example 4:

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

false

with the following fields:

• date of type Null
• datetime of type Null
• match of type Null .

> has_date("there is no date here, just a year 2017")
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}

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

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

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date(\"there is no date here, just a year 2017\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil} = result
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}
iex> Expression.evaluate_as_string!(
...>   "@has_date(\"there is no date here, just a year 2017\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

Example 5:

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

false

with the following fields:

• date of type Null
• datetime of type Null
• match of type Null .

> has_date(1)
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}

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

> "... @has_date(1) ..."
"false"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date(1)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil} = result
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}
iex> Expression.evaluate_as_string!(
...>   "@has_date(1)",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

Example 6:

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

false

with the following fields:

• date of type Null
• datetime of type Null
• match of type Null when used with the following context:

%{"var" => 1}

> has_date(var)
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}

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

> "... @has_date(var) ..."
"false"

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date(var)",
...>   %{"var" => 1},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil} = result
%{"__value__" => false, "date" => nil, "datetime" => nil, "match" => nil}
iex> Expression.evaluate_as_string!(
...>   "@has_date(var)",
...>   %{"var" => 1},
...>   Expression.Callbacks.Standard
...> )
"false"

Tests whether expression is a date equal to date_string

Example 1:

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

true

with the following fields:

• match of type Date
• test of type Date .

> has_date_eq("the date is 15/01/2017", "2017-01-15")
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-15]}

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

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

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date_eq(\"the date is 15/01/2017\", \"2017-01-15\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-15]} = result
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-15]}
iex> Expression.evaluate_as_string!(
...>   "@has_date_eq(\"the date is 15/01/2017\", \"2017-01-15\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"true"

Example 2:

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

false

with the following fields:

• error of type Map
• match of type Null
• test of type Date .

> has_date_eq("there is no date here, just a year 2017", "2017-01-15")
%{"__value__" => false, "error" => %{"__type__" => "expression/v1error", "error" => true, "message" => "The first argument is nil"}, "match" => nil, "test" => ~D[2017-01-15]}

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

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

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date_eq(\"there is no date here, just a year 2017\", \"2017-01-15\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "error" => %{"__type__" => "expression/v1error", "error" => true, "message" => "The first argument is nil"}, "match" => nil, "test" => ~D[2017-01-15]} = result
%{"__value__" => false, "error" => %{"__type__" => "expression/v1error", "error" => true, "message" => "The first argument is nil"}, "match" => nil, "test" => ~D[2017-01-15]}
iex> Expression.evaluate_as_string!(
...>   "@has_date_eq(\"there is no date here, just a year 2017\", \"2017-01-15\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

Tests whether expression is a date after the date date_string

Example 1:

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

true

with the following fields:

• match of type Date
• test of type Date .

> has_date_gt("the date is 15/01/2017", "2017-01-01")
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-01]}

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

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

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date_gt(\"the date is 15/01/2017\", \"2017-01-01\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-01]} = result
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-01-01]}
iex> Expression.evaluate_as_string!(
...>   "@has_date_gt(\"the date is 15/01/2017\", \"2017-01-01\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"true"

Example 2:

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

false

with the following fields:

• match of type Date
• test of type Date .

> has_date_gt("the date is 15/01/2017", "2017-03-15")
%{"__value__" => false, "match" => ~D[2017-01-15], "test" => ~D[2017-03-15]}

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

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

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date_gt(\"the date is 15/01/2017\", \"2017-03-15\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "match" => ~D[2017-01-15], "test" => ~D[2017-03-15]} = result
%{"__value__" => false, "match" => ~D[2017-01-15], "test" => ~D[2017-03-15]}
iex> Expression.evaluate_as_string!(
...>   "@has_date_gt(\"the date is 15/01/2017\", \"2017-03-15\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"

Tests whether expression contains a date before the date date_string

Example 1:

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

true

with the following fields:

• match of type Date
• test of type Date .

> has_date_lt("the date is 15/01/2017", "2017-06-01")
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-06-01]}

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

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

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date_lt(\"the date is 15/01/2017\", \"2017-06-01\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-06-01]} = result
%{"__value__" => true, "match" => ~D[2017-01-15], "test" => ~D[2017-06-01]}
iex> Expression.evaluate_as_string!(
...>   "@has_date_lt(\"the date is 15/01/2017\", \"2017-06-01\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"true"

Example 2:

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

false

with the following fields:

• match of type Date
• test of type Date .

> has_date_lt("the date is 15/01/2021", "2017-03-15")
%{"__value__" => false, "match" => ~D[2021-01-15], "test" => ~D[2017-03-15]}

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

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

iex> import ExUnit.Assertions
iex> result = Expression.evaluate_block!(
...>   "has_date_lt(\"the date is 15/01/2021\", \"2017-03-15\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
iex> assert %{"__value__" => false, "match" => ~D[2021-01-15], "test" => ~D[2017-03-15]} = result
%{"__value__" => false, "match" => ~D[2021-01-15], "test" => ~D[2017-03-15]}
iex> Expression.evaluate_as_string!(
...>   "@has_date_lt(\"the date is 15/01/2021\", \"2017-03-15\")",
...>   %{},
...>   Expression.Callbacks.Standard
...> )
"false"