Care to enumerate? Asking because I feel the same: I really enjoy immutability, first class functions, map/filter/reduce, Option<T> and powerful types (I dislike: currying, point-free, monads), but at the same time I feel more at home doing that in imperative-ish languages like C#, JS/TS and Rust where I can have guard ifs and the odd mutation here and there. Wondering if anyone else is the same.

Don't worry then, that's fine, you just dislike Haskell.

I personally really like functional programming but can't stand Haskell. The style favoured by the community is optimised to be the most impenetrable possible.

You should try Ocaml. The preferred style favours piping to point-free and uses monads sparingly. Currying is everywhere but copious use of named arguments tends to make things simpler.

My biggest gripe with it is not so much the language itself but the culture: it favours bloated and pompous solutions much in the same way Java/Spring does. Monad Lifting, Lenses, Aspects and FactoryFactories occupy the same space in my head.

I guess I just prefer both the simple side of functional and the simple side of imperative.

I definitely have to give OCaml a try.

My only gripe with them is that there seems to be a culture of having zero type annotations (due to HM), which can make reading other people's code difficult.

I don't think that's quite true.

Ocaml has plenty of advanced features (the module system, GADT, structural typing in the object system) but the community relationship with them is very different than how the Haskell community uses the language. For the most part, the Ocaml community tends to dislike gratuitous complexity and be non dogmatic (I fondly remember a lens library announcement on which the top comment could be boiled down to "just use mutations").

> My only gripe with them is that there seems to be a culture of having zero type annotations (due to HM), which can make reading other people's code difficult.

Interfaces tend to be annotated (mli files) but usually people rely on the tooling to know types inside files. Merlin is a blessing. It is a very fast type-checker which keeps working on incorrect files.

I should put some more time in with OCaml, Merlin sounds nice.

But I also like state, polymorphism and identity.

My familiarity with FP tends to be around "Hey! I like this Swift feature! Where did it come from?"

It's the part where we clump together functions to make a single, rather powerful function that is, in essence, a rabbithole.

Though C programming is usually about effects, effects occur in expressions which usually return a value except in cases when their type is "void" (which was a later introduction into C, possibly from C++).

C even has an if/then conditional that yields a value, the ternary operator x ? y : z, which is a more strongly typed version of (if x y z).

ChrisMarshallNY: I suspect that he understood functional languages quite well. He just didn't like them.

Your statement doesn't follow from Ritchie's words that you quoted. Preference of A over B does not have the logical consequence that B is disliked. It doesn't even imply that A is intensely liked.

Personally, I prefer Haskell or some functional Python at times, since that solves certain problems well. But, we have a lot more computing resources than existed in the past. I guess it could be possible that he enjoyed the functional paradigm, but pragmatically created a procedural language, given the hardware constraints.

It's a functional language.

Always has been.