Function composition

From Rosetta Code
Jump to: navigation, search
Task
Function composition
You are encouraged to solve this task according to the task description, using any language you may know.

Create a function, compose, whose two arguments f and g, are both functions with one argument. The result of compose is to be a function of one argument, (lets call the argument x), which works like applying function f to the result of applying function g to x, i.e,

compose(f, g) (x) = f(g(x))

Reference: Function composition

Hint: In some languages, implementing compose correctly requires creating a closure.

Contents

[edit] ActionScript

ActionScript supports closures, making function composition very straightforward.

function compose(f:Function, g:Function):Function {
return function(x:Object) {return f(g(x));};
}
function test() {
trace(compose(Math.atan, Math.tan)(0.5));
}

[edit] Ada

The interface of a generic functions package. The package can be instantiated with any type that has value semantics. Functions are composed using the operation '*'. The same operation applied to an argument evaluates it there: f * x. Functions can be composed with pointers to Ada functions. (In Ada functions are not first-class):

generic
type Argument is private;
package Functions is
type Primitive_Operation is not null
access function (Value : Argument) return Argument;
type Func (<>) is private;
function "*" (Left : Func; Right : Argument) return Argument;
function "*" (Left : Func; Right : Primitive_Operation) return Func;
function "*" (Left, Right : Primitive_Operation) return Func;
function "*" (Left, Right : Func) return Func;
private
type Func is array (Positive range <>) of Primitive_Operation;
end Functions;

Here is an implementation;

package body Functions is
function "*" (Left : Func; Right : Argument) return Argument is
Result : Argument := Right;
begin
for I in reverse Left'Range loop
Result := Left (I) (Result);
end loop;
return Result;
end "*";
 
function "*" (Left, Right : Func) return Func is
begin
return Left & Right;
end "*";
 
function "*" (Left : Func; Right : Primitive_Operation) return Func is
begin
return Left & (1 => Right);
end "*";
 
function "*" (Left, Right : Primitive_Operation) return Func is
begin
return (Left, Right);
end "*";
end Functions;

The following is an example of use:

with Ada.Numerics.Elementary_Functions;  use Ada.Numerics.Elementary_Functions;
with Ada.Text_IO; use Ada.Text_IO;
with Functions;
 
procedure Test_Compose is
package Float_Functions is new Functions (Float);
use Float_Functions;
 
Sin_Arcsin : Func := Sin'Access * Arcsin'Access;
begin
Put_Line (Float'Image (Sin_Arcsin * 0.5));
end Test_Compose;
Output:
 5.00000E-01

[edit] Aikido

 
import math
 
function compose (f, g) {
return function (x) { return f(g(x)) }
}
 
var func = compose(Math.sin, Math.asin)
println (func(0.5)) // 0.5
 
 

[edit] ALGOL 68

Translation of: Python
Works with: ELLA ALGOL 68 version Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386

Note: Returning PROC (REAL x)REAL: f1(f2(x)) from a function apparently violates standard ALGOL 68's scoping rules. ALGOL 68G warns about this during parsing, and then rejects during runtime.

MODE F = PROC(REAL)REAL; # ALGOL 68 is strong typed #
 
# As a procedure for real to real functions #
PROC compose = (F f, g)F: (REAL x)REAL: f(g(x));
 
OP (F,F)F O = compose; # or an OPerator that can be overloaded #
 
# Example use: #
F sin arc sin = compose(sin, arc sin);
print((sin arc sin(0.5), (sin O arc sin)(0.5), new line))
Output:
+.500000000000000e +0 +.500000000000000e +0

ALGOL 68 is a stack based language, and the following apparently does not violate it's scoping rules.

Works with: ALGOL 68 version Standard - Jan 1975 Boston SC allowed Partial Parametrization.
Works with: ALGOL 68G version Any - tested with release mk15-0.8b.fc9.i386
MODE F = PROC(REAL)REAL; # ALGOL 68 is strong typed #
 
# As a procedure for real to real functions #
PROC compose = (F f, g)F: ((F f2, g2, REAL x)REAL: f2(g2(x)))(f, g, ); # Curry #
 
PRIO O = 7;
OP (F,F)F O = compose; # or an OPerator that can be overloaded #
 
# Example use: #
F sin arc sin = compose(sin, arc sin);
print((sin arc sin(0.5), (sin O arc sin)(0.5), new line))

[edit] AppleScript

-- Compose two functions where each function is
-- a script object with a call(x) handler.
on compose(f, g)
script
on call(x)
f's call(g's call(x))
end call
end script
end compose
 
script sqrt
on call(x)
x ^ 0.5
end call
end script
 
script twice
on call(x)
2 * x
end call
end script
 
compose(sqrt, twice)'s call(32)
-- Result: 8.0

[edit] Applesoft BASIC

10 F$ = "SIN"
20 DEF FN A(P) = ATN(P/SQR(-P*P+1))
30 G$ = "FN A"
40 GOSUB 100"COMPOSE
50 SA$ = E$
 
60 X = .5 : E$ = SA$
70 GOSUB 200"EXEC
80 PRINT R
90 END
 
100 E$ = F$ + "(" + G$ + "(X))" : RETURN : REMCOMPOSE F$ G$
 
200 D$ = CHR$(4) : FI$ = "TEMPORARY.EX" : M$ = CHR$(13)
210 PRINT D$"OPEN"FI$M$D$"CLOSE"FI$M$D$"DELETE"FI$
220 PRINT D$"OPEN"FI$M$D$"WRITE"FI$
230 PRINT "CALL-998:CALL-958:R="E$":CONT"
240 PRINT D$"CLOSE"FI$M$D$"EXEC"FI$:CALL-998:END:RETURN

[edit] Argile

Only works for functions taking real and returning real (double precision, 64 bits)

Works with: Argile version 1.0.0
use std, math
 
let my_asin = new Function (.:<any,real x>:. -> real {asin x})
let my__sin = new Function (.:<any,real x>:. -> real { sin x})
let sinasin = my__sin o my_asin
print sin asin 0.5
print *my__sin 0.0
print *sinasin 0.5
~my_asin
~my__sin
~sinasin
 
=: <Function f> o <Function g> := -> Function {compose f g}
 
.:compose <Function f, Function g>:. -> Function
use array
let d = (new array of 2 Function)
(d[0]) = f ; (d[1]) = g
let c = new Function (.:<array of Function fg, real x>:. -> real {
*fg[0]( *fg[1](x) )
}) (d)
c.del = .:<any>:.{free any}
c
 
