So I want to minimize both the necessary calculations as well as the traversals, creating no intermediate data structures.

Sequence it is then, or plain old imperative code

class matcher(private val similarity: Similarity, private vararg val f : BiPred) {
    fun bind() : (Data) -> (Data) -> EnumSet<Similarity> =
        { data ->
            { otherdata -> f
                .map{ partial(data, it) }
                .fold(true) { acc, func -> acc && func(otherdata)} //TODO can short-circuit here
                .let { if (it) EnumSet.of(similarity) else EnumSet.noneOf(Similarity::class.java)}}
        }

    companion object {
        fun bind (matchers : List<matcher>) : (Data) -> (Data) -> EnumSet<Similarity> {
            return when (matchers.size) {
                0 -> { _ -> { EnumSet.noneOf(Similarity::class.java) } }
                1 -> matchers.first().bind()
                else ->
                    { d: Data ->
                        { d2: Data ->
                            matchers
                                .map { matcher -> matcher.bind() }
                                .fold(EnumSet.noneOf(Similarity::class.java)) { acc, f ->
                                    acc.apply { addAll(f(d)(d2)) }
                                }
                        }
                    }
            }
        }
    }
}

Ended up with this, which gives me the most flexibility. I can decide later how to invoke it. Is there a better name than bind? That probably has a very specific meaning in FP

fun bind() :

this is a specific version of a general pattern, which is currying

Just realised arrow also has

.uncurried()

which will convert my bind into a regular function. Don't quite understand what you mean by your last point. My curried function is a return value, so nothing should be allocated unless I invoke

bind()

which is just a regular function. I can see how having a curried function results in an extra allocation due to an intermediate object being returned on invocation with the first parameter. But what do you mean by making it a val? you mean instead of using fun? Looking at it another way, my

matcher

class is really a factory for comparison operations, so I could rename

bind()

to

comparator()

. Would it be more efficient to return

(Data, Data) -> EnumSet<Similarity>

to avoid currying altogether?

so my point was taking your example to the extreme

So I could rewrite it to take two parameters via

{ d, d2 ->

then assign the return value to a

val

in OCaml, Haskell or Scala I could do

let myFun x y = x + y
let plusOne x = myFun 3

Yep gotcha. I think it's unavoidable in my case. I really do have a factory of comparators. I coud probably do something with macros in clojure, but not sure how I can keep my comparators from being allocated dynamically in Kotlin. However, I should only have 6-8 comparators created and they will only be created by my factory as necessary.

instead, we write them as

fun

and take a function reference when it’s needed

Thanks for all your help, learned a lot

What I tried to run the whole thing as a sequence I got stackoverflow errors since everything was lazy

loool I missed this

Hehe. Yep, I don't think sequences was the right way to go. The cost of running the comparisons varies drastically. What I really want is a scheduler and coroutines.

why not using arrow.IO