Function composition: Difference between revisions

{{task|Higher-order functions}}

 

Reference: [[wp:Function composition (computer science)|Function composition]]

 

Hint: In some languages, implementing <span style="font-family:serif">compose</span> correctly requires creating a [[wp:Closure (computer science)|closure]].

 

=={{header|ActionScript}}==

ActionScript supports closures, making function composition very straightforward.

return function(x:Object) {return f(g(x));};

}

function test() {

trace(compose(Math.atan, Math.tan)(0.5));

 

=={{header|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):

type Argument is private;

package Functions is

private

type Func is array (Positive range <>) of Primitive_Operation;

Here is an implementation;

function "*" (Left : Func; Right : Argument) return Argument is

Result : Argument := Right;

return (Left, Right);

end "*";

The following is an example of use:

with Ada.Text_IO; use Ada.Text_IO;

with Functions;

begin

Put_Line (Float'Image (Sin_Arcsin * 0.5));

<pre>

5.00000E-01

</pre>

 

=={{header|Aikido}}==

import math

 

println (func(0.5)) // 0.5

 

 

=={{header|ALGOL 68}}==

violates standard '''ALGOL 68''''s scoping rules. [[ALGOL 68G]] warns about this during

parsing, and then rejects during runtime.

 

# As a procedure for real to real functions #

# Example use: #

F sin arc sin = compose(sin, arc sin);

<pre>

+.500000000000000e +0 +.500000000000000e +0

{{works with|ALGOL 68|Standard - Jan 1975 Boston SC allowed Partial Parametrization. }}

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

 

# As a procedure for real to real functions #

# Example use: #

F sin arc sin = compose(sin, arc sin);

 

=={{header|Argile}}==

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

{{works with|Argile|1.0.0}}

 

let my_asin = new Function (.:<any,real x>:. -> real {asin x})

f.func = func

f.data = data

 

 

=={{header|AutoHotkey}}==

contributed by Laszlo on the ahk [http://www.autohotkey.com/forum/post-276379.html#276379 forum]

 

compose(f,g,x) { ; function composition

Return %f%(%g%(x))

 

=={{header|Brat}}==

#Test

double = { x | x * 2 }

b = compose(->double ->add1)

 

=={{header|C}}==

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

 

/* generic interface for functors from double to double */

 

return 0;

 

=={{header|C++}}==

#include <cmath>

#include <iostream>

 

return 0;

 

 

=={{header|Clojure}}==

 

A manual implementation could look like this:

(fn [x]

(f (g x))))

; Example

(def inc2 (compose inc inc))

 

=={{header|Common Lisp}}==

<code>compose</code> returns a function that closes on the lexical variables f and g.

 

Example use:

COMPOSE

(funcall sin-asin 0.5))

 

 

----

 

 

=={{header|D}}==

 

 

 

=={{header|Delphi}}==

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

 

 

{$APPTYPE CONSOLE}

type

TFunc = reference to function(Value: Integer): Integer;

 

function Compose(F, G: TFunc): TFunc;

Writeln(Func3(6)); // 36 = 6 * 3 * 2

Readln;

 

=={{header|Dylan}}==

 

method(x) f(g(x)) end

 

=={{header|E}}==

 

return fn x { return f(g(x)) }

 

=={{header|Erlang}}==

 

compose(F,G) -> fun(X) -> F(G(X)) end.

 

multicompose(Fs) ->

 

Using them:

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).

 

{{omit from|Euphoria}}

 

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

 

Usage:

 

val sin_asin : (float -> float)

 

> sin_asin 0.5;;

 

=={{header|Factor}}==

[ 2 * 1 + ]

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

 

=={{header|Fantom}}==

class Compose

{

}

}

 

=={{header|Forth}}==

>r >r :noname

r> compile,

 

' 2* ' 1+ compose ( xt )

 

=={{header|GAP}}==

return x -> f(g(x));

end;

h := Composition(x -> x+1, x -> x*x);

h(5);

 

=={{header|Go}}==

// readability and maintainability. This example is written to

// the following function type, which uses float64.

return f(g(x))

}

Example use:

 

import "math"

sin_asin := compose(math.Sin, math.Asin)

fmt.Println(sin_asin(.5))

<pre>

0.5

 

=={{header|Groovy}}==

Test program:

 

 

 

=={{header|Haskell}}==

Example use:

Prelude> let sin_asin = compose sin asin

Prelude> sin_asin 0.5

 

=={{header|Icon}} and {{header|Unicon}}==

 

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

