Function composition: Difference between revisions

{{trans|Python}}

 

V sin_asin = compose(x -> sin(x), x -> asin(x))

 

{{out}}

=={{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));

{{out}}

<pre>

 

=={{header|Agda}}==

→ (B → C)

→ (A → B)

→ A → C

 

=={{header|Aikido}}==

import math

 

println (func(0.5)) // 0.5

 

 

=={{header|Aime}}==

{

($0)(($1)($2));

 

0;

{{Out}}

<pre>6400</pre>

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

{{out}}

<pre>

{{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|AntLang}}==

compose1: {f: x; g: y; {f[g[x]]}}

/Extra: apply to multiple arguments

 

=={{header|AppleScript}}==

-- a script object with a call(x) handler.

on compose(f, g)

 

compose(sqrt, twice)'s call(32)

 

A limitation of AppleScript's handlers (functions), which can be seen in the example above, is that they are not in themselves composable first class objects, and have to be lifted into script objects before they can be composed or passed as arguments.

We can generalise this lifting with an '''mReturn''' or '''mInject''' function, which injects a handler into a script for us. This allows use to write higher-order composition and pipelining functions which take a pair (or sequence of) ordinary handlers as arguments, and return a first class script object. (We can also use mReturn to equip AppleScript with '''map''' and '''fold''' functions which take a list and an ordinary handler as arguments).

 

 

on root(x)

x ^ 0.5

end half

 

on run

--> 1.61803398875

end run

 

 

 

-- foldr :: (a -> b -> a) -> a -> [b] -> a

end script

end if

{{Out}}

<pre>1.61803398875</pre>

 

=={{header|Applesoft BASIC}}==

20 DEF FN A(P) = ATN(P/SQR(-P*P+1))

30 G$ = "FN A"

220 PRINT D$"OPEN"FI$M$D$"WRITE"FI$

230 PRINT "CALL-998:CALL-958:R="E$":CONT"

 

=={{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|Arturo}}==

 

return function [x].import:[f,g][

call f @[call g @[x]]

splitupper: compose 'split 'upper

 

 

{{out}}

 

<pre>D O N E</pre>

 

=={{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|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

DEF FNsqr(a) = SQR(a)

DEF FNabs(a) = ABS(a)

\ CHR$&A4 + "(&" + STR$~(p%+4) + ")(x))"

DIM p% LEN(f$) + 4 : $(p%+4) = f$ : !p% = p%+4

{{out}}

<pre>

 

=={{header|Bori}}==

double asin (double v) { return Math.asin(v); }

Var compose (Func f, Func g, double d) { return f(g(d)); }

double d = compose(sin, asin, 0.5);

label1.setText(d.toString(9));

{{out}} on Android phone:

 

=={{header|Bracmat}}==

Function composition is illustrated with a conversion from Fahrenheit to Celsius in two steps, followed by a conversion of the resulting rational number to a floating point expression. This shows that the returned value from the <code>compose</code> function indeed is a function and can be used as an argument to another call to <code>compose</code>.

 

= f g

. !arg:(?f.?g)&'(.($f)$(($g)$!arg))

& FahrenheitToCelsiusExample$0

& FahrenheitToCelsiusExample$100

 

<pre>0 °F in °C = -1,78*10E1

 

=={{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 sharp|C#}}==

class Program

{

}

}

 

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

#include <cmath>

#include <iostream>

 

return 0;

 

{{works with|C++11}} composing <code>std::function</code>

#include <functional>

#include <cmath>

std::function<double(double)> g = asin;

std::cout << compose(f, g)(0.5) << std::endl;

 

{{Works with|C++14}}

This much simpler version uses <code>decltype(auto)</code>.

#include <cmath>

int main() {

std::cout << compose(sin, asin)(0.5) << "\n";

 

#include <cmath>

#include <ext/functional>

int main() {

std::cout << __gnu_cxx::compose1(std::ptr_fun(::sin), std::ptr_fun(::asin))(0.5) << std::endl;

 

 

=={{header|Clojure}}==

 

A manual implementation could look like this:

(fn [x]

(f (g x))))

; Example

(def inc2 (compose inc inc))

 

=={{header|CoffeeScript}}==

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

 

console.log "addFirst 2 #=> #{ addFirst 2 }"

console.log "multiple 2 #=> #{ multiple 2 }"

 

{{out}}

Or, extending the <code>Function</code> prototype.

 

Function::of = (f) -> (args...) => @ f args...

 

console.log "addFirst 2 #=> #{ addFirst 2 }"

console.log "multiple 2 #=> #{ multiple 2 }"

 

Output is identical.

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

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

 

Example use:

COMPOSE

>(let ((sin-asin (compose #'sin #'asin)))

(funcall sin-asin 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.

 

 

----

 

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

(labels ((rec1 (args)

(if (= (length args) 1)

`(funcall ,@args x)

`(funcall ,(first args) ,(rec1 (rest 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.

<pre>CL-USER> (compose f #'ceiling #'sin #'sqrt)

=={{header|Crystal}}==

Crystal requires using closures for function composition. Since the only type the compiler can't infer for <code>compose</code> is the type of <code>x</code>, the type of the first argument to <code>f</code> has to be specified as the generic type <code>T</code>.

 

def compose(f : Proc(T, _), g : Proc(_, _)) forall T

end

 

The types for <code>f</code>'s output, <code>g</code>'s input and output, and the result of <code>compose</code> can all be inferred, but could be specified verbosely with <code>def compose(f : Proc(T, U), g : Proc(U, V)) : Proc(T, V) forall T, U, V</code>

 

=={{header|D}}==

 

T delegate(S) compose(T, U, S)(in T delegate(U) f,

writeln(compose((int x) => x + 15, (int x) => x ^^ 2)(10));

writeln(compose((int x) => x ^^ 2, (int x) => x + 15)(10));

{{out}}

<pre>115

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

 

 

{$APPTYPE CONSOLE}

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

Readln;

 

=={{header|Dylan}}==

compose[https://opendylan.org/books/drm/Functional_Operations#compose] is already part of the language standard, with a more complete definition than this.

 

define method compose(f,g)

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

end;

 

=={{header|Déjà Vu}}==

It is already defined in the standard library as <code>$</code>.

 

labda:

 

=={{header|E}}==

 

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

 

=={{header|EchoLisp}}==

;; By decreasing order of performance

;; 1) user definition : lambda and closure

(define (sincos x) (sin (cos x)))

sincos → (λ (_x) (⭕️ #sin (#cos _x)))

{{out}}

((ucompose sin cos) 3) → -0.8360218615377305

((compose sin cos) 3) → -0.8360218615377305

(sincos 3) → -0.8360218615377305

 

=={{header|Ela}}==

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

 

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

 

 

=={{header|Elena}}==

extension op : Func1

public program()

{

console.printLine(fg(3))

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def compose(f, g), do: fn(x) -> f.(g.(x)) end

 

IO.puts RC.multicompose([&:math.sin/1, &:math.asin/1, fn x->1/x end]).(0.5)

 

{{out}}

 

=={{header|Emacs Lisp}}==

 

 

(let ((func (compose '1+ '1+)))

 

 

`(lambda (x) (,f (,g x))))

 

 

 

 

 

=={{header|Erlang}}==

-export([compose/2, multicompose/1]).

 

 

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}}==

To compose quotations (anonymous functions), <code>compose</code> may be used:

 

[ 2 * 1 + ]

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

 

=={{header|Fantom}}==

class Compose

{

}

}

 

=={{header|Forth}}==

>r >r :noname

r> compile,

 

' 2* ' 1+ compose ( xt )

 

=={{header|Fortran}}==

Modern Fortran standard has (limited) kind of higher-order functions (as result, argument, and with one level of nested functions) and optional arguments, and this enables to compose the following function (it is impure because Fortran ''has no closures''). For simple cases function calls may be just nested to achieve the effect of function composition, because in fortran nested calls f(g(d(x))) generate a hierarchic set of function calls and the result of each function is transmitted to its calling function in a standard way for all functions.

 

module functions_module

implicit none

write(*,*) "run compose:", compose(0.5)

end program test_compose

 

=={{header|Fortress}}==

In this version, we allow any type of function to be used by defining our own types in the function definition and using those types to define how the composed function should behave. This version operates very similarly to the way that the COMPOSE operator, explained below, operates.

 

compose[\A, B, C\](f:A->B, g:B->C, i:Any): A->C = do

f(g(i))

 

composed(i:RR64): RR64 = compose(sin, cos, i)

 

Alternatively, you could explicitly define each type for improved type safety.

 

Due to the fact that alt_compose() is built around the idea that it is being used to compose two trigonometric functions, these will return identical functions. However, if you were to pass alt_composed() any other type of function, the interpreter would throw an error.

alt_compose(f:Number->RR64, g:Number->RR64, i:RR64): ()->RR64 = do

f(g(i))

 

alt_composed(i:RR64): RR64 = compose(sin, cos, i)

 

2. You can use the COMPOSE operator (or CIRC or RING). Because COMPOSE returns an anonymous function, it is necessary to wrap it in parentheses if you want to be able to use it in this manner.

 

opr_composed(i:Number): Number->RR64 = (sin COMPOSE cos)(i)

 

Should you need to, you could also mix both methods by overloading the COMPOSE operator.

=={{header|FreeBASIC}}==

Illustrating with functions that take and return integers.

g as function(as integer) as integer,_

n as integer ) as integer

return f(g(n))

If you have functions named, say, foo and bar you would call compose with

<pre>compose( @foo, @bar, n )</pre> for some integer n.

 

=={{header|FunL}}==

 

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

sin_asin = compose( sin, asin )

 

 

{{out}}

=={{header|Fōrmulæ}}==

 

 

 

 

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

{{out}}

<pre>

=={{header|Groovy}}==

Test program:

final plus1 = { it + 1 }

 

 

assert plus1_then_times2(3) == 8

 

=={{header|Haskell}}==

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

 

Prelude> sin_asin 0.5

 

Ways to use directly:

 

 

Implementing compose function from scratch:

Example use:

Prelude> let sin_asin = compose sin asin

Prelude> sin_asin 0.5

 

 

Right to left composition of a list of functions could be defined as ''flip (foldr id)'':

 

composeList = flip (foldr id)

 

main :: IO ()

{{Out}}

<pre>1.618033988749895</pre>

 

=={{header|Hy}}==

(fn [x]

 

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

 

 

{{out}}

 

'''Solution''':

 

'''Example''':

 

Of course, given that <code>@</code> is only one character long and is a built-in primitive, there is no need for the cover function <code>compose</code>. And <code>@</code> is not the only composition primitive; composition is a very important concept in J. For more details, see the [[Talk:Functional Composition#J|talk page]].

Tentative new example:

 

g=: 1&+@|@(2&o.)

 

Example use:

 

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

 

=={{header|Java}}==

 

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

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

}

 

===Java 8===

Java 8's <code>Function</code> interface already has a <code>.compose()</code> default method:

{{works with|Java|8+}}

 

public class Compose {

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

}

 

Implementing it yourself as a static method:

{{works with|Java|8+}}

 

public class Compose {

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

}

 

=={{header|JavaScript}}==

===ES5===

====Simple composition of two functions====

return function(x) {

return f(g(x));

};

Example:

 

 

# With a fold / reduction (see http://rosettacode.org/wiki/Catamorphism). The fold is arguably simpler to write and reason about, though not quite as fast to execute.

 

'use strict';

 

});

})();

 

{{Out}}

 

====Simple composition of two functions====

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

or

Example:

 

 

====Multiple composition====

 

const compose = (...fs) =>

);

 

const

sqrt = Math.sqrt,

 

return compose(half, succ, sqrt)(5);

// --> 1.618033988749895

{{Out}}

<pre>1.618033988749895</pre>

=={{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|jq}}==

 

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)

 

{{works with|Julia|0.6}}

'''Built-in''':

 

'''Alternative''':

 

=={{header|K}}==

The K syntax for APL tacit (point free) function composition is the dyadic form of apostrophe ('), here is a cover function

 

An equivalent explicit definition would be

 

'''Example:'''

sin_asin 0.5

 

=={{header|Klingphix}}==

 

:*2 2 * ;

@++ @*2 3 composite ? { result: 7 }

 

 

=={{header|Kotlin}}==

fun f(x: Int): Int = x * x

 

fun g(x: Int): Int = x + 2

 

 

println(compose(::f, ::g)(x))

 

{{out}}

 

=={{header|Lambdatalk}}==

{def compose

{lambda {:f :g :x}

{{f} 3}

-> 80

 

=={{header|LFE}}==

(defun compose (f g)

(lambda (x)

(io:format '"Expected answer: ~p~n" (list expected))

(io:format '"Answer with compose: ~p~n" (list compose-result))))

 

If you pasted those into the LFE REPL, you can do the following:

> (funcall (compose #'math:sin/1 #'math:asin/1)

0.5)

ok

>

 

=={{header|Lingo}}==

For such "call-functions", function composition can be implemented using the following global (i.e. movie script) function compose() and the following parent script "Composer":

 

----------------------------------------

-- Composes 2 call-functions, returns a new call-function

on compose (f, g)

return script("Composer").new(f, g)

 

 

property _f

return _movie.call(me._f, _movie, value(cmd))

end if

 

Usage:

f1 = compose(#asin, #sin)

put call(f1, _movie, 0.5)

f3 = compose(f2, f1)

put call(f3, _movie, 0.5)

 

User-defined custom functions used in demo code above:

on asin (x)

res = atan(sqrt(x*x/(1-x*x)))

on triple (x)

return x*3

 

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

 

I HAS A fx, I HAS A gx

VISIBLE I IZ sqrincin YR 10 MKAY BTW, prints 121

 

 

=={{header|Lua}}==

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

Compose = lambda (f, g)->{

}

CheckIt

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

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|Maxima}}==

load(to_poly_solver);

 

 

/* An implementation, to show a use of buildq */

 

=={{header|min}}==

{{works with|min|0.19.3}}

Since min is both [http://concatenative.org/wiki/view/Concatenative%20language concatenative] and homoiconic, function composition is equivalent to list concatenation. Example:

{{out}}

<pre>

 

=={{header|MiniScript}}==

return x * 10

end function

 

f = compose(@funcA, @funcB)

{{out}}

<pre>80</pre>

 

=={{header|Nemerle}}==

using System.Console;

using System.Math;

WriteLine(SinAsin(0.5));

}

 

=={{header|Never}}==

func compose(f(i : int) -> int, g(i : int) -> int) -> (int) -> int

{

0

}

 

=={{header|NewLISP}}==

 

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

> ((compose sin asin) 0.5)

0.5

 

=={{header|Nim}}==

 

 

proc plustwo(x: int): int = x + 2

 

var plusminustwo = compose(plustwo, minustwo)

 

=={{header|Objeck}}==

bundle Default {

class Test {

}

}

prints: 42

 

=={{header|Objective-C}}==

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

 

 

typedef id (^Function)(id);

}

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|Oforth}}==

 

Oforth uses RPN notation. Function composition of f and g is just calling :

If a block is needed, a compose function can be implemented :

Usage :

The last line returns : [1.4142135623731, 2]

 

=={{header|Ol}}==

(define (compose f g)

(lambda (x) (f (g x))))

 

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

 

=={{header|Order}}==

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

 

#define ORDER_PP_DEF_8comp ORDER_PP_FN( \

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

 

=={{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|Pascal}}==

 

=={{header|Perl}}==

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

 

 

use Math::Trig;

 

=={{header|Phix}}==

There is not really any direct support for this sort of thing in Phix, but it is all pretty trivial to manage explicitly.<br>

In the following, as it stands, you cannot use constant m in the same way as a routine_id, or pass a standard routine_id to call_composite(), but tagging the ctable entries so that you know precisely what to do with each entry does not sound the least bit difficult to me.

<span style="color: #004080;">sequence</span> <span style="color: #000000;">ctable</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{<span style="color: #0000FF;">}</span>

<span style="color: #0000FF;">?<span style="color: #000000;">call_composite<span style="color: #0000FF;">(<span style="color: #000000;">m<span style="color: #0000FF;">,<span style="color: #000000;">1<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- displays 1</span>

<span style="color: #0000FF;">?<span style="color: #000000;">call_composite<span style="color: #0000FF;">(<span style="color: #000000;">m<span style="color: #0000FF;">,<span style="color: #000000;">4<span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- displays 2.5

 

=={{header|Phixmonti}}==

def ++ 1 + enddef

def composite swap exec swap exec enddef

 

 

=={{header|PHP}}==

{{works with|PHP|5.3+}}

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|pre-5.3 and 5.3+}}

works with regular functions as well as functions created by <tt>create_function()</tt>

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

 

=={{header|PicoLisp}}==

(curry (F G) (X)

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

-> 7

 

 

: (c 7)

 

=={{header|PostScript}}==

/compose { % f g -> { g f }

[ 3 1 roll exch

/plus1 { 1 add } def

/sqPlus1 /square load /plus1 load compose def

 

=={{header|PowerShell}}==

You can simply call g inside f like this:

function g ($x) {

$x + $x

}

f (g 1)

 

Or g and f can become paramaters of a new function fg

 

function fg (${function:f}, ${function:g}, $x) {

f (g $x)

}

fg f g 1

 

In both cases the answer is:

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

{{out}}

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

 

=={{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}}==

===Simple composition of two functions===

Example use:

>>> from math import sin, asin

>>> sin_asin = compose(sin, asin)

>>> sin_asin(0.5)

0.5

 

 

Or, expanding slightly:

{{Works with|Python|3}}

 

 

 

if __name__ == '__main__':

{{Out}}

<pre>[0.49999999999999994, 0.5000000000000001, 0.5000000000000001]</pre>

 

{{Works with|Python|3}}

 

 

def main():

 

succ,

 

print(

 

 

 

 

 

 

if __name__ == '__main__':

{{Out}}

<pre>1.618033988749895</pre>

 

=== composition via operator overloading===

Here need composition of several functions is reduced with classes.

{{Works with|Python|3}}

# Contents of `pip install compositions'

 

g = Compose(lambda x: x)

 

 

=={{header|Qi}}==

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

(define compose

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

 

=={{header|Quackery}}==

 

nested swap join ] is compose ( g f --> [ )

 

 

19 ' double ' [ 4 + ] compose do echo

 

{{out}}

 

=={{header|R}}==

r <- compose(sin, cos)

 

=={{header|Racket}}==

(define (compose f g)

(lambda (x) (f (g x))))

 

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

{{works with|rakudo|2018.03}}

The function composition operator is <tt>∘</tt>, U+2218 RING OPERATOR (with a "Texas" version <tt>o</tt> for the Unicode challenged). Here we compose a routine, an operator, and a lambda:

my &f = &triple ∘ &prefix:<-> ∘ { $^n + 2 };

 

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

 

{{out}}

 

=={{header|REXX}}==

 

 

=={{header|Ring}}==

# Project : Function composition

 

res = x * y

return res

Output:

<pre>

11

</pre>

 

=={{header|Ruby}}==

This <tt>compose</tt> method gets passed two Method objects or Proc objects

lambda {|x| f[g[x]]}

end

 

# verify

 

=={{header|Rust}}==

===Stable===

Function is allocated on the heap and is called via dynamic dispatch

where F: Fn(U) -> V + 'a,

G: Fn(T) -> U + 'a,

{

Box::new(move |x| f(g(x)))

 

===Nightly===

Function is returned on the stack and is called via static dispatch (monomorphized)

fn compose<'a,F,G,T,U,V>(f: F, g: G) -> impl Fn(T) -> V + 'a

where F: Fn(U) -> V + 'a,

{

move |x| f(g(x))

 

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

((_ f g h ...) #'(lambda (y) (f ((compose g h ...) y)))))))

 

Example:

(display ((compose sin asin) 0.5))

{{out}}

 

=={{header|Sidef}}==

func(x) { f(g(x)) }

}

 

var fg = compose(func(x){ sin(x) }, func(x){ cos(x) })

 

=={{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|SuperCollider}}==

has a function composition operator (the message `<>`):

f = { |x| x + 1 };

g = { |x| x * 2 };

h = g <> f;

h.(8); // returns 18

 

=={{header|Swift}}==

return { f(g($0)) }

}

 

let sin_asin = compose(sin, asin)

{{out}}

<pre>

{{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|TypeScript}}==

function compose<T, U, V> (fn1: (input: T) => U, fn2: (input: U) => V){

return function(value: T) {

console.log(evenSize("ABCD")) // true

console.log(evenSize("ABC")) // false

 

=={{header|UNIX Shell}}==

 

{{works with|Bourne Shell}}

eval "$1() { $3 | $2; }"

}

compose c downvowel upcase

echo 'Cozy lummox gives smart squid who asks for job pen.' | c

 

{{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 strdownvowel strupcase "Cozy lummox gives smart squid who asks for job pen."

 

 

With shell pipelines:

 

result @ {$g | $f}

}

fn-c = <={compose $fn-downvowel $fn-upcase}

echo 'Cozy lummox gives smart squid who asks for job pen.' | c

 

With function arguments:

 

result @ x {result <={$f <={$g $x}}}

}

fn-c = <={compose $fn-downvowel $fn-upcase}

echo <={c 'Cozy lummox gives smart squid who asks for job pen.'}

 

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

 

{{out}}

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

 

{{out}}

The simplest way is with a lambda:

 

 

Alternatively, you can take advantage of partial function calls:

 

 

Both can be used as follows:

 

 

Output:

 

 

=={{header|Wortel}}==

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

Defining the <code>compose</code> function

 

=={{header|Wren}}==

 

var double = Fn.new { |x| 2 * x }

var addOne = Fn.new { |x| x + 1 }

 

 

{{out}}

 

=={{header|zkl}}==

Which is implemented with a closure (.fp1), which fixes the second paramter

 

=={{header|ZX Spectrum Basic}}==

DEF FN commands can be nested, making this appear trivial:

20 DEF FN g(x)=ABS x

30 DEF FN c(x)=FN f(FN g(x))

Which gets you f(g(x)), for sure. But if you want g(f(x)) you need to DEF a whole new FN. Instead we can pass the function names as strings to a new function and numerically evaluate the string:

20 DEF FN g(x)=ABS x

30 DEF FN c(a$,b$,x)=VAL ("FN "+a$+"(FN "+b$+"(x))")

40 PRINT FN c("f","g",-4)

{{out}}

<pre>2