it's probably low effort for a mere every day haskell programmer; it's just a question of what you're familiar with, not actually deep math

(minor correction, :: is evidently list construction, as in ocaml or haskell, not a type annotation)

you asked what `matchAll primes as list integer with` meant ('what is the second line, a comment?') but apparently the person who answered you didn't understand that you didn't understand. it means 'evaluate the expression `primes`, which should have the type `list integer`, and then attempt to match the value resulting from that evaluation against each of the following expressions in order'

deep math isn't simple to do even when you know what it means; it isn't just a matter of learning what all the symbols mean. this is just a matter of learning what all the symbols mean, like reading chinese instead of english

with a good notation, cramming lots of symbols onto a line is a really good lever to empower your reasoning ability. consider trying to explain how to play the seventeenth measure of pachelbel's canon in words. or writing assembly instead of c, even though they're both at pretty much the same level of abstraction

i'm guessing that #() (the only weird part) is analogous to ${} in `-strings in javascript or "-strings in ruby: it embeds an expression to be evaluated in a context where you wouldn't normally expect expression evaluation, in this case a pattern for pattern-matching

(disclaimer, i don't actually know haskell, though i've implemented my own programming language featuring pattern-matching)

Thanks. As a correction, the comment you are directly replying to is the only one that I personally made.

I just happened to agree with the sympathies of the first person and was trying to rephrase things in a more productive and positive manner.

I appreciate the response not only for myself but for others who may be reading it as well. Thank you for taking the time.

i appreciate both the correction and the appreciation

>or writing assembly instead of c, even though they're both at pretty much the same level of abstraction

They aren't.

it must be simple because this code is, i presume, runnable.

That's now how simple works. Malborge's "Hello World" is a single line!

(=<`#9]~6ZY327Uv4-QsqpMn&+Ij"'E%e{Ab~w=_:]Kw%o44Uqp0/Q?xNvL:`H%c#DD2^WV>gY;dts76qKJImZkj

Look at how compact that is! Must be simple!

You can't claim simplicity by using character or line count.

there are an awful lot of separate entities in that line

Nah, this mess isn't intuitive to anyone. There also isn't anything like an agreed upon mathematical or logical notation. Everything in this field beyond the basics of algebra / set theory is awful one-off NIH languages with awful / inconsistent grammar that nobody beside the "inventor" can understand, while the inventor has perhaps a 50/50 chance of understanding their own writing.

The lack of requirement of mechanically verifiable proofs and adherence to common standards of expression of mathematical concepts is a huge drawback of what happens in this area of academia.

People who come up with languages like Haskell (which this one certainly is) are people who want the absurdity of languages created w/o system or any general design to spill over into the programming land. Solely based on the fact that they've been exposed to this cuneiform during their apprenticeship and learned to associate it with the actually valuable stuff it's meant to convey.