See [[Icon%2BUnicon/Intro#Minor_Differences|Icon and Unicon Introduction:Minor Differences]] for more information

 

h := compose(sqrt,abs)

k := compose(integer,"sqrt",ord)

return (@cf, cf) # 'prime' the co-expr before returning it

 

 

<pre>-2 h=(sqrt,abs)-> 1.414213562373095

-1 h=(sqrt,abs)-> 1.0

 

'''Solution''':

 

'''Example''':

 

 

=={{header|Java}}==

 

// Java doesn't have function type so we define an interface

System.out.println(sin_asin.call(0.5)); // prints "0.5"

}

 

=={{header|JavaScript}}==

 

 

=={{header|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.

 

=={{header|K}}==

'''Example:'''

sin_asin 0.5

 

=={{header|Lua}}==

 

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

gives back:

Custom function:

gives back:

Composition can be done in more than 1 way:

f@g@h@x

all give back:

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

becomes:

 

=={{header|Nemerle}}==

using System.Console;

using System.Math;

WriteLine(SinAsin(0.5));

}

 

=={{header|NewLISP}}==

 

(lambda (f g) (expand (lambda (x) (f (g x))) 'f 'g))

> ((compose sin asin) 0.5)

0.5

 

 

 

 

 

 

}

}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

{{works with|Mac OS X|10.6+}}

 

 

typedef id (^Function)(id);

typedef double (*func_t)(double);

Function encapsulate(func_t f) {

}

 

Function compose(Function a, Function b) {

}

 

int main()

{

 

 

return 0;

 

=={{header|OCaml}}==

Example use:

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

 

=={{header|Octave}}==

 

r = @(x) f(g(x));

endfunction

 

r = compose(@exp, @sin);

 

=={{header|Oz}}==

fun {Compose F G}

fun {$ X}

SinAsin = {Compose Float.sin Float.asin}

in

 

=={{header|PARI/GP}}==

{{works with|PARI/GP|2.4.2 and above}}

x -> f(g(x))

};

 

 

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

 

=={{header|Perl}}==

my ($f, $g) = @_;

 

 

use Math::Trig;

 

 

 

 

=={{header|PHP}}==

function compose($f, $g) {

}

 

$trim_strlen = compose('strlen', 'trim');

echo $result = $trim_strlen(' Test '), "\n"; // prints 4

function compose($f, $g) {

}

 

echo $result = $trim_strlen(' Test '), "\n"; // prints 4

 

=={{header|PicoLisp}}==

(curry (F G) (X)

(def 'b (compose 'inc 'dec))

-> 7

 

 

: (c 7)

 

=={{header|PostScript}}==

/plus1 { 1 add } def

 

 

=={{header|Prolog}}==

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

 

compose(F,G, FG) :-

FG = \X^Z^(call(G,X,Y), call(F,Y,Z)).

<pre> ?- compose(sin, asin, F), call(F, 0.5, Y).

F = \_G4586^_G4589^ (call(asin,_G4586,_G4597),call(sin,_G4597,_G4589)),

 

=={{header|PureBasic}}==

Prototype.i Func(Arg.i)

 

Title$="With x="+Str(x)

Body$="Compose(f(),g(), x) ="+Str(Compose(@f(),@g(),X))

 

=={{header|Purity}}==

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

 

=={{header|Python}}==

Example use:

>>> from math import sin, asin

>>> sin_asin = compose(sin, asin)

>>> sin_asin(0.5)

0.5

 

=={{header|R}}==

r <- compose(sin, cos)

 

=={{header|REBOL}}==

Title: "Functional Composition"

URL: http://rosettacode.org/wiki/Functional_Composition

]

] [

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.

 

bar: func [x] [reform ["bar:" x]]

 

 

sin-asin: compose-functions :sine :arcsine

 

<pre>Composition of foo and bar: "foo: bar: test"

 

 

=={{header|REXX}}==

 

=={{header|Ruby}}==

end

 

# verify

 

 

=={{header|Scala}}==

 

def add1(x: Int) = x+1

 

We can achieve a more natural style by creating a container class for composable functions, which provides

the compose method 'o':

 

def o (g: A => A) = compose(f, g)

}

implicit def toComposable[A](f: A => A) = new Composable(f)

 

 

<pre>

 

=={{header|Scheme}}==

 

;; or:

 

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

Example:

(display ((compose sin asin) 0.5))

 

=={{header|Slate}}==

Function (method) composition is standard:

 

=={{header|Smalltalk}}==

composer := [ :f :g | [ :x | f value: (g value: x) ] ].

fg := composer value: [ :x | x + 1 ]

value: [ :x | x * x ].

 

 

=={{header|Standard ML}}==

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

Example use:

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;

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

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

namespace path {::tcl::mathfunc}

 

set sin_asin [compose sin asin]

{*}$sin_asin 0.5 ;# ==> 0.5

 

=={{header|Unlambda}}==

for functions f and g, hence hardly worth defining. However, it could

be defined without using the operator like this.

test program:

#cast %n

 

<pre>7</pre>

 

 

'''Implementation'''

option explicit

class closure

end class

 

'''Invocation'''

dim c

set c = new closure

wscript.echo c.formula

wscript.echo c(12.3)

 

<pre>

lcase(ucase(p1))

25.6

</pre>