Tell the user that Culprit is not of the expected ValidType.
This error is closely related to domain_error/2
because the notion of types is not really set in stone in Prolog. We
introduce the difference using a simple example.
Suppose an argument must be a non-negative integer. If the actual
argument is not an integer, this is a type_error. If it is a
negative integer, it is a domain_error.
Typical borderline cases are predicates accepting a compound term,
e.g., point(X,Y)
. One could argue that the basic type is a
compound-term and any other compound term is a domain error. Most Prolog
programmers consider each compound as a type and would consider a
compound that is not point(_,_)
a type_error.
True if Term satisfies the type constraints for Type.
Defined types are atom
, atomic
, between
, boolean
, callable
,
chars
, codes
, text
, compound
, constant
, float
,
integer
, nonneg
, positive_integer
, negative_integer
,
nonvar
, number
, oneof
, list
, list_or_partial_list
,
symbol
, var
, rational
, encoding
, dict
and string
.
Most of these types are defined by an arity-1 built-in predicate of
the same name. Below is a brief definition of the other types.
acyclic | Acyclic term (tree); see acyclic_term/1 |
any | any term |
between(FloatL,FloatU) | Number
[FloatL..FloatU] |
between(IntL,IntU) | Integer [IntL..IntU] |
boolean | One of true or false |
callable | Atom or compound term |
char | Atom of length 1 |
chars | Proper list of 1-character atoms |
code | Representation Unicode code point (0..0x10ffff) |
codes | Proper list of Unicode character codes |
compound | compound term |
compound(Term) | Compound with same
name/arity as term; checks arguments |
constant | Same as atomic |
cyclic | Cyclic term (rational tree); see cyclic_term/1 |
dict | A dictionary term; see is_dict/1 |
encoding | Valid name for a character encoding; see current_encoding/1 |
list | A (non-open) list; see is_list/1 |
list(Type) | Proper list with elements of Type |
list_or_partial_list | A list or an open list (ending in a
variable); see is_list_or_partial_list/1 |
negative_integer | Integer < 0 |
nonneg | Integer >= 0 |
oneof(L) | Ground term that is member of L |
pair | Key-Value pair. Same as compound(any-any) |
positive_integer | Integer > 0 |
proper_list | Same as list |
stream | A stream name or valid stream handle; see is_stream/1 |
symbol | Same as atom |
text | One of atom , string , chars
or codes |
type | Term is a valid type specification |
In addition, types may be composed using TypeA,TypeB
,
TypeA;TypeB
and negated using \Type
.
- throws
- instantiation_error if Term is insufficiently instantiated
and
type_error(Type, Term)
if Term is not of Type.