class Function
function(any)(real)->(real) func
any data
function(any) del
 
=: * <Function f> <real x> := -> real
Cgen "(*("(f.func)"))("(f.data)", "(x)")"
 
.: del Function <Function f> :.
unless f.del is nil
call f.del with f.data
free f
=: ~ <Function f> := {del Function f}
 
.: new Function <function(any)(real)-\>real func> (<any data>):. -> Function
let f = new Function
f.func = func
f.data = data
f


[edit] AutoHotkey

contributed by Laszlo on the ahk forum

MsgBox % compose("sin","cos",1.5)
 
compose(f,g,x) { ; function composition
Return %f%(%g%(x))
}

[edit] BBC BASIC

      REM Create some functions for testing:
DEF FNsqr(a) = SQR(a)
DEF FNabs(a) = ABS(a)
 
REM Create the function composition:
SqrAbs = FNcompose(FNsqr(), FNabs())
 
REM Test calling the composition:
x = -2 : PRINT ; x, FN(SqrAbs)(x)
END
 
DEF FNcompose(RETURN f%, RETURN g%)
LOCAL f$, p% : DIM p% 7 : p%!0 = f% : p%!4 = g%
f$ = "(x)=" + CHR$&A4 + "(&" + STR$~p% + ")(" + \
\ CHR$&A4 + "(&" + STR$~(p%+4) + ")(x))"
DIM p% LEN(f$) + 4 : $(p%+4) = f$ : !p% = p%+4
= p%
Output:
-2        1.41421356

[edit] Bori

double sin (double v)	{ return Math.sin(v); }
double asin (double v) { return Math.asin(v); }
Var compose (Func f, Func g, double d) { return f(g(d)); }
 
void button1_onClick (Widget widget)
{
double d = compose(sin, asin, 0.5);
label1.setText(d.toString(9));
}
Output:
on Android phone:
0.500000000

[edit] Brat

compose = { f, g | { x | f g x } }
 
#Test
add1 = { x | x + 1 }
double = { x | x * 2 }
b = compose(->double ->add1)
p b 1 #should print 4

[edit] C

Only works for functions taking a double and returning a double:

#include <stdlib.h>
 
/* generic interface for functors from double to double */
typedef struct double_to_double {
double (*fn)(struct double_to_double *, double);
} double_to_double;
 
#define CALL(f, x) f->fn(f, x)
 
 
/* functor returned by compose */
typedef struct compose_functor {
double (*fn)(struct compose_functor *, double);
double_to_double *f;
double_to_double *g;
} compose_functor;
/* function to be used in "fn" in preceding functor */
double compose_call(compose_functor *this, double x) {
return CALL(this->f, CALL(this->g, x));
}
/* returns functor that is the composition of functors
f & g. caller is responsible for deallocating memory */

double_to_double *compose(double_to_double *f,
double_to_double *g) {
compose_functor *result = malloc(sizeof(compose_functor));
result->fn = &compose_call;
result->f = f;
result->g = g;
return (double_to_double *)result;
}
 
 
 
#include <math.h>
 
/* we can make functors for sin and asin by using
the following as "fn" in a functor */

double sin_call(double_to_double *this, double x) {
return sin(x);
}
double asin_call(double_to_double *this, double x) {
return asin(x);
}
 
 
 
#include <stdio.h>
 
int main() {
double_to_double *my_sin = malloc(sizeof(double_to_double));
my_sin->fn = &sin_call;
double_to_double *my_asin = malloc(sizeof(double_to_double));
my_asin->fn = &asin_call;
 
double_to_double *sin_asin = compose(my_sin, my_asin);
 
printf("%f\n", CALL(sin_asin, 0.5)); /* prints "0.500000" */
 
free(sin_asin);
free(my_sin);
free(my_asin);
 
return 0;
}

[edit] C++

#include <functional>
#include <cmath>
#include <iostream>
 
// functor class to be returned by compose function
template <class Fun1, class Fun2>
class compose_functor :
public std::unary_function<typename Fun2::argument_type,
typename Fun1::result_type>
{
protected:
Fun1 f;
Fun2 g;
 
public:
compose_functor(const Fun1& _f, const Fun2& _g)
: f(_f), g(_g) { }
 
typename Fun1::result_type
operator()(const typename Fun2::argument_type& x) const
{ return f(g(x)); }
};
 
// we wrap it in a function so the compiler infers the template arguments
// whereas if we used the class directly we would have to specify them explicitly
template <class Fun1, class Fun2>
inline compose_functor<Fun1, Fun2>
compose(const Fun1& f, const Fun2& g)
{ return compose_functor<Fun1,Fun2>(f, g); }
 
int main() {
std::cout << compose(std::ptr_fun(::sin), std::ptr_fun(::asin))(0.5) << std::endl;
 
return 0;
}
Works with: C++11
composing std::function
#include <iostream>
#include <functional>
#include <cmath>
 
template <typename A, typename B, typename C>
std::function<C(A)> compose(std::function<C(B)> f, std::function<B(A)> g) {
return [f,g](A x) { return f(g(x)); };
}
 
int main() {
std::function<double(double)> f = sin;
std::function<double(double)> g = asin;
std::cout << compose(f, g)(0.5) << std::endl;
 
return 0;
}
Works with: GCC
GCC's C++ library has a built-in compose function
#include <iostream>
#include <cmath>
#include <ext/functional>
 
int main() {
std::cout << __gnu_cxx::compose1(std::ptr_fun(::sin), std::ptr_fun(::asin))(0.5) << std::endl;
 
return 0;
}

[edit] C#

using System;
class Program
{
static void Main(string[] args)
{
Func<int, int> outfunc = Composer<int, int, int>.Compose(functA, functB);
Console.WriteLine(outfunc(5)); //Prints 100
}
static int functA(int i) { return i * 10; }
static int functB(int i) { return i + 5; }
class Composer<A, B, C>
{
public static Func<C, A> Compose(Func<B, A> a, Func<C, B> b)
{
return delegate(C i) { return a(b(i)); };
}
}
}

[edit] Clojure

Function composition is built in to Clojure. Simply call the comp function.

A manual implementation could look like this:

(defn compose [f g]
(fn [x]
(f (g x))))
 
; Example
(def inc2 (compose inc inc))
(println (inc2 5)) ; prints 7

[edit] CoffeeScript

 
compose = ( f, g ) -> ( x ) -> f g x
 
