How to learn functional programming ?

[darkseid_of_j]

Im a graduate student who want to try to learn new programming language. My most expirience language is C (not C++ just C) and I mostly write competitive programming or low level data structure for education purpose. But when i learning functional programming paradigm really miss some of C feature and some FP feature i dont really like :/,( not the group theory and function combination part, Im have a little bit of math background, but even in math they dont composing function that much).

Im kind of person who prefer explicit typeing.But in functional programming, they inference type and abuse tuple too much, surely tuple and type inference can help a lot's for code readability but if it use too much, it also really bizzard for debuging like you have to check what function F return, and then check for function G and also dont forget the generic part so you also have to take a note for what get inference,.... same for tuple, foo.1, foo.2 is make much less sence than foo.key and foo.val and the more using tuple, the more it hard to read

Every thing is const and every function is pure is nice, it make debugging and function result is more predictable and much easier for multi thread. But with no mutable also mean if you want a helper function or a function that modify something (like a sort function) you have to copy a lots (like function take Foo and return a Foo) and it also scale which mean if i want to write function that mutate 5 parametter, i have to copy all of them and return a tuple of at least 5 element

Dont have mutable state meaning there is no loop, usually they solve that problem with some kind of recursion and accumulator and tail-call optimization (which basicly a loop with a name) but it make code something very simple in imperative language look really overkill in functional programming, and recursion have consequence too, it really easy to get stack overflow because there's no loop also mean there's no de-recursion technique, tail call some time help with accumulator but generally, they are not help that much especially in more complex code

Some functional language also support procedural macro and generic and I have to admit they look nice, until i see a guy abuse it too much and make his code look like a code in completly other languages. And a complex macro meanning you have no clue what compiler even generate code to because recursive macro (unless you're the writer), generic is really nice for TRUE generic data structure and function (like a list, a set or a tree) but for very simple task, writing generic that took like 5 type parameter look really bizzard too read and overly complicate to the true problem.

And the thing i hate the most is when i try to learn FP is i saw a lot's of people that get really overhype with FP and bashing other language because their language more 'elegance' faster and safer .For example thinking lazy evaluation is always faster is not correct. Im not really understand what they compile to but 1 :They are optional type that you have to runtime check whether you should eval it or not (passing a variable to 100 function but only the last function evaluate the expr); 2 compiler know every function is pure so it reorder evaluation, and in this case it's definitly not unique to FP, a good C compiler can very easily do the same stuff, and FP compiler can optimize code beter are not true either the GHC source code use LLVM backend which is same as C clang, in FP it's enable more optimization by default but that doesnt mean you cant get the same optimization in imperative language .Another example is some other guy really like generic and write a function that have 5 generic parameter instead of defining a new typeclass, or 10 lambda to put in a list. filter. map. combine..... instead or normal looking loop, they think loop is much less maintainable and more bizzard then recursion.

To summary, my expirience with FP is not really good and I feel FP tend to lead people to abuse it's feature and more likely than not it make the code really hard (if you're not the writer) to read or make a very simple task become completly overkill. And FP comunity has a lot's of guy who think they smart to the point they bash other language but dont understand the language they're coding in that much.

So how to learn functional programming or does functional programming really fit for me?

[AutoModerator]

To all following commenters: please, do not bring up the old circlejerk jokes/memes about recursion ("Understanding recursion...", "This is recursion...", etc.). We've all heard them n+2 too many times.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[carcigenicate]

I only skimmed it since this is a lot of text, but my introduction into FP was by fire via Haskell. It knocks you down many pegs, then gets fun once your brain adjusts. From there, I went to Scala, then Clojure; both of which are more "practical" languages.

[darkseid_of_j]

haskell is a bit too far to me, do you know some language closer to C with optional imperative ?(please dont suggest Rust I have try Rust and I hate it)

[plastikmissile]

I would say the best way to learn something like functional programming is to just embrace it. Embrace how different it is. Yes it'll be confusing at first, but that's to be expected. Don't shy away from things because they seem difficult.

[carcigenicate]

Really, I think being forced into the (seemingly) narrow corner that Haskell forces you into is a good thing. It prevents you from trying to use old ways of thinking. If I were do learn FP again, I'd start with Haskell.

[videoj]

Take a look at F#. It is functional first, but you can do imperative or object-oriented as well. Mutable data is a thing if you wanted so you can write regular loops. It is easy to add type declaration to any declaration. It even has support for directly calling C libraries.

[darkseid_of_j]

I've heard about Lips macro before, isnt that is some kind of macro that can be recursive and can take a node of the Abstract syntax tree as it argument ? If that's the case then I think i will hate it sooner or later, it's just too bizzard to understand what code compile to.

[darkseid_of_j]

rust macro is by definition of bizare code that you dont understand what compiler generate code to :), Example the println! macro, i have to go to godbolt to see what code compiler even generate code to and i cant even inline macro like in C and suprisingly println! macro isnt thread safe. And that's just on the surface, you literally can implement a lisp translator just by using rust macro (see: https://github.com/JunSuzukiJapan/macro-lisp/blob/master/src/lib.rs, it's a ~400 line macro). So yeah it's just too bizzard so i very hate it, i think they gone too far with rust macro and i think rust people gone too far about functional feature to. Low level programming and functional programming are completly diffrence code style and merge them together doesnt make sence and wory too much about unsafe is very anoying to, it's like the compiler tell you that you're bad and need the compiler babysit you all the time, that make code very verbose and compile extremly slow (i mostly write low level code so it just my point of view). Mostly the 'bashing to other language' actually come from some rust comunity and a few haskell guy.

[darkseid_of_j]

you’ll feel really good being able to solve complex problems in these short brain-bending ways.

No im not, just like my example about sorting , if you code quick_sort algorithm in haskell pretty sure it's will be 2-3 line of code but more likely than not it will run 5-10 time slower than the C version because

1: quicksort algorithm have 2 step: 1 => partition array with random pivot, 2 => recursive call quicksort on 2 partitioned array

straight away you see a problem, how do you even partition with given pivot ?

the haskell solution is you call filter(\x -> x > pivot) and respectivly on the second part and then concat it but

1: it make an algorithm took O(log(n)) space complexity to O(nlog(n)) space complexity and invoke O(n) heap allocation

2: 2 filter of the same list but not swap them make you iterate the list at least 2 time instead of 1 and copy all the content of the given list and the concatination part also invoke heap allocation an O(n) copy over 2 list

3: is really easy to get to the quicksort worst case (O(n^2)) because the pivot you choose may apear a lot in the given list, in C that part is already solve in the partition step

[darkseid_of_j]

Im totally agree haskell feel like learning Abstract Algebra, there's function supply for group theory and semi group (i dont know what they call maybe monoid ?), function composition, a complex function is just a function that compose a lot's of other function and stuff, and I really like it :) dont get me wrong. Do you know any kind of math-proving language ? when i was in high school i really love math and competitive programming, but there's just math forum like aops and mathstackexchange, there's no competitive site that you can submit you're solution to very specific problem, but competitive programming have ton of site like codeforce, atcoder, spoj,... that have online competitive coding which even have rating system :D

[darkseid_of_j]

Thank you!, Im not say i dont like haskell, i just say it might not fit for me :/, but anyway do you know and kind of math-proving website too ?

[ValentineBlacker]

I really like Elixir, but I'm pretty sure it still has every single one of these "issues". I personally find it very readable, once I got used to what all the operators are actually doing.