fptools.lazy

Pythonic FP - Lazy function evaluation

Delayed function evaluations. FP tools for “non-strict” function evaluations. Useful to delay a function’s evaluation until some inner scope.

Non-strict delayed function evaluation.

• class Lazy - Delay evaluation of functions taking & returning single values

• function lazy - Delay evaluation of functions taking any number of values

• function real_lazy - Version of lazy which caches its result

class pythonic_fp.fptools.lazy.Lazy(f: Callable[[D], R], d: D, pure: bool = True)

Delayed evaluation of a singled valued function.

Class instance delays the executable of a function where Lazy(f, arg) constructs an object that can evaluate the Callable f with its argument at a later time.

• first argument f taking values of type D to values of type R

• second argument arg: D is the argument to be passed to f

  • where the type D is the tuple type of the argument types to f

• function is evaluated when the eval method is called

• result is cached unless pure is set to False

• returns True in Boolean context if evaluated

Usually use case is to make a function “non-strict” by passing some of its arguments wrapped in Lazy instances.

eval() → None

Evaluate function with its argument.

• evaluate function

• cache result or exception if pure == True

• reevaluate if pure == False

get(alt: R | None = None) → R | Never

Get result only if evaluated and no exceptions occurred, otherwise return an alternate value.

A possible use case would be if the calculation is expensive, but if it has already been done, its result is better than the alternate value.

get_exception() → MayBe[Exception]

Get result only if evaluate and exceptional.

get_result() → MayBe[R]

Get result only if evaluated and not exceptional.

got_exception() → MayBe[bool]

Return true if Lazy raised exception.

got_result() → MayBe[bool]

Return true if an evaluated Lazy did not raise an exception.

pythonic_fp.fptools.lazy.lazy(f: Callable[[P], R], *args: P, **kwargs: P) → Lazy[tuple[Any, ...], R]

Delayed evaluation of a function with arbitrary positional arguments.

Function returning a delayed evaluation of a function of an arbitrary number of positional arguments.

• first positional argument f takes a function

• next positional arguments are the arguments to be applied later to f

  • f is reevaluated whenever eval method of the returned Lazy is called

• any kwargs passed are ignored

  • if f needs them, then wrap f in another function

pythonic_fp.fptools.lazy.real_lazy(f: Callable[[P], R], *args: P, **kwargs: P) → Lazy[tuple[Any, ...], R]

Cached delayed evaluation of a function with arbitrary positional arguments.

Function returning a delayed evaluation of a function of an arbitrary number of positional arguments.

• first positional argument f takes a function

• next positional arguments are the arguments to be applied later to f

  • f is evaluated when eval method of the returned Lazy is called

  • f is evaluated only once with results cached

• any kwargs passed are ignored

  • if f needs them then wrap f in another function