# Example
add2 = ( x ) -> x + 2
mul2 = ( x ) -> x * 2
 
mulFirst = compose add2, mul2
addFirst = compose mul2, add2
multiple = compose mul2, compose add2, mul2
 
console.log "add2 2 #=> #{ add2 2 }"
console.log "mul2 2 #=> #{ mul2 2 }"
console.log "mulFirst 2 #=> #{ mulFirst 2 }"
console.log "addFirst 2 #=> #{ addFirst 2 }"
console.log "multiple 2 #=> #{ multiple 2 }"
 
Output:
add2 2 #=> 4
mul2 2 #=> 4
mulFirst 2 #=> 6
addFirst 2 #=> 8
multiple 2 #=> 12

Or, extending the Function prototype.

 
Function::of = (f) -> (args...) => @ f args...
 
# Example
add2 = (x) -> x + 2
mul2 = (x) -> x * 2
 
mulFirst = add2.of mul2
addFirst = mul2.of add2
multiple = mul2.of add2.of mul2
 
console.log "add2 2 #=> #{ add2 2 }"
console.log "mul2 2 #=> #{ mul2 2 }"
console.log "mulFirst 2 #=> #{ mulFirst 2 }"
console.log "addFirst 2 #=> #{ addFirst 2 }"
console.log "multiple 2 #=> #{ multiple 2 }"
 

Output is identical.

[edit] Common Lisp

compose returns a function that closes on the lexical variables f and g.

(defun compose (f g) (lambda (x) (funcall f (funcall g x))))

Example use:

