I need to write a "decorator" function that takes ...

# arrow

[Derek Berner]

I need to write a "decorator" function that takes in any function with arbitrary args (A,B,C,D,...) -> Z and returns a function of the same type that performs some decoration logic. Does arrow provide capabilities to do this?

[simon.vergauwen]

Do you mean like Shapeless? https://github.com/milessabin/shapeless/wiki/Feature-overview:-shapeless-2.0.0#facilities-for-abstracting-over-arity

[simon.vergauwen]

We currently don’t have any functionality to do this, but we’ve thought about it many times. We’d love to support real N arity functions for applicative builders, parMapN, raceN, etc.

Perhaps in the future but that would require a compiler plugin for sure. Kotlin does this internally in the compiler to create `Function`(N).

[Bob Glamm]

Well, if you have an upper arity limit it's possible to write extension functions similar to the tupling functions, too

[Bob Glamm]

e.g.

fun <A, B, C> ((A, B) -> C).decorate(f: () -> Unit, g: () -> Unit): ((A, B) -> C) =
        { a, b -> f(); val c = this.invoke(a, b); g(); c }

[Bob Glamm]

which is a little specific and ugly but works

[Bob Glamm]

not as clever or as elegant as Shapeless or a compiler plugin, to be sure

[Derek Berner]

Yeah, shapeless, exactly

[Derek Berner]

Yeah, you could use tupled and untupled, but the compiler would force you to call it for every decoration. decorate(f.tupled()).untupled() 😞

[raulraja]

We are gonna support this transparently with compiler plugins

[raulraja]

Both polyadic functions that generate automatically n arities based on calls and HList style derivation for product and coproduct type based on the presence of instances of tuples and hlists

[raulraja]

But we are not there yet

[raulraja]

We have currently proven we can implement higherkinds and pure function checks with compiler plugins and we are currently building support for keep 87 which is a preliminary step to auto derivation of instances

[raulraja]

We plan on supporting derivation of instances automatically for product and coproduct types and based on structural discovery for any data type that exposes the main methods from which a type class can derive the rest. For example anything that has map can derive Functor. We attempt at deriving the law tests too

[raulraja]

So you could test if your datatype is actually a lawful Functor

[Derek Berner]

Nice