Maybe "kind-of" monad in Python

Question

Trying to find a way to clean up some of my code.

So, I have something like this in my Python code:

company = None
country = None

person = Person.find(id=12345)
if person is not None: # found        
    company = Company.find(person.companyId)

    if company is not None:
         country = Country.find(company.countryId)

return (person, company, country)

Having read a tutorial on Haskell's monads (in particular Maybe), I was wondering if it's possible to write it in another way.

Answer 1

company = country = None
try:
    person  =  Person.find(id=12345)
    company = Company.find(person.companyId)
    country = Country.find(company.countryId)
except AttributeError:
    pass # `person` or `company` might be None

EAFP

Answer 2

Exploit the short-circuit behavior and that a custom object is true by default and None is false:

person  = Person.find(id=12345)
company = person and person.company
country = company and company.country

Answer 3

Python does not have a particularly nice syntax for monads. That being said, if you want to limit yourself to using something like the Maybe monad (Meaning that you'll only be able to use Maybe; you won't be able to make generic functions that deal with any monad), you can use the following approach:

class Maybe():
    def andThen(self, action): # equivalent to Haskell's >>=
        if self.__class__ == _Maybe__Nothing:
            return Nothing
        elif self.__class__ == Just:
            return action(self.value)

    def followedBy(self, action): # equivalent to Haskell's >>
        return self.andThen(lambda _: action)

class _Maybe__Nothing(Maybe):
    def __repr__(self):
        return "Nothing"

Nothing = _Maybe__Nothing()

class Just(Maybe):
    def __init__(self, v):
        self.value = v
    def __repr__(self):
        return "Just(%r)" % self.value

Then, make all of the methods that currently return None return either Just(value) or Nothing instead. This allows you to write this code:

Person.find(id=12345)
    .andThen(lambda person: Company.find(person.companyId))
    .andThen(lambda company: Country.find(company.countryId))

You can of course adapt the lambdas to store the intermediate results in variables; it's up to you how to do that properly.

Answer 4

Have you checked PyMonad ?

https://pypi.python.org/pypi/PyMonad/

It not only includes a Maybe monad, but also a list monad, a Functor and Applicative functor classes. Monoids and more.

In your case it would be something like:

country = Person.find(id=12345)          >> (lambda person: 
          Company.find(person.companyId) >> (lambda company: 
          Country.find(company.countryId))

Easier to understand and cleaner than EAFP.

Answer 5

I think this is a perfect situation for getattr(object, name[, default]):

person  = Person.find(id=12345)
company = getattr(person, 'company', None)
country = getattr(company, 'country', None)

Answer 6

person = Person.find(id=12345)
company = None if person is None else Company.find(person.companyId)
country = None if company is None else Country.find(company.countryId)

return (person, company, country)

Answer 7

More "Pythonic" than trying to implement a different paradigm (not that it is not interesting and cool) would be to add intelligence to your objects so that they can find their attributes (and whether they exist at all), by themselves.

Bellow is an example of a base class that uses your "find" method and the correlation of the Id attribute names and class names to work with your example - I put in minimal Person and Company classes for a search for the company to work:

class Base(object):
    def __getattr__(self, attr):
        if hasattr(self, attr + "Id"):
            return globals()[attr.title()].find(getattr(self, attr + "Id"))
        return None
    @classmethod
    def find(cls, id):
        return "id %d " % id

class Person(Base):
    companyId=5

class Company(Base):
    pass

And on the console, after pasting the code above:

>>> p = Person()
>>> p.company
'id 5 '

With this Base your code above could just be:

person = Person.find(id=12345)
company = person.company
country = company and company.country

Answer 8

haskell's Maybe analog in python is typing.Optional, but sadly, it is not the same thing.
For more info, see
https://docs.python.org/3/library/typing.html#typing.Optional
How should I use the Optional type hint?

Building chain with typing.Optional can be like this:

    from typing import Callable, Optional

    # some imported func, can't change definition
    def Div3(x: int) -> Optional[int]:
        print(f"-- {x} --", end= "      ->     ")
        return None if x%3!=0 else x//3

    # `bind` function
    # No Type Vars in python, so can't specify  Callable[ T, Optional[S]] -> Callable[ Optional[T], Optional[S]]
    def Optionalize( function:  Callable[ any, Optional[any]] ) -> Callable[ Optional[any], Optional[any]]:
        def _binded( x ):
            return None if x is None else function(x)
        return _binded

    @Optionalize
    def Div2(x: int) -> Optional[int]:
        print(f"-- {x} --", end= "      ->     ")
        return None if x%2!=0 else x//2

    OpD3 = Optionalize( Div3 )

    # we not wrap this one 
    def SPQRT(x: int) -> Optional[int]:
        print(f"-=^\\ {x} /^=-", end= "     ->     ")
        return None if x<0 else x**2

    print(                  SPQRT  (20) )
    print(                  SPQRT  (-1) )
    print(         Div2(    SPQRT  (20)) )   # Haskell would swear here
    print(         OpD3  (  SPQRT  (-1)) )
    print( Div2( Div2( Div2( Div2 ((-1)))))) # Only one set of wings printed (but Haskell would swear here too)
    print(         Div3(    SPQRT  (-1)) )   # TypeError at last

--------------------------

    -=^\ 20 /^=-     ->     400
    -=^\ -1 /^=-     ->     None
    -=^\ 20 /^=-     ->     -- 400 --      ->     200
    -=^\ -1 /^=-     ->     None
    -- -1 --      ->     None
    -=^\ -1 /^=-     ->     -- None --      ->     
    ---------------------------------------------------------------------------
    TypeError: unsupported operand type(s) for %: 'NoneType' and 'int'