>(defun compose (f g) (lambda (x) (funcall f (funcall g x))))
COMPOSE
>(let ((sin-asin (compose #'sin #'asin))))
(funcall sin-asin 0.5))
0.5

This alternate solution, more ugly and more difficult, never closes on any lexical variables. Instead, it uses runtime evaluation to insert the values of f and g into new code. This is just a different way to create a closure.

(defun compose (f g)
(eval `(lambda (x) (funcall ',f (funcall ',g x))))

In this last example, a macro is used to compose any number of single parameter functions.

CL-USER> (defmacro compose (fn-name &rest args)
(labels ((rec1 (args)
(if (= (length args) 1)
`(funcall ,@args x)
`(funcall ,(first args) ,(rec1 (rest args))))))
`(defun ,fn-name (x) ,(rec1 args))))

Because this macro expands into a defun form, the function returned by compose is in the function namespace and the use of funcall is not necessary.

CL-USER> (compose f #'ceiling #'sin #'sqrt)
F
CL-USER> (compose g #'1+ #'abs #'cos)
G
CL-USER> (compose h #'f #'g)
H
CL-USER> (values (f pi) (g pi) (h pi))
1
2.0L0
1
CL-USER> 

[edit] D

import std.stdio;
 
T delegate(S) compose(T, U, S)(in T delegate(U) f,
in U delegate(S) g) {
return s => f(g(s));
}
 
void main() {
writeln(compose((int x) => x + 15, (int x) => x ^^ 2)(10));
writeln(compose((int x) => x ^^ 2, (int x) => x + 15)(10));
}
Output:
115
625

[edit] Delphi

Anonymous methods were introduced in Delphi 2009, so next code works with Delphi 2009 and above:

program AnonCompose;
 
{$APPTYPE CONSOLE}
 
type
TFunc = reference to function(Value: Integer): Integer;
 
function Compose(F, G: TFunc): TFunc;
begin
Result:= function(Value: Integer): Integer
begin
Result:= F(G(Value));
end
end;
 
var
Func1, Func2, Func3: TFunc;
 
begin
Func1:=
function(Value: Integer): Integer
begin
Result:= Value * 2;
end;
 
Func2:=
function(Value: Integer): Integer
begin
Result:= Value * 3;
end;
 
Func3:= Compose(Func1, Func2);
 
Writeln(Func3(6)); // 36 = 6 * 3 * 2
Readln;
end.

[edit] Déjà Vu

It is already defined in the standard library as $.

compose f g:
labda:
f g

[edit] Dylan

define method compose(f,g)
method(x) f(g(x)) end
end;

[edit] Ela

It is already defined in standard prelude as (<<) operator.

let compose f g x = f (g x)

[edit] E

def compose(f, g) {
return fn x { return f(g(x)) }
}

[edit] Ela

It is already defined in standard prelude as (<<) operator.

compose f g x = f (g x)

[edit] Emacs Lisp

A lambda form can be constructed with the desired f and g inserted. The result is simply a list. A list starting with lambda is a function.

(defun compose (f g)
`(lambda (x) (,f (,g x))))
 
(let ((func (compose '1+ '1+)))
(funcall func 5))
=>
7

A similar thing can be done with a macro like the following. It differs in that the arguments should be unquoted symbols, and if they're expressions then they're evaluated on every call to the resulting lambda.

(defmacro compose (f g)
`(lambda (x) (,f (,g x))))
 
(let ((func (compose 1+ 1+)))
(funcall func 5))
=>
7

Another possibility is the cl.el lexical-let to hold f and g for use in a new lambda.

(eval-when-compile (require 'cl)) ;; for `lexical-let' macro
(defun compose (f g)
(lexical-let ((f f)
(g g))
(lambda (x)
(funcall f (funcall g x)))))
 
(let ((func (compose '1+ '1+)))
(funcall func 5))
=>
7

[edit] Erlang

-module(fn).
-export([compose/1, multicompose/2]).
 
compose(F,G) -> fun(X) -> F(G(X)) end.
 
multicompose(Fs) ->
lists:foldl(fun compose/2, fun(X) -> X end, Fs).

Using them:

1> (fn:compose(fun math:sin/1, fun math:asin/1))(0.5).
0.5
2> Sin_asin_plus1 = fn:multicompose([fun math:sin/1, fun math:asin/1, fun(X) -> X + 1 end]).
#Fun<tests.0.59446746>
82> Sin_asin_plus1(0.5).
1.5

[edit] F#

The most-used composition operator in F# is >>. It implements forward composition, i.e. f >> g is a function which calls f first and then calls g on the result.

The reverse composition operator <<, on the other hand, exactly fulfills the requirements of the compose function described in this task.

We can implement composition manually like this (F# Interactive session):

> let compose f g x = f (g x);;
 
val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b

Usage:

> let sin_asin = compose sin asin;;
 
val sin_asin : (float -> float)
 
> sin_asin 0.5;;
val it : float = 0.5

[edit] Factor

When passing functions around and creating anonymous functions, Factor uses so called quotations. There is already a word (compose) that provides composition of quotations.

( scratchpad ) [ 2 * ] [ 1 + ] compose .
[ 2 * 1 + ]
( scratchpad ) 4 [ 2 * ] [ 1 + ] compose call .
9

[edit] Fantom

 
class Compose
{
static |Obj -> Obj| compose (|Obj -> Obj| fn1, |Obj -> Obj| fn2)
{
return |Obj x -> Obj| { fn2 (fn1 (x)) }
}
 
public static Void main ()
{
double := |Int x -> Int| { 2 * x }
|Int -> Int| quad := compose(double, double)
echo ("Double 3 = ${double(3)}")
echo ("Quadruple 3 = ${quad (3)}")
}
}
 

[edit] Forth

: compose ( xt1 xt2 -- xt3 )
>r >r :noname
r> compile,
r> compile,
postpone ;
;
 
' 2* ' 1+ compose ( xt )
3 swap execute . \ 7

[edit] FunL

import math.{sin, asin}
 
def compose( f, g ) = x -> f( g(x) )
 
sin_asin = compose( sin, asin )
 
println( sin_asin(0.5) )
Output:
0.5

[edit] GAP

Composition := function(f, g)
return x -> f(g(x));
end;
 
h := Composition(x -> x+1, x -> x*x);
h(5);
# 26

[edit] Go

// Go doesn't have generics, but sometimes a type definition helps
// readability and maintainability. This example is written to
// the following function type, which uses float64.
type ffType func(float64) float64
 
// compose function requested by task
func compose(f, g ffType) ffType {
return func(x float64) float64 {
return f(g(x))
}
}

Example use:

package main
 
import "math"
import "fmt"
 
type ffType func(float64) float64
 
func compose(f, g ffType) ffType {
return func(x float64) float64 {
return f(g(x))
}
}
 
func main() {
sin_asin := compose(math.Sin, math.Asin)
fmt.Println(sin_asin(.5))
}
Output:
0.5

[edit] Groovy

Solution:

def compose = { f, g -> { x -> f(g(x)) } }

Test program:

def sq = { it * it }
def plus1 = { it + 1 }
def minus1 = { it - 1 }
 
def plus1sqd = compose(sq,plus1)
def sqminus1 = compose(minus1,sq)
def identity = compose(plus1,minus1)
def plus1sqdminus1 = compose(minus1,compose(sq,plus1))
def identity2 = compose(Math.&sin,Math.&asin)
 
println "(x+1)**2 = (0+1)**2 = " + plus1sqd(0)
println "x**2-1 = 20**2-1 = " + sqminus1(20)
println "(x+1)-1 = (12+1)-1 = " + identity(12)
println "(x+1)**2-1 = (3+1)**2-1 = " + plus1sqdminus1(3)
println "sin(asin(x)) = sin(asin(1)) = " + identity2(1)
Output:
(x+1)**2 = (0+1)**2 = 1
x**2-1 = 20**2-1 = 399
(x+1)-1 = (12+1)-1 = 12
(x+1)**2-1 = (3+1)**2-1 = 15
sin(asin(x)) = sin(asin(1)) = 1.0

[edit] Haskell

This is already defined as the . (dot) operator in Haskell.

compose f g x = f (g x)

Example use:

Prelude> let compose f g x = f (g x)
Prelude> let sin_asin = compose sin asin
Prelude> sin_asin 0.5
0.5

[edit] Icon and Unicon

Icon and Unicon don't have a lambda function or native closure; however, they do have co-expressions which are extremely versatile and can be used to achieve the same effect. The list of functions to compose can be a 'procedure', 'co-expression", or an invocable string (i.e. procedure name or unary operator). It will correctly handle compose(compose(...),..).

There are a few limitations to be aware of:

  • type(compose(f,g)) returns a co-expression not a procedure
  • this construction only handles functions of 1 argument (a closure construct is better for the general case)


The solution below can be adapted to work in Icon by reverting to the old syntax for invoking co-expressions.

   x @ f                      # use this syntax in Icon instead of the Unicon f(x) to call co-expressions
every push(fL := [],!rfL) # use this instead of reverse(fL) as the Icon reverse applies only to strings

See Icon and Unicon Introduction:Minor Differences for more information

procedure main(arglist)
h := compose(sqrt,abs)
k := compose(integer,"sqrt",ord)
m := compose("-",k)
every write(i := -2 to 2, " h=(sqrt,abs)-> ", h(i))
every write(c := !"1@Q", " k=(integer,\"sqrt\",ord)-> ", k(c))
write(c := "1"," m=(\"-\",k) -> ",m(c))
end
 
invocable all # permit string invocations
 
procedure compose(fL[]) #: compose(f1,f2,...) returns the functional composition of f1,f2,... as a co-expression
local x,f,saveSource
 
every case type(x := !fL) of {
"procedure"|"co-expression": &null # procedures and co-expressions are fine
"string" : if not proc(x,1) then runnerr(123,fL) # as are invocable strings (unary operators, and procedures)
default: runerr(123,fL)
}
 
fL := reverse(fL) # reverse and isolate from mutable side-effects
cf := create { saveSource := &source # don't forget where we came from
repeat {
x := (x@saveSource)[1] # return result and resume here
saveSource := &source # ...
every f := !fL do x := f(x) # apply the list of 'functions'
}
}
return (@cf, cf) # 'prime' the co-expr before returning it
 
end
Output:
-2 h=(sqrt,abs)-> 1.414213562373095
-1 h=(sqrt,abs)-> 1.0
0 h=(sqrt,abs)-> 0.0
1 h=(sqrt,abs)-> 1.0
2 h=(sqrt,abs)-> 1.414213562373095
1 k=(integer,"sqrt",ord)-> 7
@ k=(integer,"sqrt",ord)-> 8
Q k=(integer,"sqrt",ord)-> 9
1 m=("-",k) -> -7

[edit] J

Solution:

compose =: @

Example:

f compose g

Of course, given that @ is only one character long and is a built-in primitive, there is no need for the cover function compose. And @ is not the only composition primitive; composition is a very important concept in J. For more details, see the talk page.

Tentative new example:

f=: >.@(1&o.)@%:
g=: 1&+@|@(2&o.)
h=: f@g

Example use:

   (f, g, h) 1p1
1 2 1

Note: 1&o. is sine (mnemonic: sine is an odd circular function), 2&o. is cosine (cosine is an even circular function), %: is square root, >. is ceiling, | is absolute value and 1&+ adds 1.

[edit] Java

public class Compose {
 
// Java doesn't have function type so we define an interface
// of function objects instead
public interface Fun<A,B> {
B call(A x);
}
 
public static <A,B,C> Fun<A,C> compose(final Fun<B,C> f, final Fun<A,B> g) {
return new Fun<A,C>() {
public C call(A x) {
return f.call(g.call(x));
}
};
}
 
public static void main(String[] args) {
Fun<Double,Double> sin = new Fun<Double,Double>() {
public Double call(Double x) {
return Math.sin(x);
}
};
Fun<Double,Double> asin = new Fun<Double,Double>() {
public Double call(Double x) {
return Math.asin(x);
}
};
 
Fun<Double,Double> sin_asin = compose(sin, asin);
 
System.out.println(sin_asin.call(0.5)); // prints "0.5"
}
}
Works with: Java version 8+
import java.util.function.Function;
 
public class Compose {
public static <A,B,C> Function<A,C> compose(Function<B,C> f, Function<A,B> g) {
return x -> f.apply(g.apply(x));
}
 
public static void main(String[] args) {
Function<Double,Double> sin_asin = compose(Math::sin, Math::asin);
 
System.out.println(sin_asin.apply(0.5)); // prints "0.5"
}
}

[edit] JavaScript

function compose(f, g) {
return function(x) {
return f(g(x));
};
}

Example:

var id = compose(Math.sin, Math.asin);
print(id(0.5)); // 0.5

[edit] Joy

Composition is the default operation in Joy. The composition of two functions is the concatenation of those functions, in the order in which they are to be applied.

g f

[edit] jq

The equivalent in jq of a function with one argument is a 0-arity filter. For example, in jq, exp is the exponential function and can be evaluated like so: 0.5 | exp.

We therefore illustrate here how a function that composes two 0-arity filters can be written:

 
# apply g first and then f
def compose(f; g): g | f;
 

Example: 0.5 | compose(asin, sin)

[edit] Julia

compose(f::Function, g::Function) = x->f(g(x))
Output:
julia> compose(asin,sin)(0.5)
0.5

[edit] K

Functions are automatically curried in K if called with missing arguments.

compose: {x@y@z}

Example:

  sin_asin: compose[_sin;_asin]
sin_asin 0.5
0.5

[edit] LFE

 
(defmodule compose
(export all)
(import
(from math (sin 1) (asin 1)))
(import
(from io (format 2))))
 
(defun compose (f g)
(lambda (x)
(funcall f
(funcall g x))))
 
(defun check ()
(let* ((sin-asin (compose #'sin/1 #'asin/1))
(expected (sin (asin 0.5)))
(compose-result (funcall sin-asin 0.5)))
(format '"Expected answer: ~p~n" (list expected))
(format '"Answer with compose: ~p~n" (list compose-result))))
 

Running the code:

 
> (slurp '"compose.lfe")
#(ok compose)
> (check)
Expected answer: 0.49999999999999994
Answer with compose: 0.49999999999999994
ok
>
 

[edit] LOLCODE

LOLCODE supports first-class functions only insofar as they may be stored in variables and returned from other functions. Alas, given the current lack of support for either lambdas or closures, function composition can only be reasonably simulated with the help of a few global variables.

HAI 1.3
 
I HAS A fx, I HAS A gx
 
HOW IZ I composin YR f AN YR g
fx R f, gx R g
HOW IZ I composed YR x
FOUND YR I IZ fx YR I IZ gx YR x MKAY MKAY
IF U SAY SO
FOUND YR composed
IF U SAY SO
 
HOW IZ I incin YR num
FOUND YR SUM OF num AN 1
IF U SAY SO
 
HOW IZ I sqrin YR num
FOUND YR PRODUKT OF num AN num
IF U SAY SO
 
I HAS A incsqrin ITZ I IZ composin YR incin AN YR sqrin MKAY
VISIBLE I IZ incsqrin YR 10 MKAY BTW, prints 101
 
I HAS A sqrincin ITZ I IZ composin YR sqrin AN YR incin MKAY
VISIBLE I IZ sqrincin YR 10 MKAY BTW, prints 121
 
KTHXBYE

[edit] Lua

function compose(f, g) return function(...) return f(g(...)) end end

[edit] Mathematica

Built-in function that takes any amount of function-arguments:

Composition[f, g][x]
Composition[f, g, h, i][x]

gives back:

f[g[x]]
f[g[h[i[x]]]]

Custom function:

compose[f_, g_][x_] := f[g[x]]
compose[Sin, Cos][r]

gives back:

Sin[Cos[r]]

Composition can be done in more than 1 way:

Composition[f,g,h][x]
f@g@h@x
x//h//g//f

all give back:

f[g[h[x]]]

The built-in function has a couple of automatic simplifications:

Composition[f, Identity, g]
Composition[f, InverseFunction[f], h][x]

becomes:

f[g[x]]
h[x]

[edit] Maxima

/* built-in */
load(to_poly_solver);
 
compose_functions([sin, cos]);
/* lambda([%g0],sin(cos(%g0)))*/
 
/* An implementation, to show a use of buildq */
compose(f, g) := buildq([f, g], lambda([x], f(g(x))));

[edit] Nemerle

using System;
using System.Console;
using System.Math;
 
module Composition
{
Compose[T](f : T -> T, g : T -> T, x : T) : T
{
f(g(x))
}
 
Main() : void
{
def SinAsin = Compose(Sin, Asin, _);
WriteLine(SinAsin(0.5));
}
}

[edit] NewLISP

> (define (compose f g) (expand (lambda (x) (f (g x))) 'f 'g))
(lambda (f g) (expand (lambda (x) (f (g x))) 'f 'g))
> ((compose sin asin) 0.5)
0.5
 

[edit] Nimrod

import future
 
proc compose[A,B,C](f: A -> B, g: B -> C): A -> C = (x: A) => f(g(x))
 
proc plustwo(x: int): int = x + 2
proc minustwo(x: int): int = x - 2
 
var plusminustwo = compose(plustwo, minustwo)
echo plusminustwo(10)

[edit] Objective-C

Works with: Mac OS X version 10.6+

We restrict ourselves to functions that take and return one object.

#include <Foundation/Foundation.h>
 
typedef id (^Function)(id);
 
// a commodity for "encapsulating" double f(double)
typedef double (*func_t)(double);
Function encapsulate(func_t f) {
return ^(id x) { return @(f([x doubleValue])); };
}
 
Function compose(Function a, Function b) {
return ^(id x) { return a(b(x)); };
}
 
// functions outside...
double my_f(double x)
{
return x+1.0;
}
 
double my_g(double x)
{
return x*x;
}
 
 
int main()
{
@autoreleasepool {
 
Function f = encapsulate(my_f);
Function g = encapsulate(my_g);
 
Function composed = compose(f, g);
 
printf("g(2.0) = %lf\n", [g(@2.0) doubleValue]);
printf("f(2.0) = %lf\n", [f(@2.0) doubleValue]);
printf("f(g(2.0)) = %lf\n", [composed(@2.0) doubleValue]);
 
}
return 0;
}

[edit] Objeck

 
bundle Default {
class Test {
@f : static : (Int) ~ Int;
@g : static : (Int) ~ Int;
 
function : Main(args : String[]) ~ Nil {
compose := Composer(F(Int) ~ Int, G(Int) ~ Int);
compose(13)->PrintLine();
}
 
function : F(a : Int) ~ Int {
return a + 14;
}
 
function : G(a : Int) ~ Int {
return a + 15;
}
 
function : Compose(x : Int) ~ Int {
return @f(@g(x));
}
 
function : Composer(f : (Int) ~ Int, g : (Int) ~ Int) ~ (Int) ~ Int {
@f := f;
@g := g;
return Compose(Int) ~ Int;
}
}
}
 

prints: 42

[edit] OCaml

let compose f g x = f (g x)

Example use:

# let compose f g x = f (g x);;
val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = <fun>
# let sin_asin = compose sin asin;;
val sin_asin : float -> float = <fun>
# sin_asin 0.5;;
- : float = 0.5

[edit] Octave

function r = compose(f, g)
r = @(x) f(g(x));
endfunction
 
r = compose(@exp, @sin);
r(pi/3)

[edit] Order

Order supplies the built-in function 8compose for this purpose. However, a manual implementation might be:

#include <order/interpreter.h>
 
#define ORDER_PP_DEF_8comp ORDER_PP_FN( \
8fn(8F, 8G, 8fn(8X, 8ap(8F, 8ap(8G, 8X)))) )

Interpreter limitations mean that local variables containing functions must be called with the 8ap operator, but the functions themselves are still first-class values.

[edit] Oz

declare
fun {Compose F G}
fun {$ X}
{F {G X}}
end
end
 
SinAsin = {Compose Float.sin Float.asin}
in
{Show {SinAsin 0.5}}

[edit] PARI/GP

Works with: PARI/GP version 2.4.2 and above
compose(f, g)={
x -> f(g(x))
};
 
compose(x->sin(x),x->cos(x)(1)

Usage note: In Pari/GP 2.4.3, this can be expressed more succinctly:

compose(sin,cos)(1)

[edit] Pascal

See Delphi

[edit] Perl

sub compose {
my ($f, $g) = @_;
 
sub {
$f -> ($g -> (@_))
};
}
 
use Math::Trig;
print compose(sub {sin $_[0]}, \&asin)->(0.5), "\n";

[edit] Perl 6

Works with: rakudo

We'll define an infix compose operator from , U+2218 RING OPERATOR.

sub infix:<> (&f, &g --> Block) {
-> |args { f g |args }
}

Example of composing a routine, an operator, and a lambda:

sub triple($n) { 3 * $n }
my &f = &triple&prefix:<->{ $^n + 2 };
say &f(5); # Prints "-21".

[edit] PHP

Works with: PHP version 5.3+
<?php
function compose($f, $g) {
return function($x) use ($f, $g) { return $f($g($x)); };
}
 
$trim_strlen = compose('strlen', 'trim');
echo $result = $trim_strlen(' Test '), "\n"; // prints 4
?>
Works with: PHP version pre-5.3 and 5.3+

works with regular functions as well as functions created by create_function()

<?php
function compose($f, $g) {
return create_function('$x', 'return '.var_export($f,true).'('.var_export($g,true).'($x));');
}
 
$trim_strlen = compose('strlen', 'trim');
echo $result = $trim_strlen(' Test '), "\n"; // prints 4
?>

[edit] PicoLisp

(de compose (F G)
(curry (F G) (X)
(F (G X)) ) )
(def 'a (compose inc dec))
(def 'b (compose 'inc 'dec))
(def 'c (compose '((A) (inc A)) '((B) (dec B))))
: (a 7)
-> 7
 
: (b 7)
-> 7
 
: (c 7)
-> 7

[edit] PostScript

PostScript functions typically pops operand stack for argument, so calling two functions one after another naturally makes a compound function, and making a compound requires just defing them:
/square { dup mul } def
/plus1 { 1 add } def
/sqPlus1{ square plus1 } def
 
% if the task really demands we make a function called "compose", well
/compose { def } def  % so now we can say:
/sqPlus1 { square plus1 } compose

[edit] Prolog

Works with SWI-Prolog and module lambda, written by Ulrich Neumerkel found there http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl

:- use_module(lambda).
 
compose(F,G, FG) :-
FG = \X^Z^(call(G,X,Y), call(F,Y,Z)).
 
Output:
 ?- compose(sin, asin, F), call(F, 0.5, Y).
F = \_G4586^_G4589^ (call(asin,_G4586,_G4597),call(sin,_G4597,_G4589)),
Y = 0.5.

[edit] PureBasic

;Declare how our function looks like
Prototype.i Func(Arg.i)
 
; Make a procedure that composes any functions of type "Func"
Procedure Compose(*a.Func,*b.Func, x)
ProcedureReturn *a(*b(x))
EndProcedure
 
; Just a procedure fitting "Func"
Procedure f(n)
ProcedureReturn 2*n
EndProcedure
 
; Yet another procedure fitting "Func"
Procedure g(n)
ProcedureReturn n+1
EndProcedure
 
;- Test it
X=Random(100)
Title$="With x="+Str(x)
Body$="Compose(f(),g(), x) ="+Str(Compose(@f(),@g(),X))
MessageRequester(Title$,Body$)

[edit] Purity

 
data compose = f => g => $f . $g
 

[edit] Python

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

Example use:

>>> compose = lambda f, g: lambda x: f( g(x) )
>>> from math import sin, asin
>>> sin_asin = compose(sin, asin)
>>> sin_asin(0.5)
0.5
>>>

[edit] Qi

Qi supports partial applications, but only when calling a function with one argument.

 
(define compose
F G -> (/. X
(F (G X))))
 
((compose (+ 1) (+ 2)) 3) \ (Outputs 6) \
 

Alternatively, it can be done like this:

 
(define compose F G X -> (F (G X)))
 
(((compose (+ 1)) (+ 2)) 3) \ (Outputs 6) \
 

[edit] R

compose <- function(f,g) function(x) { f(g(x)) }
r <- compose(sin, cos)
print(r(.5))

[edit] Racket

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

Also available as a compose1 builtin, and a more general compose where one function can produce multiple arguments that are sent the the next function in the chain. (Note however that this is rarely desired.)

[edit] REBOL

rebol [
Title: "Functional Composition"
Author: oofoe
Date: 2009-12-06
URL: http://rosettacode.org/wiki/Functional_Composition
]

 
; "compose" means something else in REBOL, therefore I use a 'compose-functions name.
 
compose-functions: func [
{compose the given functions F and G}
f [any-function!]
g [any-function!]
] [
func [x] compose [(:f) (:g) x]
]

Functions "foo" and "bar" are used to prove that composition actually took place by attaching their signatures to the result.

foo: func [x] [reform ["foo:" x]]
bar: func [x] [reform ["bar:" x]]
 
foo-bar: compose-functions :foo :bar
print ["Composition of foo and bar:" mold foo-bar "test"]
 
sin-asin: compose-functions :sine :arcsine
print [crlf "Composition of sine and arcsine:" sin-asin 0.5]
Output:
Composition of foo and bar: "foo: bar: test"

Composition of sine and arcsine: 0.5

[edit] REXX

compose: procedure;  parse arg f,g,x;  interpret 'return' f"(" g'(' x "))"
exit /*control never gets here, but this was added just in case.*/

[edit] Ruby

This compose method gets passed two Method objects or Proc objects

def compose(f,g)
lambda {|x| f[g[x]]}
end
s = compose(Math.method(:sin), Math.method(:cos))
p s[0.5] # => 0.769196354841008
 
# verify
p Math.sin(Math.cos(0.5)) # => 0.769196354841008

[edit] Scala

def compose[A](f: A => A, g: A => A) = { x: A => f(g(x)) }
 
def add1(x: Int) = x+1
val add2 = compose(add1, add1)

We can achieve a more natural style by creating a container class for composable functions, which provides the compose method 'o':

class Composable[A](f: A => A) {
def o (g: A => A) = compose(f, g)
}
 
implicit def toComposable[A](f: A => A) = new Composable(f)
 
val add3 = (add1 _) o add2
> (add2 o add3)(37)
res0: Int = 42

[edit] Scheme

(define (compose f g) (lambda (x) (f (g x))))
 
;; or:
 
(define ((compose f g) x) (f (g x)))
 

Example:

 
(display ((compose sin asin) 0.5))
(newline)
Output:
0.5

[edit] Sidef

func compose(f, g) {
func(x) { f(g(x)) }.copy;
};
var fg = compose(func(x){Math.sin(x)}, func(x){Math.cos(x)});
say fg(0.5); # => 0.7691963548410084218525147580510688880995

[edit] Slate

Function (method) composition is standard:

[| :x | x + 1] ** [| :x | x squared] applyTo: {3}

[edit] Smalltalk

| composer fg |
composer := [ :f :g | [ :x | f value: (g value: x) ] ].
fg := composer value: [ :x | x + 1 ]
value: [ :x | x * x ].
 
(fg value:3) displayNl.

[edit] Standard ML

This is already defined as the o operator in Standard ML.

fun compose (f, g) x = f (g x)

Example use:

- fun compose (f, g) x = f (g x);
val compose = fn : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b
- val sin_asin = compose (Math.sin, Math.asin);
val sin_asin = fn : real -> real
- sin_asin 0.5;
val it = 0.5 : real

[edit] Swift

func compose<A,B,C>(f: (B) -> C, g: (A) -> B) -> (A) -> C {
return { f(g($0)) }
}
 
let sin_asin = compose(sin, asin)
println(sin_asin(0.5))
Output:
0.5

[edit] Tcl

Works with: Tcl version 8.5

This creates a compose procedure that returns an anonymous function term that should be expanded as part of application to its argument.

package require Tcl 8.5
namespace path {::tcl::mathfunc}
 
proc compose {f g} {
list apply [list {f g x} {{*}$f [{*}$g $x]}] $f $g]
}
 
set sin_asin [compose sin asin]
{*}$sin_asin 0.5 ;# ==> 0.5
{*}[compose abs int] -3.14 ;# ==> 3

[edit] UNIX Shell

Each function takes its argument from standard input, and puts its result to standard output. Then the composition of f and g is a shell pipeline, c() { g | f; }.

Works with: Bourne Shell
compose() {
eval "$1() { $3 | $2; }"
}
 
downvowel() { tr AEIOU aeiou; }
upcase() { tr a-z A-Z; }
compose c downvowel upcase
echo 'Cozy lummox gives smart squid who asks for job pen.' | c
# => CoZY LuMMoX GiVeS SMaRT SQuiD WHo aSKS FoR JoB PeN.
Works with: Bourne Again SHell

This solution uses no external tools, just Bash itself.

 
#compose a new function consisting of the application of 2 unary functions
 
compose () { f="$1"; g="$2"; x="$3"; "$f" "$("$g" "$x")";}
 
 
chartolowervowel()
# Usage: chartolowervowel "A" --> "a"
 
#Based on a to_upper script in Chris F. A. Johnson's book Pro Bash Programming Ch7. String Manipulation
#(with minor tweaks to use local variables and return the value of the converted character
#http://cfajohnson.com/books/cfajohnson/pbp/
#highly recommended I have a copy and have bought another for a friend
{
 
local LWR="";
 
case $1 in
A*) _LWR=a ;;
# B*) _LWR=b ;;
# C*) _LWR=c ;;
# D*) _LWR=d ;;
E*) _LWR=e ;;
# F*) _LWR=f ;;
# G*) _LWR=g ;;
# H*) _LWR=h ;;
I*) _LWR=i ;;
# J*) _LWR=j ;;
# K*) _LWR=k ;;
# L*) _LWR=L ;;
# M*) _LWR=m ;;
# N*) _LWR=n ;;
O*) _LWR=o ;;
# P*) _LWR=p ;;
# Q*) _LWR=q ;;
# R*) _LWR=r ;;
# S*) _LWR=s ;;
# T*) _LWR=t ;;
U*) _LWR=u ;;
# V*) _LWR=v ;;
# W*) _LWR=w ;;
# X*) _LWR=x ;;
# Y*) _LWR=y ;;
# Z*) _LWR=z ;;
*) _LWR=${1%${1#?}} ;;
esac;
echo "$_LWR";
}
 
strdownvowel()
# Usage: strdownvowel "STRING" --> "STRiNG"
 
#Based on an upword script in Chris F. A. Johnson's book Pro Bash Programming Ch7. String Manipulation
#(with minor tweaks to use local variables and return the value of the converted string
#http://cfajohnson.com/books/cfajohnson/pbp/
#highly recommended I have a copy and have bought another for a friend
 
{
local _DWNWORD=""
local word="$1"
while [ -n "$word" ] ## loop until nothing is left in $word
do
chartolowervowel "$word" >> /dev/null
_DWNWORD=$_DWNWORD$_LWR
word=${word#?} ## remove the first character from $word
 
done
Echo "$_DWNWORD"
}
 
 
 
 
chartoupper()
# Usage: chartoupper "s" --> "S"
 
#From Chris F. A. Johnson's book Pro Bash Programming Ch7. String Manipulation
#(with minor tweaks to use local variables and return the value of the converted character
#http://cfajohnson.com/books/cfajohnson/pbp/
#highly recommended I have a copy and have bought another for a friend
{
local UPR="";
 
case $1 in
a*) _UPR=A ;;
b*) _UPR=B ;;
c*) _UPR=C ;;
d*) _UPR=D ;;
e*) _UPR=E ;;
f*) _UPR=F ;;
g*) _UPR=G ;;
h*) _UPR=H ;;
i*) _UPR=I ;;
j*) _UPR=J ;;
k*) _UPR=K ;;
l*) _UPR=L ;;
m*) _UPR=M ;;
n*) _UPR=N ;;
o*) _UPR=O ;;
p*) _UPR=P ;;
q*) _UPR=Q ;;
r*) _UPR=R ;;
s*) _UPR=S ;;
t*) _UPR=T ;;
u*) _UPR=U ;;
v*) _UPR=V ;;
w*) _UPR=W ;;
x*) _UPR=X ;;
y*) _UPR=Y ;;
z*) _UPR=Z ;;
*) _UPR=${1%${1#?}} ;;
esac;
echo "$_UPR";
}
 
strupcase()
# Usage: strupcase "string" --> "STRING"
 
#Based on an upword script in Chris F. A. Johnson's book Pro Bash Programming Ch7. String Manipulation
#(with minor tweaks to use local variables and return the value of the converted string
#http://cfajohnson.com/books/cfajohnson/pbp/
#highly recommended I have a copy and have bought another for a friend
 
{
local _UPWORD=""
local word="$1"
while [ -n "$word" ] ## loop until nothing is left in $word
do
chartoupper "$word" >> /dev/null
_UPWORD=$_UPWORD$_UPR
word=${word#?} ## remove the first character from $word
 
done
Echo "$_UPWORD"
}
 
compose strdownvowel strupcase "Cozy lummox gives smart squid who asks for job pen."
# --> CoZY LuMMoX GiVeS SMaRT SQuiD WHo aSKS FoR JoB PeN.


[edit] es

With shell pipelines:

fn compose f g {
result @ {$g | $f}
}
 
fn downvowel {tr AEIOU aeiou}
fn upcase {tr a-z A-Z}
fn-c = <={compose $fn-downvowel $fn-upcase}
echo 'Cozy lummox gives smart squid who asks for job pen.' | c
# => CoZY LuMMoX GiVeS SMaRT SQuiD WHo aSKS FoR JoB PeN.

With function arguments:

fn compose f g {
result @ x {result <={$f <={$g $x}}}
}
 
fn downvowel x {result `` '' {tr AEIOU aeiou <<< $x}}
fn upcase x {result `` '' {tr a-z A-Z <<< $x}}
fn-c = <={compose $fn-downvowel $fn-upcase}
echo <={c 'Cozy lummox gives smart squid who asks for job pen.'}
# => CoZY LuMMoX GiVeS SMaRT SQuiD WHo aSKS FoR JoB PeN.

[edit] Unlambda

``s`ksk

[edit] Ursala

Functional composition is a built in operation expressible as f+g for functions f and g, hence hardly worth defining. However, it could be defined without using the operator like this.

compose("f","g") "x" = "f" "g" "x"

test program:

#import nat
#cast %n
 
test = compose(successor,double) 3
Output:
7

[edit] VBScript

I'm not convinced that this is really a 'closure'. It looks to me more like a cute trick with Eval().

Implementation

 
option explicit
class closure
 
private composition
 
sub compose( f1, f2 )
composition = f2 & "(" & f1 & "(p1))"
end sub
 
public default function apply( p1 )
apply = eval( composition )
end function
 
public property get formula
formula = composition
end property
 
end class
 

Invocation

 
dim c
set c = new closure
 
c.compose "ucase", "lcase"
wscript.echo c.formula
wscript.echo c("dog")
 
c.compose "log", "exp"
wscript.echo c.formula
wscript.echo c(12.3)
 
function inc( n )
inc = n + 1
end function
 
c.compose "inc", "inc"
wscript.echo c.formula
wscript.echo c(12.3)
 
function twice( n )
twice = n * 2
end function
 
c.compose "twice", "inc"
wscript.echo c.formula
wscript.echo c(12.3)
 
Output:
lcase(ucase(p1))
dog
exp(log(p1))
12.3
inc(inc(p1))
14.3
inc(twice(p1))
25.6

[edit] Wortel

The @ operator applied to a array literal will compose the functions in the array and ^ with a group literal will do the same, but also quotes operators.

! @[f g] x ; f(g(x))
! ^(f g) x ; f(g(x))

Defining the compose function

@var compose &[f g] &x !f!g x

[edit] zkl

Utils.Helpers.fcomp('+(1),'*(2))(5) //-->11
Which is implemented with a closure (.fp), T is a read only list and L(x).apply(L(g,f)) --> L(g(f(x)):
fcn fcomp(f,g,h,etc){
fcn(x,hgf){ T(x).apply(hgf)[0] }.fp1(vm.arglist.reverse()); }
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox