homoiconic | publishing code and words about code on a small scale

There are two direct ways. If the thing is hygienic and referentially transparent, just use a const value. That won't work in your example.

Otherwise you have to use the macro in call syntax: @foo(). There's no around that, it's how Julia syntax work. Although I won't recommend doing it either.

But a nicer alternative, IMHO, would be an "anaphoric context macro", something like:

You can use $map to get the difference for each comment (using $subtract) and then run $max on the output from mapped comments. Additionally you need another nested $max to get the differences from replies, try:

You have a typo, $Ratings; use $ratings as below. Aggregation syntax is case sensitive.

Do I miss something or stems this behaviour from the fact that haskell is not homoiconic?

No. Homoiconicity is a red herring: every language is homoiconic with its source text and its AST¹, and indeed, Haskell is implemented internally as a series of desugaring passes between various intermediate languages.

The real problem is that let...in and case...of just have fundamentally different semantics, which is intentional. Pattern-matching with case...of is strict, in the sense that it forces the evaluation of the scrutinee in order to choose which RHS to evaluate, but pattern bindings in a let...in form are lazy. In that sense, let p = e1 in e2 is actually most similar to case e1 of ~p -> e2 (note the lazy pattern match using ~!), which produces a similar, albeit distinct, error message:

I think you're conflating Common Lisp and CLOS. CLOS (usually implemented using the MOP but not required) is a facility provided by Common Lisp, but there's no requirement that Common Lisp itself be written in such a way that it actually use CLOS where possible. As Rainer mentioned, the Smalltalk VM isn't purely written in Smalltalk and Common Lisp is (often) already largely written in Common Lisp (there is some low-level support code in assembly/C/whatever and some native libraries utilized to provide the Lisp runtime environment just as there is for the Smalltalk VM. I would suspect that there is more of it for the Smalltalk VM due to the higher-level abstraction that the VM provides and more support/glue code needed to maintain the facade.)

What I think you're actually getting at is if it would be useful if more of Lisp itself were written in CLOS (which at that point would probably not be Common Lisp anymore) since Common Lisp as it is usually implemented does not generally use CLOS (at all?), but rather makes CLOS available as an optional OO framework for your applications. As it is (commonly) implemented, Smalltalk is focused on messages being sent to methods (i.e. making decisions at runtime) and Common Lisp is more focused on macros calling (non-generic) functions (i.e. making many, but not all, decisions at compile-time.) These are fundamental design and implementation decisions but there's no reason you couldn't create a Lisp that had a more Smalltalky 'feel' by utilizing CLOS and deferring more decisions to runtime.

As you've already noted, Lisp already has a very dynamic environment with a similar interactive 'feel' to Smalltalk, so what would this get you? Generally, you'd get the more extreme dynamism that the Smalltalk runtime offers and from a code organization standpoint you would replace a lot of what alist, plist, defparameter, defvar, and to an extent what namespaces are used for with object slots. You would probably also end up with a smaller set of more general functionality (Common Lisp offers a kitchen sink approach to functionality: macros and functions for nearly every use case you can imagine) to support the more extreme capabilities that OO can offer (i.e. transparent proxy objects become trivial to implement, overriding subsystems like the debugger becomes easy etc.) While there are still differences in OO implementations between Smalltalk and Lisp (single vs. multiple-dispatch, single vs. multiple-inheritance, methods vs. generic functions, message sends vs. function calls etc.), I think this could probably get you 95%+ of what Smalltalk offers. What does it cost you? Compile-time clarity and runtime performance... a price Smalltalk pays currently. Probably of greater concern to most Lispers would be that code would look and feel different from what they're used to not unlike how Clojure is different from Common Lisp. So what you'd end up with is a new Lisp with a Smalltalky feel rather than another Common Lisp implementation.