Pros and cons of the functional paradigm and Haskell

Question

I saw that, clearly, the Functional Programming Stop is not at all famous in the world of programming in general. However, talking to a few fans of languages like Lisp, Ocaml, F#, Haskell, etc. I saw arguments that almost convinced me to learn the purely functional language that seems to be the most influential and popular of the moment: Haskell.

So the question is fundamentally this: What are the pros and cons of functional programming? What are the pros and cons of Haskell? Why should I learn Haskell?

Just to leave a clue, one of the arguments I heard the most from fans of the functional paradigm was: "Parallelism and threading in functional programming is almost trivial from so simple, while in other languages this is difficult, arduous and due to poor implementation only brings problems".

Answer 1

To tell the truth, I think the term "functional programming" is not very precise, and I would prefer to separate Lisps from ML-style typed languages (Haskell, Ocaml, F#, etc). That said, to answer the question "why learn Haskell", I think it best to divide it into two parts.

1. Functional programming in general

   One thing all functional languages have in common is how functions are first-category values: You can define functions within other functions (accessing function variables from the outside), define functions that receive other functions as parameter or that return functions... This is quite flexible and lets you write many things succinctly.

   Today, this point of functional programming is no longer such an important distinction, as many "imperative" languages have first-class functions and even languages notable for the lack of anonymous functions, such as Java and C++ are finally including them. And since we’re talking about imperative programming, to tell you the truth, functional programming doesn’t have to be that different - you can write programs with a pretty imperative face if you use tail recursion (something equivalent to computed files).

2. ML family languages (Haskell, Ocaml, etc)

   The most unique factor of Haskell and its raw languages (Ocaml, F#, etc.) is certainly the type system, extremely powerful and flexible, but still relatively easy to use. I would say that it is worth learning such a language just for that. Some of the most important points:

   • The type system is completely static. Many errors that are detected at runtime in other languages are detected at compile time in Haskell.

   • Variables will always be initialized (it is not possible to access an uninitialized variable).

   • Parametric polymorphism / Generics. Allows you to express precise types without having to upcasting and downcasting with an Object supertype.

   • Fined unions and "Pattern matching". It is possible to describe types with more than one case (for example, "integer or null value") and it is easy to write programs that deal with all these cases (Pattern matching is a mix of switch with unstructuring). This all avoids exceptions like Nullpointerexceptions, since the type of a nullable variable is not the same as a nonnullable variable.

   • Type inference is powerful and if you want you can write any program without using any type annotations, which avoids hassles like MyClass myClass = new MyClass. That said, it’s still a good idea to put some kind notes here and there to make the error messages more understandable.

3. Haskell, specifically for

   • Haskell is one of the functional languages with the most active community. It will be easier to find documentation, libraries and introductory books to Haskell. In particular, Haskell has some really cool libraries, which are not common in other languages:

     • Quickcheck. Generates random inputs to your test cases automatically, based on function types.

     • Hoogle. Search Haskell’s standard library based on the types. An extremely fast and effective way to search for functions, if you know what you want them to receive and return but don’t know their name.

     • Parser Combinators. A flexible way to write your own parsers but that would be difficult and ugly to implement in conventional languages.

     • Haskell uses lazy evaluation, which makes it easy to define their own combinators and flow control structures. For a somewhat forced example, we can define

       meuIfThenElse cond ifTrue ifFalse = if cond then ifTrue Else ifFalse

     In Haskell, this function behaves exactly like an if. In a language with strict evaluation, this function would not work as well, since the two parameters ifTrue and ifFalse would always be evaluated, rather than a single being. You would need to explicitly wrap them in extra functions:

       function meuIfThenElse(cond, onTrue, onFalse){
           if(cond){ onTrue() } else { onFalse() }
       }
     

   • Due to lazy evaluation, Haskell ends up having to separate functional code without side effects from the code with side effects (which need to be executed in a precise order). A lot of people find this confusing at first (having to use monads to print and read values) but after you learn how it works it is very useful to have the type system marking which parts of the program can have side effects and which are pure. If a function is pure you can call it without having to worry about when it runs or whether it will change some instance variable of an object of yours.

Answer 2

Good answers have already been given, but there are still some questions left to be answered by the PO, which I will try to address here

What are the pros and cons of functional programming [in relation to parallelism and threading]?

The issue here is not so much the functional vs. imperative, but rather mutability vs. immutability.

Imperative languages tend to make great use of structures and objects mutable, with state change. A property of an object, encapsulated by a pair of methods get and set is an example of this.

This style of programming is usually simple, in an environment single-threaded, but gains orders of magnitude of complexity when considering multi-processed environments. For, if more than one process can read and change a variable, it is necessary to control the accesses simultaneous read and write to memory (through the use of semaphores, for example). And this control, because it is very complex, is also very susceptible to problems such as deadlocks, low performance and other implementation errors.

Functional languages tend to use only structures and objects immutable. This means that created objects are never changed again (if an information needs to be changed, it implies creating a new object, and do not change the old).

This style is much more expensive, from the point of view of memory consumption, but it has a great advantage: all the difficulties associated with memory reading and writing control cease to exist (but, of course, some new difficulties also arise).

Hence, in part, the predilection of functional languages for lists, because they are structures that can be easily manipulated, without giving up the immutability (it is possible to "add" an item to a list simply by creating a new "head" that points to the old list - that is, a new list object is created, but without having to copy the items from the old list to the new one, saving processing).

'Cause I should learn Haskell?

That’s a trick question, because I don’t think so that you should learn Haskell (at least not now)!

You (OP) don’t seem to have much knowledge about functional languages. And Haskell is for sure one of the most complex and difficult programming languages to learn. In addition to immutability, you would have to learn concepts such as lazyness, purity, type-classes, monads, monoids, transactional memory... And believe me, this is all the stranger than the fact that it’s functional. : P (In my opinion, it’s more or less like wanting to learn quantum physics, without having learned classical Newtonian physics: it’s possible, it’s just not sensible).

There are much more accessible options:

• Scheme is a multi-paradigm Lisp language, suitable for students, that makes strong use of functional concepts, and is relatively easy to learn (if you ignore the parentheses).
• Clojure is more of a Lisp dialect. Some claim that it is even more modern and more functional than Scheme, with the advantage of running on the JVM. Personally, I haven’t had the opportunity to learn Clojure in more depth, but it seems to be one of the most interesting languages to use today.
• Scala is a language that I have professional experience with, and therefore can speak better. At first glance it looks a lot like Java and Ruby, but from "inside" you can see that it was very inspired by Haskell. It is not fully functional, and is far from pure, but is usually a good option for those who have experience in OOP languages like Java or C#. Libraries like the Lift (a web framework) also allows you to see, in practice, the advantages (and disadvantages) of functional style in areas typically dominated by traditional object orientation.
• F# is, like Scala, another example of functional hybrid x objects. But F# "picks up heavier" on the functional side, for being a superset of Ocaml. It can also help to get the "prerequisites" needed to learn Haskell (for example, the computation Expressions of F# are monads, which in turn are very important to understand Haskell).

Apart from these, it is possible to use the main functional concept, first-class functions, in Ruby, Python and even C# (3.0+) and Java (8.0+).

Answer 3

I will not guarantee that I will answer your question with the excellence you expect.

First of all, you can never learn something new. To tell you the truth, it’s healthy to get out of the comfort zone. Getting out of it will always make us come back better than when we left.

One thing is to apply this kind of paradigm to the market that is totally dominated by OOP, Web and Mobile. This can be a barrier, since most IT companies work with rice beans (CRUD, small screen that pulls data from here, print report from there...).

A very positive point of functional programming is the possibility of working with lists and performing absurd calculations by writing very little code. We do a lot of writing very little, I think that’s one of the strongest points of this type of language.

Finally, we are in the age of integration. There are no barriers that will prevent you from integrating Haskell with another market language. Today for everything there is a way. :)

I hope I’ve helped.

Answer 4

Recommend this tutorial of Haskell in English, that the author called "Learning Haskell will be a great good for you". It teaches Haskell in a well-didactic and fluent, light, friendly way. Worth checking out.

Editing:

I just discovered that this tutorial is the Portuguese version of Learn you a Haskell for Great Good, which has already been mentioned here in this comment.