Is there a name for this patter in functional programming? What would you name the function? ``` ...

# functional

[gsala]

Is there a name for this patter in functional programming? What would you name the function?

fun ((A, B) -> Unit).whatShouldThisBeNamed(b: B): (A) -> Unit {
        return { a -> this(a, b) }
    }

(A function that returns a simpler function by providing one of the parameters to the first function)

[ephemient]

partial application (e.g. https://docs.python.org/3/library/functools.html#functools.partial) or bind (e.g. https://en.cppreference.com/w/cpp/utility/functional/bind), but typically you bind the arguments starting from the left side

[ephemient]

but https://kotlinlang.slack.com/archives/CQ3GFJTU1/p1634832675000100?thread_ts=1634242183.020800&cid=CQ3GFJTU1

[ephemient]

although I suppose it's quite unlikely that you'd be using this on a lambda expression, as that would be fairly pointless

[gsala]

Thanks.

My use case is I have a container class

class Container(
    val container : ContainerModel,
    val onItemClick : (Container, Item -> Unit)
) {
    val items = container.items
        .map { Item(it, onItemClick.partialApply(container) }
}

and an item class

class Item(
    val item : ItemModel,
    val onItemClick : (Item -> Unit)
)

So I want to provide the container parameter to the lambda passed into the items

[gsala]

Now I don’t really know if I should turn the extension function above into an operator invoke function

[andyg]

I would likely take Roman's advice and avoid, but in any case, I think this is known as "currying"

[Ties]

Yes, the concept is called partial application. Currying is turning a function with 2 (or more) arguments into 2 functions with 1 argument (e.g: plus(a,b) becomes plus(a)(b), where plus(a) returns a function with 1 argument where a is partially applied