REIFY vs. LIFT vs.... SOMETHING

Development Naming
1

Originally I suggested that REIFY of an isotope would give its plain form, and you would LIFT it if you wanted a quasiform:

But that's not a full coverage answer.

  • An operator that takes everything "one level up", where antiforms become quasiforms and everything else gets a quote level added.

    >> okay
== \~okay~\  ; antiform

>> lift okay
== ~okay~

>> lift 10
== '10

  • An operator that leaves non-antiforms as they are, but turns antiforms into their quasiforms (and I think this probably is best called REIFY):

    >> okay
== \~okay~\  ; antiform

>> reify okay
== ~okay~

>> reify 10
== 10

  • An operator that leaves non-antiforms as they are, but turns antiforms into their plain forms:

    >> okay
== \~okay~\  ; antiform

>> something okay
== okay

>> something 10
== 10

Specifically for FRAME! antiforms (actions) being turned into plain FRAME!, I used an interim term UNRUN, but that's pretty awful. (UPDATE: it's still around, years later.)

It could be a refinement to REIFY, like REIFY:PLAIN. But at that point it could be two steps that might be clearer: NOQUASI REIFY, where NOQUASI would be like NOQUOTE and not complain if the thing you passed it was not a quasiform.

Maybe... CONCRETIZE? That sounds like it might do a bit more work than what REIFY does :-/

>> okay
== \~okay~\  ; antiform

>> concretize okay
== okay

>> concretize 10
== 10

It's not awful. A shorter word would be CONCRETE.

>> okay
== \~okay~\  ; antiform

>> concrete okay
== okay

>> concrete 10
== 10

We do mess a bit with wording, but here it would be more of an adjective.

Another big question is what the antonym of REIFY would be. That is to say something that leaves all input values alone except for quasi forms, and gives you back an antiform.

>> unreify first [~okay~ 1020]
== \~okay~\  ; antiform

>> unreify second [~okay~ 1020]
== 1020

Unfortunately, there's not a good opposite word for REIFY. Maybe DEGRADE?

>> degrade first [~okay~ 1020]
== \~okay~\  ; antiform

>> degrade second [~okay~ 1020]
== 1020

I think I'll go with DEGRADE a while and see how I like it. The names can be juggled around once all the necessary behaviors are assembled.

3

Not being an English native speaker I'll have to trust you on this.

6

I think (noquasi reify ...) and (reify:noquasi ...) are probably about as good as this gets.

One argument against providing both is that it's cleaner. Another is that a function with one argument and no refinements can be an intrinsic. So having just noquasi reify would be faster than chain dispatch, as well as speed up all REIFY operations.

No one will know what that means. If you're in a script where you're saying noquasi reify over and over so often it's creating problems you can define it however you like (nqr: get $noquasi/reify)

Maybe not everything needs a single word.

1 Like