Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the cl-unification Reference Manual, generated automatically by Declt version 3.0 "Montgomery Scott" on Fri Jun 26 10:39:59 2020 GMT+0.
| • Introduction | What cl-unification is all about | |
| • Systems | The systems documentation | |
| • Files | The files documentation | |
| • Packages | The packages documentation | |
| • Definitions | The symbols documentation | |
| • Indexes | Concepts, functions, variables and data types |
CL-UNIFICATION ============== Marco Antoniotti (c) 2004-2020 ------------------------------ The directory containing this file you are reading should contain the code and the documentation of the CL-UNIFICATION package. The package is a full-blown library to "unify" arbitrary CL objects while constructing bindings for placeholders (unification variables) in a "template" sublanguage. A NOTE ON FORKING ----------------- Of course you are free to fork the project subject to the current licensing scheme. However, before you do so, I ask you to consider plain old "cooperation" by asking me to become a developer. It helps keeping the entropy level at an acceptable level. Enjoy.
Next: Files, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The cl-unification system |
Marco Antoniotti
BSD
The CL-UNIFICATION system.
The system contains the definitions for the ’unification’ machinery.
cl-unification.asd (file)
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files |
Next: The cl-unification/cl-unification-pkg․lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
cl-unification.asd
cl-unification (system)
asdf-system-definition-file (class)
Next: The cl-unification/variables․lisp file, Previous: The cl-unification․asd file, Up: Lisp files [Contents][Index]
cl-unification (system)
cl-unification-pkg.lisp
Next: The cl-unification/substitutions․lisp file, Previous: The cl-unification/cl-unification-pkg․lisp file, Up: Lisp files [Contents][Index]
cl-unification-pkg.lisp (file)
cl-unification (system)
variables.lisp
make-var-name (function)
Next: The cl-unification/lambda-list-parsing․lisp file, Previous: The cl-unification/variables․lisp file, Up: Lisp files [Contents][Index]
variables.lisp (file)
cl-unification (system)
substitutions.lisp
Next: The cl-unification/templates-hierarchy․lisp file, Previous: The cl-unification/substitutions․lisp file, Up: Lisp files [Contents][Index]
substitutions.lisp (file)
cl-unification (system)
lambda-list-parsing.lisp
Next: The cl-unification/unifier․lisp file, Previous: The cl-unification/lambda-list-parsing․lisp file, Up: Lisp files [Contents][Index]
lambda-list-parsing.lisp (file)
cl-unification (system)
templates-hierarchy.lisp
Next: The cl-unification/match-block․lisp file, Previous: The cl-unification/templates-hierarchy․lisp file, Up: Lisp files [Contents][Index]
templates-hierarchy.lisp (file)
cl-unification (system)
unifier.lisp
Next: The cl-unification/apply-substitution․lisp file, Previous: The cl-unification/unifier․lisp file, Up: Lisp files [Contents][Index]
unifier.lisp (file)
cl-unification (system)
match-block.lisp
Next: The cl-unification/cl-unification-lib․lisp file, Previous: The cl-unification/match-block․lisp file, Up: Lisp files [Contents][Index]
match-block.lisp (file)
cl-unification (system)
apply-substitution.lisp
Previous: The cl-unification/apply-substitution․lisp file, Up: Lisp files [Contents][Index]
apply-substitution.lisp (file)
cl-unification (system)
cl-unification-lib.asd
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The cl-unification-system package | ||
| • The it.unimib.disco.ma.cl.ext.dacf.unification package |
Next: The it․unimib․disco․ma․cl․ext․dacf․unification package, Previous: Packages, Up: Packages [Contents][Index]
cl-unification.asd
asdf-system-definition-file (class)
Previous: The cl-unification-system package, Up: Packages [Contents][Index]
The CL.EXT.DACF.UNIFICATION Package.
This package contains all the definitions necessary for the general
Common Lisp unifier to work.
The package also has the "UNIFY" nickname.
cl-unification-pkg.lisp (file)
common-lisp
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions | ||
| • Internal definitions |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported special variables | ||
| • Exported macros | ||
| • Exported functions | ||
| • Exported generic functions | ||
| • Exported conditions | ||
| • Exported structures | ||
| • Exported classes | ||
| • Exported types |
Next: Exported macros, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
unifier.lisp (file)
Next: Exported functions, Previous: Exported special variables, Up: Exported definitions [Contents][Index]
Sets up a lexical environment to evaluate FORMS after an unification.
MATCH unifies a TEMPLATE and an OBJECT and then sets up a lexical
environment where the variables present in the template are bound
lexically. Note that both variable names ’?FOO’ and ’FOO’ are bound
for convenience.
The MATCH form returns the values returned by the evaluation of the
last of the FORMS.
If ERRORP is non-NIL (the default) then the form raises a
UNIFICATION-FAILURE, otherwise the result of evaluating ERROR-VALUE,
whose default is NIL is returned. (Note that UNIFICATION-FAILUREs
raising from the evaluation of FORMS will also be caught and handled
according to ERRORP settings.)
If MATCH-NAMED is not NIL, then a surrounding BLOCK named MATCH-NAMED
is set up around the matching code.
match-block.lisp (file)
MATCH-CASE sets up a CASE-like environment for multiple template matching clauses.
The syntax of MATCH-CASE comprises a number of clauses of the form
<pre>
clause ::= regular-clause | default-clause
regular-clause ::= ’(’ template ’&body’ forms ’)’
default-clause ::= ’(’ t ’&body’ forms ’)’
| ’(’ ’otherwise’ ’&body’ forms ’)’
</pre>
’form’ and ’forms’ are regular Common Lisp forms.
’template’ is a unification template.
The full syntax of MATCH-CASE is
<pre>
match-case (object &key errorp default-substitution) clauses
</pre>
Each clause evaluates its forms in an environment where the variables
present in the template are bound lexically. Note that both variable
names ’?FOO’ and ’FOO’ are bound for convenience.
The values returned by the MATCH-CASE form are those of the last form in
the first clause that satisfies the match test.
If ERRORP is non-NIL then if none of the regular clauses matches, then
an error of type UNIFICATION-NON-EXAUSTIVE is signalled, regardless of
any default clause. Otherwise, the default clause behaves as a
standard CASE default clause. The default value of ERRORP is NIL.
MATCHING-NAMED is used as BLOCK name around the MATCHING machinery.
DEFAULT-SUBSTITUTION is the substitution to be used for the matching;
it defaults to the empty substitution.
match-block.lisp (file)
Sets up a lexical environment to evaluate FORMS after an unification.
MATCHF unifies a TEMPLATE and an OBJECT and then sets up a lexical
environment where the variables present in the template are bound
lexically. Note that both variable names ’?FOO’ and ’FOO’ are bound
for convenience.
MATCHF does not ’evaluate’ TEMPLATE (note that using the #T syntax will
generate a template at read-time).
The MATCHF form returns the values returned by the evaluation of the
last of the FORMS.
If ERRORP is non-NIL (the default) then the form raises a
UNIFICATION-FAILURE, otherwise the result of evaluating ERROR-VALUE,
whose default is NIL is returned. (Note that UNIFICATION-FAILUREs
raising from the evaluation of FORMS will also be caught and handled
according to ERRORP settings.)
If MATCH-NAMED is not NIL, then a surrounding BLOCK named MATCH-NAMED
is set up around the matching code.
match-block.lisp (file)
MATCHF-CASE sets up a CASE-like environment for multiple template matching clauses.
The syntax of MATCHF-CASE comprises a number of clauses of the form
<pre>
clause ::= regular-clause | default-clause
regular-clause ::= ’(’ template ’&body’ forms ’)’
default-clause ::= ’(’ t ’&body’ forms ’)’
| ’(’ ’otherwise’ ’&body’ forms ’)’
</pre>
’form’ and ’forms’ are regular Common Lisp forms.
’template’ is a unification template.
The full syntax of MATCHF-CASE is
matchf-case (object &key errorp default-substitution) clauses
Each clause evaluates its forms in an environment where the variables
present in the template are bound lexically. Note that both variable
names ’?FOO’ and ’FOO’ are bound for convenience.
The values returned by the MATCH-CASE form are those of the last form in
the first clause that satisfies the match test.
If ERRORP is non-NIL then if none of the regular clauses matches, then
an error of type UNIFICATION-NON-EXAUSTIVE is signalled, regardless of
any default clause. Otherwise, the default clause behaves as a
standard CASE default clause. The default value of ERRORP is NIL.
MATCHING-NAMED is used as BLOCK name around the MATCHING machinery.
DEFAULT-SUBSTITUTION is the substitution to be used for the matching;
it defaults to the empty substitution.
Notes:
MATCHF-CASE behaves like MATCH-CASE, but the patterns are not
evaluated; i.e., it relies on MATCHF instead of MATCH to construct the
macro expansion.
match-block.lisp (file)
MATCHING sets up a COND-like environment for multiple template matching clauses.
The syntax of MATCHING comprises a number of clauses, collected in
MATCH-CLAUSES, of the form
<pre>
clause ::= regular-clause | default-clause
regular-clause ::= ’(’ ’(’ template form ’)’ ’&body’ forms ’)’
default-clause ::= ’(’ ’t’ ’&body’ forms ’)’
| ’(’ ’otherwise’ ’&body’ forms ’)’
</pre>
’form’ and ’forms’ are regular Common Lisp forms.
’template’ is a unification template.
The full syntax of MATCHING is
<pre>
matching (&key errorp default-substitution) clauses
</pre>
Each clause evaluates its forms in an environment where the variables
present in the template are bound lexically. Note that both variable
names ’?FOO’ and ’FOO’ are bound for convenience.
The values returned by the MATCHING form are those of the last form in
the first clause that satisfies the match test.
If ERRORP is non-NIL then if none of the regular clauses matches, then
an error of type UNIFICATION-NON-EXAUSTIVE is signalled, regardless of
any default clause. Otherwise, the default clause behaves as a
standard COND default clause. The default value of ERRORP is NIL.
MATCHING-NAMED is used as BLOCK name around the MATCHING machinery.
DEFAULT-SUBSTITUTION is the substitution to be used for the matching;
it defaults to the empty substitution.
match-block.lisp (file)
Next: Exported generic functions, Previous: Exported macros, Up: Exported definitions [Contents][Index]
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
Finds the value associated to VARIABLE in ENV.
VARIABLE is a unification variable; if ERRORP is non-null an error is
signaled if VARIABLE is not found in the environment ENV.
The function returns two values: the value associated to VARIABLE or
NIL, and an indication about whether an association was actually found
in ENV.
Arguments and Values:
VARIABLE : a unification variable
ENV : and ENVIRONMENT
ERRORP : a generalized Boolean
result : a T
foundp : a BOOLEAN
Exceptional Situations:
If an error is signaled, then it is an instance of UNIFICATION-VARIABLE-UNBOUND.
Notes:
FIND-VARIABLE-VALUE is almost symmetric to IS-VARIABLE-BOUND.
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
variables.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
unifier.lisp (file)
unifier.lisp (file)
unifier.lisp (file)
Finds the value associated to the variable S in ENV.
This function is essentialy a convenience wrapper around
FIND-VARIABLE-VALUE. If PLAIN-SYMBOL-P is non-NIL, then the symbol S
is ensured to be a ’unification variable’ (with a #? first
character).
Exceptional Situations:
A UNIFICATION-VARIABLE-UNBOUND may be signaled is ERRORP is non-nil and no association si found for S in ENV.
substitutions.lisp (file)
variables.lisp (file)
variables.lisp (file)
Next: Exported conditions, Previous: Exported functions, Up: Exported definitions [Contents][Index]
Applies a SUBSTITUTION to an ITEM.
apply-substitution.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
The ’template’ factory.
Creates a TEMPLATE instance based on the values of KIND and SPEC.
Arguments and Values:
KIND : a T
SPEC : a T
result : a TEMPLATE
Exceptional Situations:
May signal an error if a particular combination of KIND and SPEC is either not consistent or handled.
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
Returns T if the argument X is a TEMPLATE.
Arguments and Values:
X : any object
result : a BOOLEAN
templates-hierarchy.lisp (file)
automatically generated reader method
templates-hierarchy.lisp (file)
automatically generated writer method
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
Unifies two objects A and B given a substitution ENV.
A is a Common Lisp object and B is either a Common Lisp object or a
"template", A and B can be commuted.
The unification rules are rather complex. Each method of the generic
function implements a specific rule of unification.
The generic function returns a ‘substitution’ upon success or it signals a UNIFICATION-FAILURE condition upon failure.
unifier.lisp (file)
Unifies two strings A and B.
Two strings A and B unify if and only if they satisfy either #’STRING= or
#’STRING-EQUAL. The choice of which of test to perform (#’STRING= or #’STRING-EQUAL)
is made according to the value of the variable
*UNIFY-STRING-CASE-SENSITIVE-P*, which defaults to T.
If A and B unify then an unmodified environment ENV is returned,
otherwise an error of type UNIFICATION-FAILURE is signaled.
Unifies two strings A and B.
Two CHARACTERs A and B unify if and only if they satisfy either #’CHAR= or
#’CHAR-EQUAL. The choice of which of test to perform (#’CHAR= or #’CHAR-EQUAL)
is made according to the value of the variable
*UNIFY-STRING-CASE-SENSITIVE-P*, which defaults to T.
If A and B unify then an unmodified environment ENV is returned,
otherwise an error of type UNIFICATION-FAILURE is signaled.
Unifies two numbers A and B.
Two numbers unify only if and only if they are equal as per the function #’=, in
which case an unmodified envirironment ENV is returned.
Otherwise an error of type UNIFICATION-FAILURE is signalled.
Of course, asking for unification of two floating point numbers may
not yield the expected result.
Unifies a list A and a list B in an environment ENV.
The unification procedure proceedes recursively on each element of
both lists. If two elements cannot be unified then an error of type
UNIFICATION-FAILURE is signaled. Otherwise a possibly extended
environment is returned.
Unifies a symbol B and a list A in an environment ENV.
If A is not a variable then an error of type UNIFICATION-FAILURE is
signaled. If A is a unification variable, then the environment ENV is
extended with a binding for A to B, unless the occurrence check is
called and fails, in which case an error is signaled.
Unifies a symbol A and a list B in an environment ENV.
If A is not a variable then an error of type UNIFICATION-FAILURE is
signaled. If A is a unification variable, then the environment ENV is
extended with a binding for A to B, unless the occurrence check is
called and fails, in which case an error is signaled.
Next: Exported structures, Previous: Exported generic functions, Up: Exported definitions [Contents][Index]
substitutions.lisp (file)
simple-error (condition)
unification-non-exhaustive (condition)
This is the condition that is signaled
substitutions.lisp (file)
unbound-variable (condition)
Next: Exported classes, Previous: Exported conditions, Up: Exported definitions [Contents][Index]
The ENVIRONMENT structure.
The data structure containing the associations (bindings) between variables and values.
substitutions.lisp (file)
structure-object (structure)
list
environment-frames (function)
(setf environment-frames) (function)
Next: Exported types, Previous: Exported structures, Up: Exported definitions [Contents][Index]
The AREF-TEMPLATE Class.
The instances of this class are those object that are used to unify
against a particular element of an ARRAY.
The syntax of these templates is the following:
<pre>
#T(<b>aref</b> (<i>index1</i> ... <i>indexN</i>) <i>item</i>)
</pre>
<pre>
#T(<b>aref</b> <i>index</i> <i>item</i>)
</pre>
The AREF-TEMPLATE syntax denotes the <i>item</i> at <i>index1</i> ...
<i>indexN</i> of an ARRAY. An AREF-TEMPLATE must be unified against a
ARRAY object. <i>item</i> is <em>unified</em> against the element
extracted from the sequence object at <i>index1</i> ... <i>indexN</i>
by the standard function AREF.
The second form is a shorthand.
<pre>
#T(<b>aref</b> <i>index</i> <i>item</i>) <==> #T(<b>aref</b> (<i>index</i>) <i>item</i>)
</pre>
Examples:
cl-prompt> (setf e (unify #(0 1 42 3 4 5) #T(aref 2 ?x)))
#<ENVIRONMENT xxx>
cl-prompt> (find-variable-value ’?x e)
42
cl-prompt> (setq e (unify #(0 1 42 3 4 5) #T(aref 42 ?x)))
==> Error: index 42 out of bounds.
cl-prompt> (setq e (unify 42 #T(aref 42 ?x)))
==> Error: UNIFICATION-FAILURE
cl-prompt> (setq e (unify "This is a string!" #T(aref 4 ?x)))
#<ENVIRONMENT xxx>
cl-prompt> (find-variable-value ’?x e)
#\Space
cl-prompt> (setq e (unify #2A((1 0) (foo bar)) #T(aref (1 1) ?x)))
#<ENVIRONMENT xxx>
cl-prompt> (find-variable-value ’?x e)
BAR
cl-prompt> (setq e (unify #2A((1 0) (foo bar)) #T(aref (1 1) baz)))
==> Error: UNIFICATION-FAILURE
cl-prompt> (setq e (unify #2A((1 0) (foo ?x)) #T(aref (1 1) baz)))
#<ENVIRONMENT xxx>
cl-prompt> (find-variable-value ’?x e)
BAZ
Exceptional Situations:
Unifying an AREF-TEMPLATE against a non-ARRAY object results in an
UNIFICATION-FAILURE error being signaled.
templates-hierarchy.lisp (file)
element-template (class)
The ARRAY-TEMPLATE Class.
The instances of this class are objects that can be used to unify
against arrays.
The syntax of this particular template is the following:
<pre>
#T(array <shape-template>)
</pre>
<pre>
#T(<CL array type specifier> <shape-template>)
</pre>
<pre>
#T(array ([* | <CL type specifier>] [<dimension spec>]) <shape-template>)
</pre>
Where <shape-template> can be:
<pre>
<shape-template> ::= <sequence-template>
| <destructuring template lambda list>
| (<shape-template>)
</pre>
The ARRAY-TEMPLATE syntax denotes an ARRAY object. An ARRAY-TEMPLATE
must be unified against an ARRAY object. The elements of the array
must be unified against the <shape-template>. Each row of the
array is unified recursively against each element of the
<shape-template>.
Examples:
cl-prompt> (setf e (unify #(0 1 42 3 4 5) #T(array (0 1 ?x 3 4 5))))
#<ENVIRONMENT xxx>
cl-prompt> (find-variable-value ’?x e)
42
cl-prompt> (setq e (unify #(0 1 42 3 4 5) #T(array (0 1 "FOO" 3 4 5))))
==> Error: UNIFICATION-FAILURE
cl-prompt> (setq e (unify #2A((0 1 42) (3 4 5)) #T(array ((0 1 ?x) (3 4 5)))))
#<ENVIRONMENT xxx>
cl-prompt> (find-variable-value ’?x e)
42
cl-prompt> (setq e (unify #2A(("foo" "bar" 42) (3 4 5)) #T(array ((_ _ ?x) (3 4 5)))))
#<ENVIRONMENT xxx>
cl-prompt> (find-variable-value ’?x e)
42
cl-prompt> (setq e (unify #2A(("foo" "bar" 42) (3 4 5)) #T(array (#T(vector _ &rest ?x) (3 4 5)))))
#<ENVIRONMENT xxx>
cl-prompt> (find-variable-value ’?x e)
#("bar" 42)
Exceptional Situations:
Unifying an ARRAY-TEMPLATE against a non-ARRAY object results in an
UNIFICATION-FAILURE error being signaled.
Notes:
<h3>Syntax Note</h3>
The ARRAY-TEMPLATE syntax tries to be easy to use, at the cost of
being overloaded. There is no actual need to have the separate
forms <code>(<b>array</b> (fixnum) ...)</code> and
<code>((<b>array</b> fixnum) ...)</code>.
In a future release they may be conflated. For the time being
they are kept separate as it is unclear which would be better to
provide.
<h3>Elements Unification</h3>
It would be nice to have the possibility to unify against
<em>slices</em> of the array. Alas, this seems non trivial to get
right, and it is left as a future extension of the semantics of
<i><shape-template></i>.
<h3>ARRAY Structural Properties</h3>
For the time being, there is no way to "unify" against structural
properties of vectors like fill pointers and displacements.
templates-hierarchy.lisp (file)
type-template (class)
vector-template (class)
The ELEMENT-TEMPLATE Class.
The instances of this class are those object that are used to unify against a particular element of an ARRAY or a SEQUENCE.
templates-hierarchy.lisp (file)
expression-template (class)
element-template-p (method)
templates-hierarchy.lisp (file)
element-template (class)
The EXPRESSION-TEMPLATE Class.
This class is the root of the ’expression template’ sub-hierarchy.
templates-hierarchy.lisp (file)
template (class)
expression-template-p (method)
templates-hierarchy.lisp (file)
type-template (class)
templates-hierarchy.lisp (file)
element-template (class)
templates-hierarchy.lisp (file)
element-template (class)
nthcdr-template-p (method)
templates-hierarchy.lisp (file)
type-template (class)
templates-hierarchy.lisp (file)
type-template (class)
templates-hierarchy.lisp (file)
type-template (class)
templates-hierarchy.lisp (file)
type-template (class)
The TEMPLATE Class.
The root of the hierarchy of template objects.
templates-hierarchy.lisp (file)
standard-object (class)
(or symbol cons)
:spec
template-spec (generic function)
(setf template-spec) (generic function)
| Initarg | Value |
|---|---|
| :spec | nil |
templates-hierarchy.lisp (file)
template (class)
Previous: Exported classes, Up: Exported definitions [Contents][Index]
The SUBSTITUTION type.
The type representing the associations between variables and values.
Notes:
It is a synonim for the structure type ENVIRONMENT.
substitutions.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal special variables | ||
| • Internal functions | ||
| • Internal generic functions | ||
| • Internal conditions | ||
| • Internal structures | ||
| • Internal classes | ||
| • Internal types |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
templates-hierarchy.lisp (file)
substitutions.lisp (file)
unifier.lisp (file)
Next: Internal generic functions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
match-block.lisp (file)
apply-substitution.lisp (file)
lambda-list-parsing.lisp (file)
substitutions.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
Finds a BINDING for a VARIABLE in ENV.
The function returns a BINDING for VARIABLE in ENV, if it finds one.
Otherwise returns NIL.
Arguments and Values:
VARIABLE : a unification variable
ENV : and ENVIRONMENT
result : a BINDING or NIL.
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
apply-substitution.lisp (file)
Checks whether a VARIABLE is bound in ENV.
The function returns two values: a BOOLEAN that indicates whether
VARIABLE is bound in ENV and its value if so; otherwise the second
value is NIL.
Arguments and Values:
VARIABLE : a unification variable
ENV : and ENVIRONMENT
bounddp : a BOOLEAN
result : a T
Notes:
IS-VARIABLE-BOUND is almost symmetric to FIND-VARIABLE-VALUE.
substitutions.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
substitutions.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
variables.lisp (file)
lambda-list-parsing.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
substitutions.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
substitutions.lisp (file)
lambda-list-parsing.lisp (file)
templates-hierarchy.lisp (file)
lambda-list-parsing.lisp (file)
lambda-list-parsing.lisp (file)
unifier.lisp (file)
unifier.lisp (file)
unifier.lisp (file)
unifier.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
Next: Internal conditions, Previous: Internal functions, Up: Internal definitions [Contents][Index]
lambda-list-parsing.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
unifier.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
templates-hierarchy.lisp (file)
unifier.lisp (file)
templates-hierarchy.lisp (file)
Next: Internal structures, Previous: Internal generic functions, Up: Internal definitions [Contents][Index]
lambda-list-parsing.lisp (file)
program-error (condition)
lambda-list-parsing-error-item (method)
:item
lambda-list-parsing-error-item (generic function)
Condition thrown by ’match’ forms.
The condition UNIFICATION-FAILURE is thrown by ’match’ forms when it
can be established that there are other possible unifications for a
template.
match-block.lisp (file)
unification-failure (condition)
templates-hierarchy.lisp (file)
simple-error (condition)
Next: Internal classes, Previous: Internal conditions, Up: Internal definitions [Contents][Index]
lambda-list-parsing.lisp (file)
optional-lambda-var-info (structure)
substitutions.lisp (file)
structure-object (structure)
it.unimib.disco.ma.cl.ext.dacf.unification::bindings
frame-bindings (function)
(setf frame-bindings) (function)
lambda-list-parsing.lisp (file)
optional-lambda-var-info (structure)
key-lambda-var-info-keyword-name (function)
(setf key-lambda-var-info-keyword-name) (function)
lambda-list-parsing.lisp (file)
structure-object (structure)
lambda-var-info-name (function)
(setf lambda-var-info-name) (function)
t
lambda-var-info-type (function)
(setf lambda-var-info-type) (function)
lambda-list-parsing.lisp (file)
lambda-var-info (structure)
optional-lambda-var-info-default-value (function)
(setf optional-lambda-var-info-default-value) (function)
optional-lambda-var-info-name-for-supplied-indicator (function)
(setf optional-lambda-var-info-name-for-supplied-indicator) (function)
lambda-list-parsing.lisp (file)
lambda-var-info (structure)
t
rest-lambda-var-info-element-type (function)
(setf rest-lambda-var-info-element-type) (function)
Next: Internal types, Previous: Internal structures, Up: Internal definitions [Contents][Index]
cl-unification.asd
cl-source-file (class)
source-file-type (method)
templates-hierarchy.lisp (file)
lambda-template-p (method)
templates-hierarchy.lisp (file)
sequence-template (class)
list-template-p (method)
templates-hierarchy.lisp (file)
list-template (class)
templates-hierarchy.lisp (file)
type-template (class)
templates-hierarchy.lisp (file)
vector-template (class)
string-template-p (method)
templates-hierarchy.lisp (file)
expression-template (class)
templates-hierarchy.lisp (file)
string-template (class)
vector-template-p (method)
Previous: Internal classes, Up: Internal definitions [Contents][Index]
substitutions.lisp (file)
substitutions.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index | ||
| • Function index | ||
| • Variable index | ||
| • Data type index |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | C F L |
|---|
| Jump to: | C F L |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | (
A B C D E F G I K L M N O P R S T U V |
|---|
| Jump to: | (
A B C D E F G I K L M N O P R S T U V |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | *
B D E F I K N S T |
|---|
| Jump to: | *
B D E F I K N S T |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | A B C E F I K L N O P R S T U V |
|---|
| Jump to: | A B C E F I K L N O P R S T U V |
|---|