non-pure

A pure functional language can use denotational semantics to embed non-pure languages/programs/concepts, because the denotational semantics of non-pure concepts are still pure.

Scala also has non-pure constructs built in, but most people tend to opt in to its purity.

Too few functions are actually pure and the difference in a pure signature and a non-pure one doesn't exist.

Non-strictness removed the temptation to extend the language in non-pure ways, either intensionally or accidentally, for the sake of convenience.

It seems like Javascript was supposed to be an Algol-syntax over a non-pure Scheme inspired core...

Edit: Also, programmers in non-pure functional languages will often still minimize their use of mutation (changing variables) for a number of reasons.

State is the most common example of a non-pure concept that many programmers miss in Haskell, but it's not the only one.

In a non-pure environment, automatically updating values can be quite nice.

Also, saying that a Pure FP language (Idris) is easier than a non-pure language (Scala), for someone without extensive FP backround, is an interesting comment.

A pure democracy cannot be trusted (as a pure democracy trivially allows/enables the oppression of minorities), but non-pure democracies must be conceived and implemented somehow.

In the same way, you can make a mistake when doing all manner of other things such as using a non-pure function or adding instead of subtracting.

It is fundamentally stateful and non-pure.

The thing is, when you're talking about important enough acts, like dissidence from authoritarian regimes, there's no such thing as "non-pure anonymity".

Think of detecting outliers on a square wave, or a pinched sine wave, or any "non-pure" tone, really...

Software is eating the world, and almost every "non-pure software" activity is hurting for good programmer help.

Some people can grok recursion in a functional programming language much faster and more easily than they would understand the concept of branching, variable assignment (with mutability) and non-pure functions (what we used to call "procedures" back in the day).