REIFY vs. META vs. SOMETHING

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

But that's not a full coverage answer.

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

    >> true
    == ~true~  ; isotope
    
    >> meta true
    == ~true~
    
    >> meta 10
    == '10
    
  • An operator that leaves non-isotopes as they are, but turns isotopes into their quasiforms (and I think this probably is best called REIFY):

    >> true
    == ~true~  ; isotope
    
    >> reify true
    == ~true~
    
    >> reify 10
    == 10
    
  • An operator that leaves non-isotopes as they are, but turns isotopes into their plain forms:

    >> true
    == ~true~  ; isotope
    
    >> something true
    == true
    
    >> something 10
    == 10
    

Specifically for ACTION! isotopes being turned into plain actions, I used an interim term UNRUN, but that's pretty awful.

Making things into isotopes is done with ISOTOPIC:

>> isotopic 10
== ~10~  ; isotope

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 :-/

>> true
== ~true~  ; isotope

>> concretize true
== true

>> concretize 10
== 10

It's not awful. Main thing is just to have a name for it while the gears turn. But as usual, throw out suggestions if you have them...

A shorter word would be CONCRETE.

>> true
== ~true~  ; isotope

>> concrete true
== true

>> 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 isotope.

>> unreify first [~alpha~ 1020]
== ~alpha~  ; isotope

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

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

>> degrade first [~alpha~ 1020]
== ~alpha~  ; isotope

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

The pairing of CONCRETE/ABSTRACT might be a possibility here. I'm not sure.

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.

1 Like

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

Same here, that is when I go for one of my help lines in these kinds of cases: The wordhippo

There is a tab for antonyms as well. That would lead me to suggestions NEGLECT, OBSCURE or IGNORE.
But with some creativity I came up with the word DEIFY.

After pushing various problems around: I think it has turned out that this operation is more useful in practice ...and likely deserves the coveted term "REIFY".

In particular, I think it may be the answer to passing isotopic actions as parameters in a way that conflates with plain actions, yet canonizes it to plain. e.g. the <reify> tag could indicate a desire to turn isotopic actions into non-isotopic ones if passed. But it would be generic. If you use it you mean you want anything passed to arrive in its reified form.

 func [arg [block!] /predicate [<reify> action!]] [...]

That feels like a pretty intelligent solution to the problem, while being generic enough to be useful for other purposes.

The other operation (which I called REIFY above) would be what needed a name. Maybe it's a parameter to META, something like a META/ISOTOPE or similar. I'll keep thinking, but I don't think it's going to be needed very often...whereas the sense of REIFY I'm talking about here is actually showing up a lot of places.