"andThen" and "compose" methods for functions with more than 1 argument

Scala Standard Library
1

Now they are exist for Function1 only, but it is useful to have them for any Function, since Tuples are converted to function arguments in Scala 3.

The logic is: if someFunction return type is a some Tuple(T1, T2…) , you can compose it with otherFunction, which has (T1, T2…) arguments with the same types, as returned Tuple from someFunction.

For example, if

val f1: (T1, T2) => (T3, T4, T5)
val f2: (T3, T4, T5) => R

then

f2 compose f1

or

f1 andThen f2

gives you the function

(x1: T1, x2: T2) => R = f2( f1(x1, x2) )

It has some symmetry with “function-chain call” proposal.

1 Like
2

FunctionN#andThen(g: Function1) and Function1#compose(g: FunctionN) sound more useful to me than the other varieties that you could tuple or curry to get composition for.

I have had the intent to make a PR for those when I needed them in practice for years, but it seems it just never comes up.

1 Like
3

Easiest example is 2d-point operations without declaration of class Point (it makes them independent of particular class and, this way, more general).

def move(shiftX: Int, shiftY: Int)(x: Int, y: Int) = (x + shiftX, y + shiftY)
def drawPoint(implicit canvas: Canvas) = (x: Int, y: Int) =>
   {canvas.point(x, y); (x, y)}

val movements = 
  move(1,  1) andThen 
    drawPoint andThen 
    move(-5, 10) andThen 
    drawPoint andThen 
    move(10, 0)

movements(100, 100)
4

ignoring the canvas, in scala 3, you have to tuple the first one, and then it’ll flow along:

val movements =
  move(1, 1).tupled andThen
    drawPoint andThen
    move(-5, 10) andThen
    drawPoint andThen
    move(10, 0)

because you have auto-tupling for infix operators.