Class structure and predicates for "atoms", numbers, etc.

[gwerbin]

There seems to be no straightforward way to tell if a Hy form is an "atom". I ran into this issue when writing a macro in which I wanted to change the behavior depending on the kind of form that the user provided as input.

It looks like hy.models.Symbol, hy.models.String, etc. don't have a common base class that indicates their "atomicity", only hy.models.Object which is too general.

Similarly, there doesn't seem to be any way to tell if something is a "number". You'd have to write (isinstance form (hy.models.Integer hy.models.Float, hy.models.Complex)), which of course one could wrap up into a predicate (maybe model-number?), but it seems flaky to write such utilities in user code, particularly with how much of a moving target the Hy language is.

Would it be possible to add sufficient class structure, or to add a collection of predicate functions, to distinguish among numbers, string-like forms (String, FString), collection-like forms (List, etc.), and atoms vs. composite forms?

[gwerbin]

As a specific example, I wanted to write these macros:

(defmacro set-item [var-name item-keys rhs]
  "Convenience syntax for `(setv (get v ...))`."
  `(setv (get ~var-name ~item-keys) ~rhs))  
    
(defmacro set-attr [var-name attr-names rhs]
  "Convenience syntax for `(setv (. v ...))`."
  `(setv (. ~var-name ~attr-names) ~rhs))

(defmacro replace-item [var-name item-keys rhs]
  "Anaphoric version of set-attr, with the item bound to `it`."
  `(let [it (get ~var-name ~@item-keys)]
     (setv (get ~var-name ~@item-keys) ~rhs)))

(defmacro replace-attr [var-name item-keys rhs]
  "Anaphoric version of set-attr, with the item bound to `it`."
  `(let [it (. ~var-name ~@item-keys)]
     (setv (. ~var-name ~@item-keys) ~rhs)))

Working examples:

(set-item foo "x" (bar))
(set-item foo ["x" "y"] (bar))
(set-item foo #("x" "y") (bar))
(set-attr foo x (bar))
(set-attr foo ["x"] (bar))

(replace-item foo ["x"] (it.astype "float"))
(replace-item foo ["x" "a" "b"] (it.astype "float"))
(replace-attr foo [x] (it.astype "float"))
(replace-attr foo [x a b] (it.astype "float"))

However, I also wanted to be able to support this syntax, allowing a standalone atom instead of a list literal:

(replace-item foo "x" (it.astype "float"))
(replace-attr foo x (it.astype "float"))

But this would require me to figure out inside the macro that x or "x" is an atom, hence the desire to have a predicate like model-atom? or (isinstance var-name hy.models.Atom).

[Kodiologist]

In this example, it looks like all you need to support is square brackets (why use a literal #(x y) as the input when you could use [x y]?), so (isinstance x hy.models.List) should suffice.

[gwerbin]

If I wanted to support Lisp-like syntax with parens (x y) as well as square braces [x y], would I do (isinstance x #(hy.models.Expression hy.models.List))?

[Kodiologist]

Right.

[Kodiologist]

It sounds like the notion of "atom" you're aiming for is simply "non-sequential models", so try (and (isinstance x hy.models.Objects) (not (isinstance x hy.models.Sequence))). Similarly, numeric models can be identified with Python's existing numeric-tower classes in numbers with something like (and (isinstance x hy.models.Object) (isinstance x numbers.Number)). Don't forget to promote x first with hy.as-model if desired (in which case, of course, you need not then check against hy.models.Object).

Does that fit the bill?

[Kodiologist]

You seem to be under the impression that Hy has a preexisting notion of an atom. That's not the case, so it's up to you to define it.

Like I said before, if you're calling hy.as-model, you need not then check against Object.

It looks like the manual wrongly suggests that FString isn't a subclass of Sequence. I'll correct this.

[gwerbin]

To be clear, I am not under that impression. I was using the term "atom" in the sense that it is used in e.g. Common Lisp. I could call this macro is-nonsequential, but then you run into the fact that it no longer respects the Sequential class hierarchy. So even after you explained that I am looking for "non-sequential" models, I still wanted to use a term that wouldn't cause such confusion.

As for FString, I included it in here because I think most programmers (especially those without a lot of Hy experience) would expect it to be considered "atomic" or "non-sequential" in a macro like this. I am curious though: Is FString being a subclass of Sequence considered an implementation detail, or a deliberate part of the interface? (Understanding of course that Hy is still in very active design development.)

[Kodiologist]

I'd say it's on purpose because the existence of Sequence is public. That said, I haven't done a lot of metaprogramming with f-strings, so perhaps there's an argument that it would be more convenient for them to not be sequential.

[Kodiologist]

@scauligi put work into making f-strings more readily manipulated as models (#1950), so perhaps he has something useful to add here.

[scauligi]

It's intentional for our purposes, since recursive macros (such as hyrule.walk and associated macros) need to be able to descend into expressions within f-strings. Maybe we need to eventually change Sequence to a better name, but right now the intent it captures is "this model can recursively contain other models".

By the by, if you're looking to test against literals (and are willing to use the funcparserlib framework), we do have hy.model_patterns.LITERAL that we use for our own macro definitions.