Was recently looking into "annotations" in Self and Java, as well as the related concepts of "property wrappers" and "function builders" in Swift. Are there other languages with similar features? Also, what are the most interesting uses of annotations you've run across?

decorators in python? https://peps.python.org/pep-0318/

Python decorators. I think Rust calls them annotations as well. Elixir via Erlang, apparently. Nim. I'm less sure about C# but I'd bet 5$ they have something like that too. They're pretty common these days.

Stage 2 proposal on js https://github.com/tc39/proposal-decorators

And now to torpedo this thread — can someone explain to me how these are meaningfully different from lisp macros?

Well, to the extent you can even consider them as a group, considering the very wide variety in semantics, they're pretty sharply limited (by design) relative to proper macros. The others seem to be more complicated, but Python decorators are literally sugar for wrapping the advisor annotated item in a function call. I think Rust annotations are just tags that can be processed by some other build-time code.

@Ivan Reese Python decorators are just syntactic sugar for a particular use case of higher-order function. But since readability is an important criterion for Python programmers, and since Python does not have anything like Lisp macros, syntactic sugar can make a big difference.

I'm more interested in the idea of an abstraction around slots (instance variable name and value) that manages meta data and computation related to it than a particular feature of this general area (such as decorators). Yes, we can implement decorators with macros etc, but that's just one small feature related to this area.

clojure supports metadata for any datastructure https://clojuredocs.org/clojure.core/with-meta

@Steve Dekorte Pharo Smalltalk has something like that, see https://hal.inria.fr/hal-00641716/document. Slots can be defined by classes, making them almost objects themselves. I have used this myself only once, to trace and record slot accesses. It’s surprisingly straightforward to use.

Rubyist checking in. At some point (probably a decade or two ago), the method definition construct was made to return the method name so that you can easily write your own decorators. This means that when you write

synchronize memoize def calculate(something); ...; end

, the interpreter: 1. defines the

calculate

method, 2. sends the symbol

:calculate

to the

memoize

class method, which will presumably define a new version of

calculate

and return

:calculate

, so that the interpreter 3. again sends the symbol

:calculate

to the

synchronize

class method, which will presumably wrap

calculate

again.

Kotlin has so called "delegated properties": https://kotlinlang.org/docs/delegated-properties.html