Learning Functional Programming

In functional programming, everything is an expression (of frustration).
- Y=λf.(λ🤬.f(🤬🤬))(λ🤬.f(🤬🤬))
  
  lisp
  
  Y😄 = (λf.(λ🤬.f(🤬🤬))(λ🤬.f(🤬🤬)))😄 = (λ🤬.😄(🤬🤬))(λ🤬.😄(🤬🤬)) = 😄((λ🤬.😄(🤬🤬))(λ🤬.😄(🤬🤬))) = 😄(Y😄)
- Having worked for nearly two decades in a functional language now, that's precisely how I feel about the imperative style.
  
  In imperative style, everything is an instruction (to suffer)

If you are bored of writing Brainfuck in your spare time, try Lambda Calculus instead as an exciting alternative!
- Relevant reading: https://justine.lol/lambda/
- Id rather cut of my limbs with a handsaw than touch lambda calculus again

I’ve been there. It’s great!

It would be extremely annoying to be forced to write all my code functionally.
But I find it even more annoying to be forced to write all my code object oriented. Looking at you, python and java.
- C++. Do whatever the hell you want, it doesn't care. Mix paradigms all day long.
  People complain about its complexity and the fact that it has everything including the kitchen sink, but that is exactly why I love it. It gives you choice.
  
  C++: You can do everything, but with garbage syntax and ten traps to look out for™
  
  If choice is our metric here, why not C? That way, you have the choice to use your own implementation of OOP
- Unless you're writing Scala or something (which is probably the one exception to the rule), if you are using a language that supports OOP, you're not really doing functional programming. Functional-esque features that have made their way into imperative languages like map are only a tiny fraction of the functional toolbox.
  There's a bunch of features you want in a language to do functional programming, and imperative languages don't really have them, like purity by default (and consequently, an orientation towards values rather than references) ergonomic function composition, algebraic data types, pattern matching, support for treating everything as first class expressions/values, etc.
  Perhaps this is presumptious (and I apologize in advance if so), but I'd wager you haven't truly programmed in the functional paradigm. What imperative programmers tend to think of functional programming is very surface-level and not really reflective of what it actually is. It's an entirely different beast from imperative programming. It requires a shift of your mindset and how you think about programs as a whole.
  Source: Senior software engineer writing Haskell full time for the last 4 years. Will avoid OOP until my dying breath.
- Bro just finds it annoying to write code
  
  Nah, coding is one of the few things I don't find annoying, so long as the language or toolsets I'm using allow for freedom. What I find annoying is when some talking head says all code should be a certain way, and everybody believes them for some reason.
- Not sure why you're saying Python forces everything to be object oriented...?
  
  It basically does. It pretends to court functional programming while actually being really antithetical to it in basically every way. Guido Van Rossum has vocally expressed his dislike for functional programming (though I'd argue he actually doesn't really know much about it).

But how many burritos is that.
- But how many burritos is that.
  Lets find out! Count = λB. (B (λx. (x + 1)) 0)
  3 its 3 burriotos you're going to have to pop out and get 8 more for the other commenters