Make record realms accessible during record definition

[neshtea]

There are cases where we want to define a record via def-record and need access the record type in the body of the record definition. Example:

(record/def-record foo
  [foo-do-something :- (realm/function -> foo)])

Right now, this doesn't compile since the foo record type is not yet available during definition. To work around it, we can combine a declare with a realm/delay to achieve the desired result:

(declare foo)

(record/def-record foo
  [foo-do-something :- (realm/function -> (realm/delay foo))])

It would be nice to be able to define such a record type without the cumbersome declare plus delay workaround.

[mikesperber]

AFAICS, the declare is not needed once the realm/delay is in place.

But this doesn't help you when you want to define a mutually recursive tree datatype, where you still need a declare form somewhere.

I'd rather not have def-record introduce a realm/delay, as it hides the performance implications of what's going on.

@neshtea But how about adding (realm/recursive <identifier>) which expands to

(do (declare <identifier>) (realm/delay <identifier))

?

[neshtea]

I'd rather not have def-record introduce a realm/delay, as it hides the performance implications of what's going on.

I'm not sure I understand -- what are the performance implications of realm/delay? Do they occur at runtime or during macro-expansion?

@neshtea But how about adding (realm/recursive <identifier>) which expands to

(do (declare <identifier>) (realm/delay <identifier))

?

I'd be fine with that. It's elegant enough and I actually quite like the explicit nature of the realm/recursive-call.

I do see a potential downside though (depending on what realm/delay actually does): What happens with typos if we just automatically declare the mutually recursive types name? Would it silently fail? Example

(record/def-record zero [])
(record/def-record succ-e 
  [succ-e-value :- (realm/recursive oddd)])  ; <- Here's the typo.
(def realm:event (realm/union zero succ-e))
(record/def-record odd
  [odd-succ :- (realm/recursive realm:even)])

[mikesperber]

The performance implication is mainly at validation time, where you go through an additional indirection/check at the realm level for every indirection at the value level.

As to the fail question: It'll silently fail until you do something with the realm. Validation would trigger a failure, for instance. (That's an inherent problem in Clojure, I'm afraid.)

[neshtea]

The performance implication is mainly at validation time, where you go through an additional indirection/check at the realm level for every indirection at the value level.

Thanks for clarifying. I don't mind the additional indirection for checking as long as it's optional.

That's an inherent problem in Clojure, I'm afraid.

Not really, no. That's the exact point of the issue, isn't it: We want to 'delay' the recursive evaluation because Clojure does check whether or not there's an active binding for that var. Nevertheless, I'm fine with that as well, I just wanted to bringt that up in case someone is oppose to that behaviour.