@RobertHarvey don't get me started

my current company is so unbelievably "checklist oriented' for stuff like that

@JimmyHoffa Yeah, that kinda makes sense. You're wiring up a computation, but you don't get the result until you press "play."

Aand... Gone.

@RobertHarvey Yeah, and in that space before "play" - you have an extremely malleable thing in the computation, you can destructure it into parts, compose other parts onto it, it's an extremely general thing a computation. In LISP macros that's what everything is, and in Haskell that's what everything is.

Haskell is a Lisp macro? Oh, wait.

I just mean, everything is a computation from the perspective of a LISP macro, and throughout Haskell everything is a computation

Is there such a thing as a Haskell macro, or is Haskell so first-class that it doesn't need them?

You need uhh..what's that word? Homoidiosomething? Homoiconicity, that's the one

to do macros right

Haskell has TemplateHaskell and QuasiQuote Haskell, which give a type of pre-processing that can do what macros do in a sense

@WorldEngineer "The original programmers of the day used toggle switches, relays, vacuum tubes, and hand-assembled everything without Git". Now that sounds like a teenager. "Before cars people, I don't know, rode bikes or something."

but it's not the same at all without the homoiconicity

I expect Roslyn to fully as good as LISP macros.

@psr I see what you did there.

Or, more accurately, I see what you there.

@RobertHarvey Oh thank god. Let me know ASAP.

the homoiconicity means that the starting representation, the ending representation, and the code that alters them, are of the same form; This means macros can effect macros, and it gives the monadic generality that a macro's result can have a macro applied to it (like how a LINQ result is an IEnumerable which can have a LINQ function applied to it; recursively composing computations because of the uniformity)

Haskell isn't homoiconic

Meta macros. [sound of head exploding]

@RobertHarvey like I said, recursion

It all has this quality of purity about it. A purity that begins to break down when you have to start dealing with the thorniness of real-world issues like CSS incompatibilities, the aesthetics of forms, and cats walking on keyboards.

@RobertHarvey IO must be done, but at least there are ways to put it behind a barrier so you can enjoy that purity in as much of your code as doesn't need to interoperate with other systems. Such as code that creates computations for interoperating. :)

@JimmyHoffa:

These non-underlined links on Google are really pissing me off.

Must have gotten the idea from Stack Exchange.