Scion
A function ancestrally dependent on apply$
The function fn is a scion of apply$ or simply a
scion if the function is ancestrally dependent on apply$. That
is, fn is apply$, or fn calls apply$, or calls a function
that calls apply$, or calls a function that calls a function that calls
apply$, etc.
Meriam-Webster defines scion as ``a descendant of a wealthy,
aristocratic, or influential family.''
Examples of scions include apply$, collect$ and foldr, where
the last two are defined as shown below.
(defun$ collect$ (fn lst)
(if (endp lst)
nil
(cons (apply$ fn (list (car lst)))
(collect$ fn (cdr lst)))))
(defun$ foldr (lst fn init)
(if (endp lst)
init
(apply$ fn
(list (car lst)
(foldr (cdr lst) fn init)))))
Note: Collect$, which is part of the support for the loop$
statement, is pre-defined in ACL2 but foldr is not.
Most often, scions treat one or more of their arguments as ``functions,''
i.e., have at least one formal of ilk :FN. But that is not necessarily
the case. Collect$-squares, as defined below,
(defun$ collect$-squares (lst)
(collect$ (lambda$ (x) (* x x)) lst))
is a scion even though it does not have a formal of ilk :FN.
However, it calls the scion collect$.
The function defined by
(defun$ collect$-expr (x lst alist)
(if (endp lst)
nil
(cons (ev$ x (cons (cons 'v (car lst)) alist))
(collect$-expr x (cdr lst) alist))))
is a scion because it calls ev$ which calls apply$ in the
mutually recursive clique that defines them both. Note that the ilks of the
formals of collect$-expr are :EXPR, NIL and NIL,
respectively. The function collects the successive values of the expression
x under extensions of alist binding the variable symbol v to
successive elements of lst.
In the early days of apply$ we used the term ``mapping function'' to
refer to scions. But that nomenclature was misleading because in the Lisp
culture ``mapping'' tends to be understood as a kind of linear iteration.
Fans of higher order logic have suggested we use the term ``functional''
for our scions, or at least for those scions having at least one formal of
ilk :FN. However, we have resisted that suggestion because a functional
takes a function as an argument and is thus a higher-order entity, but ACL2
is first-order, functions are never objects in ACL2, and the values of our
:FN formals are ordinary objects like symbols and lists that are
interpreted as functions.
