Functional Programming in Python

Post by ianhorn » Fri, May 29, 2020, 1:12 AM UTC

Izkata wrote: post #39

ianhorn wrote: post #11

This is neat. It reminds me of an silly project [0] I made a while back to implement do-notation in python. In OP's project you still end up with code that's basically this: y = (Maybe(just=x) if x > 0 else Maybe()).bind(lambda a: Maybe(just=x*a) .bind(lambda b: Maybe.mreturn(a+b))) It's functionally sound and standard, but ergonomically painful. I built a really fun horrible hack to allow you to write that instead a…

Your example isn't using "y", so you should also be able to drop the " as y" part (unless the AST hack requires it for some reason). Edit: Oh, nevermind - the "y" is how you access it after the with statement. Weird for python, but it makes sense given the rewritten version. I was thinking your version would have a non-rewritten "result = something " within the with block in a real use, but that's not what it's doing…

Post by rbonvall » Fri, May 29, 2020, 1:39 AM UTC

cheez wrote: post #43

I'm a big fan of functional programming but this documentation is kind of funny, unintentionally. I realize there is no better way to do it in Python. And that’s how your initial refactored code will look like: user: Optional[User] can_buy_stuff: Maybe[bool] = Maybe.from_value(user).map( # type hint is not required lambda real_user: real_user.get_balance(), ).map( lambda balance: balance.credit_amount(), ).map( lambd…

Post by rbonvall » Fri, May 29, 2020, 1:43 AM UTC

ralphc wrote: post #25

typenil wrote: post #18

The `Maybe` container seems to be a close analog of `Option` in Rust https://doc.rust-lang.org/rust-by-example/std/option.html

Another synonym is Some in some languages.

Post by cellularmitosis » Fri, May 29, 2020, 1:54 AM UTC

okasaki wrote: post #45

> But, having null checks here and there makes your code unreadable. if user is not None: balance = user.get_balance() if balance is not None: balance_credit = balance.credit_amount() if balance_credit is not None and balance_credit > 0: can_buy_stuff = True else: can_buy_stuff = False Actually I think that's very readable user: Optional[User] can_buy_stuff: Maybe[bool] = Maybe.from_value(user).map( # type hint is no…

    def can_buy_stuff(user):
        if user is None:
            return False
        balance = user.get_balance()
        if balance is None:
            return False
        balance_credit = balance.credit_amount()
        if balance_credit is None:
            return False
        return balance_credit > 0

   def can_buy_stuff(user):
       return (user?.get_balance()?.credit_amount() ?? 0) > 0

Post by entha_saava » Fri, May 29, 2020, 3:02 AM UTC

frenchyatwork wrote: post #34

saghm wrote: post #8

Earlier quoted context omitted.

I agree with you that having more than a single expression in lambdas would be super nice. That being said, I don't think it's necessarily stateful to allow more than a single expression! If you don't reassign any variables, then it's equivalent to a single expression. For instance, something like this (using made up syntax for extended lambdas) isn't stateful: lambda i: square = i * i if i A decent heuristic for whe…

I'm sure there are cases where multiple lines would be nice, but I don't think this is one. This seems easier to read to me: lambda i: -i * i if i Also, the functional way of doing multiple lines in a lot of situations would typically be to compose smaller lambdas.