object

expected(Reference)

Expected term reference predicates. Requires passing a reference constructed using the “expected” object as a parameter.

Author: Paulo Moura
Version: 1.2
Date: 2019/1/24
Compilation flags:
static, context_switching_calls

(no dependencies on other entities)

Public interface

is_unexpected/0

True if the reference holds an unexpected term. Avoid whenever possible by using instead the if_unexpected/1 predicate.

Compilation flags:
static
Mode and number of proofs:
is_unexpected - zero_or_one

is_expected/0

True if the reference holds an expected term. Avoid whenever possible by using instead the if_expected/1 predicate.

Compilation flags:
static
Mode and number of proofs:
is_expected - zero_or_one

if_unexpected/1

Applies a closure when the reference holds an unexpected term using the term as argument. Succeeds otherwise. Can be used to throw the exception hold by the reference by calling it the atom “throw”.

Compilation flags:
static
Template:
if_unexpected(Closure)
Meta-predicate template:
if_unexpected(1)
Mode and number of proofs:
if_unexpected(+callable) - zero_or_more

if_expected/1

Applies a closure when the reference holds an expected term using the term as argument. Succeeds otherwise.

Compilation flags:
static
Template:
if_expected(Closure)
Meta-predicate template:
if_expected(1)
Mode and number of proofs:
if_expected(+callable) - zero_or_more

unexpected/1

Returns the unexpected term hold by the reference. Throws an error otherwise.

Compilation flags:
static
Template:
unexpected(Unexpected)
Mode and number of proofs:
unexpected(--term) - one_or_error
Exceptions:
Reference holds an expected term:
existence_error(unexpected_term,Reference)

expected/1

Returns the expected term hold by the reference. Throws an error otherwise.

Compilation flags:
static
Template:
expected(Expected)
Mode and number of proofs:
expected(--term) - one_or_error
Exceptions:
Reference holds an unexpected term:
existence_error(expected_term,Reference)

map/2

When the reference does not hold an unexpected term and mapping a closure with the expected term and the new expected term as additional arguments is successful, returns a reference with the new expected term. Otherwise returns the same reference.

Compilation flags:
static
Template:
map(Closure,NewReference)
Meta-predicate template:
map(2,*)
Mode and number of proofs:
map(+callable,--nonvar) - one

flat_map/2

When the reference does not hold an unexpected term and mapping a closure with the expected term and the new reference as additional arguments is successful, returns the new reference. Otherwise returns the same reference.

Compilation flags:
static
Template:
flat_map(Closure,NewReference)
Meta-predicate template:
flat_map(2,*)
Mode and number of proofs:
flat_map(+callable,--nonvar) - one

or_else/2

Returns the expected term hold by the reference if it does not hold an unexpected term or the given default term if the reference holds an unexpected term.

Compilation flags:
static
Template:
or_else(Expected,Default)
Mode and number of proofs:
or_else(--term,@term) - one

or_else_get/2

Returns the expected term hold by the reference if it does not hold an unexpected term. Otherwise applies a closure to compute the expected term. Throws an error when the reference holds an unexpected term and an expected term cannot be computed.

Compilation flags:
static
Template:
or_else_get(Expected,Closure)
Meta-predicate template:
or_else_get(*,1)
Mode and number of proofs:
or_else_get(--term,+callable) - one_or_error
Exceptions:
Reference holds an unexpected term and an expected term cannot be computed:
existence_error(expected_term,Reference)

or_else_call/2

Returns the expected term if the reference does not hold an unexpected term. Calls a goal deterministically otherwise.

Compilation flags:
static
Template:
or_else_call(Expected,Goal)
Meta-predicate template:
or_else_call(*,0)
Mode and number of proofs:
or_else_call(--term,+callable) - zero_or_one

or_else_throw/1

Returns the expected term hold by the reference if present. Throws the unexpected term as an error otherwise.

Compilation flags:
static
Template:
or_else_throw(Expected)
Mode and number of proofs:
or_else_throw(--term) - one_or_error

or_else_fail/1

Returns the expected term hold by the reference if it does not hold an unexpected term. Fails otherwise. Usually called to skip over references holding unexpected terms.

Compilation flags:
static
Template:
or_else_fail(Expected)
Mode and number of proofs:
or_else_fail(--term) - zero_or_one

Protected interface

(none)

Private predicates

(none)

Operators

(none)

Remarks

(none)

See also

expected