Act

Library for dynamic functional programming and more.

Enter this command and go to the documentation:

pip install act4

Overview

fromtypingimportOptional, Callablefromactimport*defdivision_between(a: int, b: int) ->int|bad[str]:
ifa==0orb==0:
returnbad("division by zero")
returna/bWithNumber=type(number=N)
WithMultiplication=type(multiplication=M)
WithDivision=type(division=D)
Result=WithMultiplication[N] &WithDivision[N]
@fbind_by(... |then>>on(None, bad("something is missing")))@do(maybe, optionally, for_input=optionally)deffunc(do: Do, a: WithNumber[Optional[int]], b: WithNumber[Optional[int]]) ->Result[int]:
maybe, optionally=dofirst_number=optionally.same(a.number)
second_number=optionally.same(b.number)
division=maybe(division_between)(first_number, second_number)
multiplication=first_number*second_numberreturnResult(multiplication, division)
# As a result, `func` has this type.func: Callable[
[Optional[WithNumber[Optional[int]]], Optional[WithNumber[Optional[int]]]],
Result[int] |bad[str],
]
assertfunc(WithNumber(16), WithNumber(2)) ==obj(multiplication=32, division=8)
assertfunc(WithNumber(16), WithNumber(0)) ==bad("division by zero")
assertfunc(WithNumber(16), WithNumber(None)) ==bad("something is missing")
assertfunc(WithNumber(16), None) ==bad("something is missing")
classRawResult:
def__init__(self, multiplication: int, division: int) ->None:
self.multiplication=multiplicationself.division=divisionassert (
Result(32, 8)
==RawResult(32, 8)
==WithMultiplication(32) &WithDivision(8)
==obj(multiplication=32, division=8)
)