OOP languages compose on the level of a class rather than function because an individual function rarely represents something you want to work with independently. That's the whole point of OOP - it says what real programs care about is objects, not functions.

But OOP languages do have lambdas and function pointers, so can easily do something very close to that. In Kotlin:

    fun addOne(value: Int) = value + 1
    fun addTwo(value: Int) = value + 2
    val addThree = fun (value: Int) { addOne(addTwo(value)) }

There are libraries that add a pure functional composition operator via a + operator overload, I think.

Even in Java you can do function composition, though it's not well known and a bit verbose:

    import static java.lang.invoke.MethodHandles.*;
    import static java.lang.invoke.MethodType.*;

    static int addOne(int i) { return i + 1; }
    static int addTwo(int i) { return i + 2; }

    void combine() throws Throwable {
        var lookup = lookup();
        var type = methodType(int.class, int.class);
        var first = lookup.findStatic(Main.class, "addOne", type);
        var second = lookup.findStatic(Main.class, "addTwo", type);
        var combination = filterReturnValue(first, second);
        System.out.println(combination.invoke(1));   // Prints 4
    }