I've always called the block in #inject:into: the *combining* function. Perhaps the reason I don't think of it as a "reducing" function is that setOfSets inject: Set new into: [:acc :each | acc union: each] has a block that combines its arguments in a way that makes the result bigger, not smaller. For what it's worth, Backus used "insert": *insert-right* /*f* where /*f*:ã*x*ã = *x* and /*f*:ã*x*1,*x*2,...,*x*nã = *f*:ã*x*1,/*f*:ã*x*2,...,*x*nãã and /*f*:ã ã = *unit f* *insert-left* \*f* where \*f*:ã*x*ã = *x* and \*f*:ã*x*1,*x*2,...,*x*nã = *f*:ã\*f*:ã*x*1,...,*x*n-1ã,*x*nã and \*f*:ã ã = *unit f* --- https://en.wikipedia.org/wiki/FP_(programming_language) Every day spent debating the words is another day the software isn't getting used, so I'm sorry about prolonging this. Some names are just too confusing. Some years ago, I found it useful to add {value:}...{optionalValue:}... to my library for passing arguments that the receiver may choose to ignore. (The methods are exactly as direct as the {value:}... methods, no extra allocations or anything.) About the same time, Pharo independenty added {cull:}... but it was years before I noticec, because "cull" to me means either (a) to slaughter a large proportion of a population of wild or domestic anmals, or (b) to gather information from a large number of sources. (The concept "reap" is lurking somewhere in the background.) I don't know who came up with that name for pass-optional-argument, but it grates so much I can't bring myself to use it and just make do without optional parameters in Pharo. In fact it was this example that was at the back of my mind. Changing the subject a wee bit, there's an operation family in my library, and I wonder how it would fit into Transducers? To avoid bias, here's a specification in Haskell (for lists, because I haven't had any luck installing Data.Witherable). uccessorBy, predecessorBy :: (a -> a -> Ordering) -> a -> [a] -> a successor, predecessor :: Ord a => a -> [a] -> a successor = successorBy compare successorBy cmp x = minimumBy cmp . filter (\y -> cmp x y == LT) predecessor = predecessorBy compare predecessorBy cmp = successorBy (flip cmp) The reason these operations exist is to pick neighbouring elements in SortedCollections and SortedSets. But they make *sense* for any Enumerable. So there are "generic" definitions with orderrides for those two classes. A filter + a reduce . Traditionally, a #select:thenFold:ifNone: in order to avoid building an intermediate collection. That much I see how to do with transducers. But you can't get the desired override for #successor:[sortBlock:][ifNone:] by overriding #select:thenFold:ifNone: in SortedCollection or SortedSet. So what *should* one do?