reader monad usage about pfun HOT 6 CLOSED

I often find that eliminating "plumbing" parameters with Reader is most effective when you ask for the reader value close to where you need it. In your example I would probably do something like

from pfun.reader import map_m, Reader, ask

def main():
    connection = Connection(URI='testuri')
    result = process_all().run(connection)
    print(result)


def process_all() -> Reader[Connection, str]:
    return map_m(process, range(5)).map(lambda _: 'result')


def process(item: int) -> Reader[Connection, None]:
    return ask().map(lambda c: print(item, c))

map_m is sort of like the built-in map except it expects a function that returns a Reader and will combine the results of mapping process over range(5) using and_then.

Reader.map applies its function argument to the "wrapped" Reader value, which in the case of the reader returned by ask happens to be the Connection instance.

from pfun.

I apologize that I don't talk about map in the guide on readthedocs :)
I think the documentation still has a way to go before its super beginner friendly.

from pfun.

Maye sequence is a little more pythonic in this case:

from pfun.reader import sequence, Reader, ask

def process_all() -> Reader[Connection, str]:
    return sequence(process(i) for i in range(5)).map(lambda _: 'result')

from pfun.

Thanks, so if I want to do some stuff with a result coming from process I can do something like:

def process_all() -> Reader[Connection, List[int]]:
    def process_results(r):
        return list(map(lambda x: x*2, r))

    return map_m(process, range(5)).map(process_results)


def process(item: int) -> Reader[Connection, int]:
    def _(c):
        # do stuff
        return item
    return ask().map(_)

from pfun.

Another question :), if I want to use the Writer Monad together with Reader Monad:

def process(item: int) -> Writer[Reader[Connection, int], List[str]]:
    mylog = []
    def _(c):
        # do stuff
        mylog.append('test log')
        return item*2
    return Writer(ask().map(_), mylog)

connection = Connection(URI='testuri')
result, log = process(4).map(lambda x: x.run(connection))
print(log)
print(result)

there is a better way to do it? It seems a little ugly to me, and it's a very simple example.

from pfun.

Thanks, so if I want to do some stuff with a result coming from process I can do something like

Exactly!

Another question :), if I want to use the Writer Monad together with Reader Monad

This is normally referred to as effect composition, and no, its not very nice. In other frameworks you'll find special constructs for dealing with this (monad transformers e.g). For pfun I'm working on another approach which will be released beginning of 2020

from pfun.