haskpy.types.uncurried.UncurriedFunction

UncurriedFunction

class UncurriedFunction(UncurriedFunction__f)

Bases: Monad, Semigroup

Monad instance for normal Python functions

The functions can take any number of positional and keyword arguments, so the signature can be anything supported by Python. The function must be called by passing all arguments at the same time, so it doesn’t support automatic partial evaluation like Function. One way to think of this in type level is that the collection of all positional and keyword arguments are represented by type Args. So, the type of UncurriedFunction is Args -> a. This is a bit notational abuse as Args cannot be an output of a function, only an input. So, type a -> Args makes no sense. This means that one cannot compose these functions in a way that would pass Args to the next function because a function can only output a single value, not many values.

Note

Monoid instance of UncurriedFunction requires the knowledge of the contained monoid type in order to be able to create empty. The contained type is not known because Function class can be used to create functions of any type. This is just convenience and simpler user interface. If you need Monoid instance of UncurriedFunction, use UncurriedFunctionMonoid function to create such a class. Note though that the Semigroup instance is available in this Function without needing to use UncurriedFunctionMonoid.

__add__(other)

Append two monoids

Using + operator to append two monoid values seems natural because that’s what Python is doing by default because lists are concatenated with +.

__attrs_post_init__()

__call__(*args, **kwargs)

Call self as a function.

property __code__

__eq_test__(g, data, input_strategy=integers())

__get__(obj, objtype)

Support instance methods.

See: https://stackoverflow.com/a/3296318

__lshift__(x)

Sequence with << similarly as with <* and << in Haskell

__matmul__(x)

Application operand @ applies similarly as <*> in Haskell

f @ x translates to f.apply_to(x), x.apply(f) and apply(f, x).

Why @ operator?

• It’s not typically used as often as some other more common operators so less risk for confusion.

• The operator is not a commutative as isn’t apply either.

• If we see matrix as some structure, then matrix multiplication takes both left and right operand inside this structure and gives a result also inside this structure, similarly as apply does. So it’s an operator for two operands having a similar structure.

• The operator evaluates the contained function(s) at the contained value(s). Thus, f “at” x makes perfect sense.

__mod__(f)

Use % as bind operator similarly as >>= in Haskell

That is, x % f is equivalent to bind(x, f) and x.bind(f).

Why % operator?

• It’s not very often used so less risk for confusion.

• It’s not commutative as isn’t bind either.

• It is similar to bind in a sense that the result has the same unit as the left operand while the right operand has different unit.

• The symbol works visually as a line “binds” two circles and on the other hand two circles tell about two similar structures on both sides but those structures are just on different “level”.

__pow__(x)

__rpow__(f)

Lifting operator ** lifts similarly as <$> in Haskell

f ** x translates to x.map(f) and map(f, x).

Why ** operator?

• It’s not typically used as often as multiplication or addition so less risk of confusion.

• It’s not commutative operator as isn’t lifting either.

• The two operands have very different roles. They are not at the same “level”.

• The right operand is “higher”, that is, it’s inside a structure and the left operand is kind of “raised to the power” of the second operand, where the “power” is the functorial structure.

• The same operand is also used for function composition because function composition is just mapping. Visually the symbol can be seen as chaining two stars similarly as function composition chains two functions.

__rshift__(x)

Sequence with >> similarly as with *> and >> in Haskell

property __signature__

append(g)

Semigroup b => (Args -> b) -> (Args -> b) -> (Args -> b)

apply(g)

(Args -> b) -> (Args -> b -> c) -> Args -> c

apply_first(x)

Combine two actions, keeping only the result of the first

Apply f => f a -> f b -> f a

apply_second(x)

Combine two actions, keeping only the result of the second

Apply f => f a -> f b -> f b

apply_to(x)

f (a -> b) -> f a -> f b

Default implementation is based on apply.

bind(g)

(Args -> b) -> (b -> Args -> c) -> Args -> c

flap(x)

Functor f => f (a -> b) -> a - > f b

join()

m (m a) -> m a

Default implementation is based on bind:

self :: m (m a)

identity :: m a -> m a

bind :: m (m a) -> (m a -> m a) -> m a

map(g)

(Args -> b) -> (b -> c) -> (Args -> c)

pure(x)

a -> m a

replace(x)

Haskell ($>) operator