compose f g x = f (g x)
Isn't this just the benifits of native support for *functional composition* and *currying* [see: CurryingSchonfinkelling] or is it really the name a HigherOrderFunction?
*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:
*I'm not sure. For one, this compose2 takes 3 arguments. It seems to be equivalent to the following Haskell:*

In SchemeLanguage:*Or, if you want to take advantage of Scheme's multiple values:*
*In this case, F takes as many arguments as G returns. Even better would be to return an n-ary function:*
*And, better yet, to define COMPOSE itself to be n-ary:*
*--Riastradh*

In PythonLanguage:

In CsharpLanguage:

In the StandardTemplateLibrary:

In BlocksInJava:

JavaScript:

JoyLanguage: Functional composition is expressed in Joy by simple concatenation. In a sense, it is the default operator.

In OcamlLanguage:

HaskellLanguage has a pre-defined operator (.) for composition.

SmlLanguage has a pre-defined operator (o) for composition.

TeXnicard:

See also CommonHigherOrderFunctions FunctionalComposition InverseFunctionalComposition CategoryFunctionalProgramming CategoryInManyProgrammingLanguages

std::find( seq.begin(), seq.end(), std::compose2( std::and(), std::bind2nd( std::greater(), 0 ), std::bind2nd( std::less(), 11 ) );This composes a binary and operation with two unary operations like so that executing:

and( x )is really executing:

f = bind_second_parameter_of( greater(), 0 ); g = bind_second_parameter_of( less(), 0 ); o = and( f( x ), g( x ) );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.

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!!

In SchemeLanguage:

(define (compose f g) (lambda (x) (f (g x))))

(define (compose f g) (lambda (x) (call-with-values (lambda () (g x)) f)))

(define (compose f g) (lambda args (call-with-values (lambda () (apply g args)) f)))

(define (compose f . rest) (if (null? rest) f (let ((g (apply compose rest))) (lambda args (call-with-values (lambda () (apply g args)) f)))))

In PythonLanguage:

def compose(f, g): return lambda x, f=f, g=g: f(g(x))

In CsharpLanguage:

public static Converter<T1, T3> Compose<T1, T2, T3>(Converter<T2, T3> f, Converter<T1, T2> g) { return delegate(T1 x) { return f(g(x)); }; }

In the StandardTemplateLibrary:

std::compose1( std::ptr_fun( f ), std::ptr_fun( g ) );

In BlocksInJava:

UnaryFunction compose1( UnaryFunction f, UnaryFunction g ) { return new UnaryCompose( f, g ); }For example given the following FunctorObjects:

UnaryFunction f = new UnaryFunction() { public Object eval( Object x ) { return x.toString() + "f"; } }; UnaryFunction g = new UnaryFunction() { public Object eval( Object x ) { return x.toString() + "g"; } };You can do the following:

o = compose1( f, g ); o.eval( x );This creates the string:

"xgf"

JavaScript:

function compose(f,g) { return function(x) { return f(g(x)) } } function square(x) { return x*x } function halve(x) { return x/2 } assert( compose( halve, square ) (4) == 8 )See http://ling.ucsd.edu/~barker/Iota/ where JavaScript and composition are used to simulate the combinative languages Iota and Jot.

JoyLanguage: Functional composition is expressed in Joy by simple concatenation. In a sense, it is the default operator.

In OcamlLanguage:

let compose f g x = f (g x)

HaskellLanguage has a pre-defined operator (.) for composition.

Prelude> ( (`div` 2) . (^2) ) 4 8It could have been defined like this:

(f . g) x = f (g x)

SmlLanguage has a pre-defined operator (o) for composition.

- ( (fn x => x div 2) o (fn x => x * x) ) 4; val it = 8 : intIt could have been defined like this:

fun op o (f, g) x = f (g x)

TeXnicard:

@S Compose @. ( code code -- code ) rB[x]+rB[x]++You can also just use the + operator although that won't work in many cases, such as if one or both operands are numbers or if the first code is a string that ends with a number in decimal notation.

See also CommonHigherOrderFunctions FunctionalComposition InverseFunctionalComposition CategoryFunctionalProgramming CategoryInManyProgrammingLanguages

View edit of May 16, 2011 or FindPage with title or text search