No it is not the same as currying. Composing f and g returns a function that takes one argument and applies f to the result of applying g to its argument. In Haskell the ComposeFunction? is denoted by '.', so (f . g) is the same as (lambda x (f (g x))). Currying would give (lambda x (f g x)) which is completely different.

Cool! I think I get it now! It's seems kind of like the std::binder1st, std::binder2nd, and std::compose classes in STL. Where you can, for example, partially specify the arguments of a binary function to make it evaluate as a unary function?

Partially specifying the arguments of a binary function is called partial application, which you get ForFree if all your functions are curried. This is not directly related to ComposeFunction.

Great, that makes sense. However, it seems like composition, at least the way we use it in CeePlusPlus, is not as useful without having these binders for partial application. For example:

Which, in this example is used to find the first x in the sequence that is in the range of [1,11). Is this similar in intent? In BlocksInJava I provide classes like BinderFirst, BinderSecond, UnaryCompose, and BinaryCompose to do the same thing as this CeePlusPlus example.

I'm not sure. For one, this compose2 takes 3 arguments. It seems to be equivalent to the following Haskell:

compose2 f g h x = f (g x) (h x)

Okay, this is the same...well, at least as close to the same as CeePlusPlus can get with classes, templates, and function objects!!