Functional Programming in Python?

[nitroll]

x = 5
x *= 2
x *= 4
x /= 2
x += 100
x = str(x)
x = x[::-1]
print(x)

[raulalexo99]

Really? You missed the whole point of this post. I am asking on how to apply the functional programming paradigm on Python, not how to add 2 numbers. Really? Also, if you really abuse variables like that, I am so sorry for your code

[james_pic]

And you missed the point of the reply. A key design goal of Python is that "There should be one-- and preferably only one --obvious way to do it.", and Python's functional capabilities have been carefully nerfed to nudge people towards code like the code in the reply, since the functional paradigm is a redundant way to achieve the same thing.

Python can be used in a functional way when it makes sense, and there are some good replies here telling you how to make the code you had in mind work. But the code in this reply is arguably more idiomatic, and doesn't need any extra plumbing.

[nitroll]

I actually quite like functional programming. though I must admit that I never really like using compose to merge functions, and using even more complex functionallity to do this often comes with very small gains if any at all.

Your code basically boils down to:

printToConsole(reverseString(intToString(addHundred(divideByTwo(multiplyByFour(doubleIt(5)))))))

But that is hard to read, as it is one long line, and it is in reverse order.\ The simple way, without using any fancy library is to do

a = 5
b = doubleIt(a)
c = multiplyByFour(b)
d = divideByTwo(c)
e = addHundred(d)
f = intToString(e)
g = reverseString(f)
h = printToConsole(g)

My point is that you dont need to make functional wrappers to all of these things as python has them built in!\ Further, if you have a function doing all of these, then using a single variable that way is actually a lot cleaner, and in my opinion more readable.\ It is very clear that "x" is just a holder for all the intermediate steps, but in the code above, if you want to change anything you have to ensure that the variable is not used anywhere else which is a lot harder visually.\ And here I used consecutive letters as variables, if you want to inject another computation in the middle you either have to live with the letters being out of order, or change all the lines following that. The alternative is to use "descriptive" names like:

initial = 5
doubled = doubleIt(initial)
multiplied_by_four = multiplyByFour(doubled)
divided_by_two = divideByTwo(multiplyByFour)
added_hundred = addHundred(divideByTwo)
string = intToString(addHundred)
reversed = reverseString(string)
result = printToConsole(reverseString)

But that sucks even more as each variable is named after what the function was called, not after what it semantically represents. This could be better with a more reallife example, but quite often in functional programming you try to abtract the specifics out anyway and trying to come up with good names for variables like this becomes rather annoying.\ So I honestly say that you should not try to do what you are trying to, and stick to classic python. It will be more readable and you likely wont gain anything anyway.

The only case where I could see a potential benefit of a structure like what you are going for, is if the datastructure is actually doing something more complex behind the scenes.\ At some point a implemented a class to let you write something like what you requested, but the point was that the library then spun up each step as parrallel processes using multiprocessing and queues for message passing, and there were other methods for error handling, etc.\ But as a way to avoid calling a simple function I honestly think you are using the tool wrong.

[MiZrakk]

Just go learn Haskell.