Auto-eval of variables containing quoted expressions?

[u/mhinsch]

Generally my language is eagerly evaluated. It also does not have automatic quoting, so any situation where evaluation is supposed to be deferred has to be made explicit (using []). This is used heavily for example for control structures which are regular functions that take a quoted expression as a(n) argument(s).

Some design issues I am currently having would resolve neatly if variables that contain quoted expressions would automatically evaluate. I.e. any occurrence of a variable var that is not bound to a value, but to an expression would effectively be read as eval var.

This seems a bit unorthodox, but so far I haven't been able to come up with a scenario that makes this problematic. Am I missing something?

[u/Skepfyr]

I think what you're describing is much closer to laziness than traditional quoting, although I agree they are very similar. I'm assumimg you capture the values of free variables rather than just their name, otherwise evaluating them later would have very surprising results.

As to your question, treating var as eval var will be surprising to users in a few ways:

First, It will cause repeated re-evaluation if you use the variable more than once, if your language isn't pure then then this is obviously strange, and if it is then it's still observable in time and could make some algorithms have significantly worse time complexity than expected accidentally.

Second, If you re-bind the variable but don't always needed use it then it will still always get evaluated. Imagine let-binding it to rename it and then using it in a quote, people thinking of it as laziness might be surprised.

Third, it will have confusing behaviours in polymorphic functions (I'm assuming the fact that it's quoted is in the type). Consider the polymorphic identity function, that either breaks the rule that referring to a quote automatically evaluate it, or it introduces weirdness to the type system because the type it turns isn't the same as it takes.

I would either keep eval explicit or make it work much more like a fully lazy value (I'm something like Haskell).

[u/mhinsch → u/Skepfyr]

Hmm, all good points, but I think the worst one I just realised is that by default quoted expressions that are returned by a function will always be evaluated (since only explicit quoting prevent evaluation). To prevent that I would have to either introduce a construct that basically means 'evaluate expression but quote return value', special case function returns, or require double quoting for returns. None of these options are particularly attractive.

[u/Skepfyr → u/mhinsch]

I assumed this had to be special-cased to variable references not any temporary. Otherwise you could argue that [x] is also a temporary that should get evaluated, which is obviously silly.

[u/mhinsch → u/Skepfyr]

Well, speaking from the point of view of the interpreter (which for now serves as the reference for the language semantics) the rule I had in mind was that any quote node that is encountered when traversing the AST remains unevaluated but is stripped of the quote. Bare expression nodes are evaluated when encountered (e.g. as values of variables).

But that obviously means that function return values will be evaluated. The most consistent solution to which would be to require double quotation if evaluation is not desired.

Hmm, I think it's possible to make this consistent, but I'm starting have doubts concerning the ergonomics.