Add cross join (#1) #5203
Add cross join (#1) #5203
Conversation
| /** | ||
| * Returns a list containing all possible pairs with left field from the first collection, | ||
| * and the right field from the second collection, | ||
| * applying the provided transformation against those pairs. | ||
| * | ||
| * The returned set preserves the element iteration order of both original collections. | ||
| * It begins with all the pairs with the first element of left collection, | ||
| * combined with all the elements of the right one in the order of the right collection. | ||
| * | ||
| * @sample samples.collections.Collections.BinaryOperations.crossJoinWithTransformation | ||
| */ | ||
| fun <T, U, V> crossJoin( | ||
| left: Collection<T>, | ||
| right: Collection<U>, | ||
| transformation: (left: T, right: U) -> V, | ||
| ): Sequence<V> { | ||
| return sequence { | ||
| left.forEach { leftElement -> | ||
| right.forEach { rightElement -> | ||
| yield(transformation(leftElement, rightElement)) | ||
| } | ||
| } | ||
| } | ||
| } |
There was a problem hiding this comment.
Based on the crossJoin implementation you've provided, I believe it's possible to extend the concept to combine multiple elements from multiple collections, not just pairs of two elements. This could be achieved by creating a function that takes a list of collections and performs a multi-element cross join operation, producing combinations of elements from each collection.
The function signature could look something like this:
fun <T, V> multiCrossJoin(
collections: List<Collection<T>>,
transformation: (List<T>) -> V
): Sequence<V> {
var result: Sequence<List<T>> = sequenceOf(emptyList())
for (collection in collections) {
result = result.flatMap { acc ->
collection.map { element -> acc + element }
}
}
return result.map { transformation(it) }
}
This function would take a list of collections and a transformation function, and it would perform a multi-element cross join operation to generate combinations of elements from each collection. The implementation would involve iterating through each collection and combining the elements to produce the desired combinations.
I believe that such a function would provide a flexible and powerful way to generate combinations from multiple collections of elements.
There was a problem hiding this comment.
Based on the crossJoin implementation you've provided, I believe it's possible to extend the concept to combine multiple elements from multiple collections, not just pairs of two elements. This could be achieved by creating a function that takes a list of collections and performs a multi-element cross join operation, producing combinations of elements from each collection.
The function signature could look something like this:
fun <T, V> multiCrossJoin( collections: List<Collection<T>>, transformation: (List<T>) -> V ): Sequence<V> { var result: Sequence<List<T>> = sequenceOf(emptyList()) for (collection in collections) { result = result.flatMap { acc -> collection.map { element -> acc + element } } } return result.map { transformation(it) } }This function would take a list of collections and a transformation function, and it would perform a multi-element cross join operation to generate combinations of elements from each collection. The implementation would involve iterating through each collection and combining the elements to produce the desired combinations.
I believe that such a function would provide a flexible and powerful way to generate combinations from multiple collections of elements.
You are solving a different problem: all elements in your collections have the same type T. The whole point of this PR is to handle pairs of elements with different types, left: T, right: U.
There was a problem hiding this comment.
You are solving a different problem: all elements in your collections have the same type T. The whole point of this PR is to handle pairs of elements with different types,
left: T, right: U.
Sure, I understand. It seems that I overlooked the fact that the types of "left" and "right" are different. I created a function to find all possible combinations of elements of the same type, and it looks like you implemented something different. If this PR gets merged, I will try implementing it based on this idea and submit another PR. Thank you.
add binary operation
crossJoin, as it is commonly used