In the .NET class library, this type is Lazy<T>
Have you read Strachey's "Fundamental Concepts in Programming Languages"[1]? You seem to have rediscovered lvalues.
[1] https://www.itu.dk/courses/BPRD/E2009/fundamental-1967.pdf
That would prevent treating function calls as special.
It's interesting to see how far you can get without eval.
If you're passing around a piece of code with an environment, you effectively have a lambda already: one that is condemned to slow interpretation.
Without the environment passing for proper referencing semantics, the implementation wouldn't be a correct call-by-name reference; it would not pass Knuth's Man-or-boy test.
https://en.wikipedia.org/wiki/Evaluation_strategy#Call_by_na...
Call-by-name in Lisp macros, to implement Knuth's "Man or boy test" program: https://rosettacode.org/wiki/Man_or_boy_test#TXR
As you can see, the make-cbn-val constructor packages up the argument as an object ("thunk") that contains zero-argument lambda for getting the value, and a one-argument setter.
Inside a call-by-name function, references to all the call-by-name arguments are converted according to the pattern X -> (cbn-val X), using a lexical macro.
(cbn-val ...) syntax is treated as a place thanks to the (defplace (cbn-val thunk) ...) definition.
In the following, the (inc a) applied on the call-by-name argument a turns into (set-cbn-val #:g0098 (succ (cbn-val #:g0098)))): get the value, find successor, store the value.
4> (expand '(defun-cbn foo (a) (inc a)))
(progn (defun #:g0091
())
(defmacro foo args (list* 'cbn '#:g0091 args))
(let ((#:g0095 (sys:get-fun-getter-setter '#:g0091)))
(call (cdr #:g0095)
(lambda (#:g0092)
(block foo (let ((foo))
(let ((#:g0098 #:g0092))
(set-cbn-val #:g0098 (succ (cbn-val #:g0098))))
foo))))))
An empty function is defined, named by a gensym. Two steps later in the progn, this function binding is overwritten with the real function. A macro called foo is generated which provides the syntactic sugar for calling foo, automatically converting the arguments to thunks. The syntax (foo a b c) turns into (cbn #:g0091 a b c), which is another macro operator for doing call by name.The actual function starts at (lambda (#g:0092) ...). The (let ((foo)) ...) part simulates another Algol feature: returning a value is done by assigning to the function name. Our function returns nil because it doesn't assign anything to foo.
The call (foo x) expands like this:
5> (macroexpand '(foo x))
(call (fun #:g0083)
(make-cbn-val
x))
Or fully: 6> (expand '(foo x))
(call (fun #:g0083)
(make-struct 'cbn-thunk
(list 'get (lambda () x)
'set (lambda (#:g0099)
(sys:setq x #:g0099)))))
The make-struct call is an expansion of the new macro operator; that comes from the object system: 11> (macroexpand-1 '(make-cbn-val x))
(new cbn-thunk
get (lambda () x)
set (lambda (#:g0104)
(set x #:g0104)))
In action: watch x get incremented by foo: 12> (defvar x 10)
x
13> (foo x)
nil
14> x
11
Of course, this is objectionably hacky because foo isn't a function; we can't pass it around or anything.The goal was only to solve the Rosetta Code "Man or boy" task, with a focus on actually emulating the language features to some degree of fidelity, so that the program could truly be a transliteration of Knuth's code into Lisp expressions, almost node for node.
fn A(k, &x1, &x2, &x3, &x4, &x5) {
fn B() {
k = k - 1
return A(k, B(), *x1, *x2, *x3, *x4)
}
if k <= 0 {
return *x4 + *x5
} {
return B()
}
}
print A(10, 1, -1, -1, 1, 0)
Only a few languages can do this without some form of explicit wrappers in the top-level call to A.
https://github.com/jhallen/joes-sandbox/tree/master/lang/ivy
The idea is that in a function call, the arguments are normally evaluated before the call as usual. But if a formal argument in the function's declaration is prefixed with ampersand then during a function call, that argument is not evaluated, but is instead packaged up as a zero-argument lambda function. The argument can be called later using the normal function call syntax, but also there is semantic sugar: the * operator calls a zero-argument function.
Further, when a variable is evaluated, you get both its value and a reference to it. This allows variables to be evaluated before being assigned to in assignments. This sounds weird, but it works with the above. You can make a "set" function which does the same thing as assignment:
Here is how you could define switch using primitives (if the last argument is prefixed with ampersand, then any extra arguments are treated the same, but can only be accessed via argv): Example use (8 arguments passed to switch- each set of braces is an argument): "two" is printed in this case.Right now the delayed arguments are evaluated in the closure of the function call (so they are lexically scoped). The wrap/unwrap concept from this paper gives me ideas on how to make this more versatile...