First-class functions
You are encouraged to solve this task according to the task description, using any language you may know.
A language has first-class functions if it can do each of the following without recursively invoking a compiler or interpreter or otherwise metaprogramming:
- Create new functions from preexisting functions at run-time
- Store functions in collections
- Use functions as arguments to other functions
- Use functions as return values of other functions
Write a program to create an ordered collection A of functions of a real number. At least one function should be built-in and at least one should be user-defined; try using the sine, cosine, and cubing functions. Fill another collection B with the inverse of each function in A. Implement function composition as in Functional Composition. Finally, demonstrate that the result of applying the composition of each function in A and its inverse in B to a value, is the original value. (Within the limits of computational accuracy).
(A solution need not actually call the collections "A" and "B". These names are only used in the preceding paragraph for clarity.)
C.f. First-class Numbers
ActionScript
<lang ActionScript> var cube:Function = function(x) {
return Math.pow(x, 3);
}; var cuberoot:Function = function(x) {
return Math.pow(x, 1/3);
};
function compose(f:Function, g:Function):Function { return function(x:Number) {return f(g(x));}; } var functions:Array = [Math.cos, Math.tan, cube]; var inverse:Array = [Math.acos, Math.atan, cuberoot];
function test() { for (var i:uint = 0; i < functions.length; i++) {
// Applying the composition to 0.5
trace(compose(functions[i], inverse[i])(0.5)); } }
test();</lang> Output:
0.5000000000000001 0.5000000000000001 0.5000000000000001
Ada
Even if the example below solves the task, there are some limitations to how dynamically you can create, store and use functions in Ada, so it is debatable if Ada really has first class functions.
<lang Ada>with Ada.Float_Text_IO,
Ada.Integer_Text_IO,
Ada.Text_IO,
Ada.Numerics.Elementary_Functions;
procedure First_Class_Functions is
use Ada.Float_Text_IO,
Ada.Integer_Text_IO,
Ada.Text_IO,
Ada.Numerics.Elementary_Functions;
function Sqr (X : Float) return Float is
begin
return X ** 2;
end Sqr;
type A_Function is access function (X : Float) return Float;
generic
F, G : A_Function;
function Compose (X : Float) return Float;
function Compose (X : Float) return Float is
begin
return F (G (X));
end Compose;
Functions : array (Positive range <>) of A_Function := (Sin'Access,
Cos'Access,
Sqr'Access);
Inverses : array (Positive range <>) of A_Function := (Arcsin'Access,
Arccos'Access,
Sqrt'Access);
begin
for I in Functions'Range loop
declare
function Identity is new Compose (Functions (I), Inverses (I));
Test_Value : Float := 0.5;
Result : Float;
begin
Result := Identity (Test_Value);
if Result = Test_Value then
Put ("Example ");
Put (I, Width => 0);
Put_Line (" is perfect for the given test value.");
else
Put ("Example ");
Put (I, Width => 0);
Put (" is off by");
Put (abs (Result - Test_Value));
Put_Line (" for the given test value.");
end if;
end;
end loop;
end First_Class_Functions;</lang>
It is bad style (but an explicit requirement in the task description) to put the functions and their inverses in separate arrays rather than keeping each pair in a record and then having an array of that record type.
Aikido
<lang aikido> import math
function compose (f, g) {
return function (x) { return f(g(x)) }
}
var fn = [Math.sin, Math.cos, function(x) { return x*x*x }] var inv = [Math.asin, Math.acos, function(x) { return Math.pow(x, 1.0/3) }]
for (var i=0; i<3; i++) {
var f = compose(inv[i], fn[i]) println(f(0.5)) // 0.5
}
</lang>
ALGOL 68
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 - if run out of scope - rejects during runtime.
<lang algol68>MODE F = PROC (REAL)REAL;
OP ** = (REAL x, power)REAL: exp(ln(x)*power);
- Add a user defined function and its inverse #
PROC cube = (REAL x)REAL: x * x * x; PROC cube root = (REAL x)REAL: x ** (1/3);
- First class functions allow run-time creation of functions from functions #
- return function compose(f,g)(x) == f(g(x)) #
PROC non standard compose = (F f1, f2)F: (REAL x)REAL: f1(f2(x)); # eg ELLA ALGOL 68RS # PROC compose = (F f, g)F: ((F f2, g2, REAL x)REAL: f2(g2(x)))(f, g, );
- Or the classic "o" functional operator #
PRIO O = 5; OP (F,F)F O = compose;
- first class functions should be able to be members of collection types #
[]F func list = (sin, cos, cube); []F arc func list = (arc sin, arc cos, cube root);
- Apply functions from lists as easily as integers #
FOR index TO UPB func list DO
STRUCT(F f, inverse f) this := (func list[index], arc func list[index]); print(((inverse f OF this O f OF this)(.5), new line))
OD</lang> Output:
+.500000000000000e +0 +.500000000000000e +0 +.500000000000000e +0
AutoHotkey
AutoHotkey core does not support new function definitions at run time.
However, functions can be called by name, so mapping functions is possible:
<lang AutoHotkey>forward := "sin,cube,cos"
inverse := "Asin,cuberoot,Acos"
StringSplit, forward, forward, `, ; store array length in forward0
StringSplit, inverse, inverse, `, ; array contents are in inverse1, inverse2...
Loop, % forward0
MsgBox % map(compose(forward%A_Index%, inverse%A_Index%), 0.500)
Return
compose(f, g){
Return map(0, 0, f, g)
}
map(ab = 0, x = 0 , a = 0, b = 0) {
Static
If (a And b)
Return a . "`n" . b
If ab
{
StringSplit, ab, ab, `n
Return %ab1%(%ab2%(x))
}
}
cube(x){
Return x ** 3
}
cuberoot(x){
Return x ** (1 / 3)
}</lang>
Axiom
Using the interpreter: <lang Axiom>fns := [sin$Float, cos$Float, (x:Float):Float +-> x^3] inv := [asin$Float, acos$Float, (x:Float):Float +-> x^(1/3)] [(f*g) 0.5 for f in fns for g in inv]</lang> Using the Spad compiler: <lang Axiom>)abbrev package TESTP TestPackage TestPackage(T:SetCategory) : with
_*: (List((T->T)),List((T->T))) -> (T -> List T)
== add
import MappingPackage3(T,T,T)
fs * gs ==
((x:T):(List T) +-> [(f*g) x for f in fs for g in gs])</lang>
This would be called using: <lang Axiom>(fns * inv) 0.5</lang> Output: <lang Axiom>[0.5,0.5,0.5]</lang>
BBC BASIC
Strictly speaking you cannot return a function, but you can return a function pointer which allows the task to be implemented. <lang bbcbasic> REM Create some functions and their inverses:
DEF FNsin(a) = SIN(a)
DEF FNasn(a) = ASN(a)
DEF FNcos(a) = COS(a)
DEF FNacs(a) = ACS(a)
DEF FNcube(a) = a^3
DEF FNroot(a) = a^(1/3)
dummy = FNsin(1)
REM Create the collections (here structures are used):
DIM cA{Sin%, Cos%, Cube%}
DIM cB{Asn%, Acs%, Root%}
cA.Sin% = ^FNsin() : cA.Cos% = ^FNcos() : cA.Cube% = ^FNcube()
cB.Asn% = ^FNasn() : cB.Acs% = ^FNacs() : cB.Root% = ^FNroot()
REM Create some function compositions:
AsnSin% = FNcompose(cB.Asn%, cA.Sin%)
AcsCos% = FNcompose(cB.Acs%, cA.Cos%)
RootCube% = FNcompose(cB.Root%, cA.Cube%)
REM Test applying the compositions:
x = 1.234567 : PRINT x, FN(AsnSin%)(x)
x = 2.345678 : PRINT x, FN(AcsCos%)(x)
x = 3.456789 : PRINT x, FN(RootCube%)(x)
END
DEF FNcompose(f%,g%)
LOCAL f$, p%
f$ = "(x)=" + CHR$&A4 + "(&" + STR$~f% + ")(" + \
\ CHR$&A4 + "(&" + STR$~g% + ")(x))"
DIM p% LEN(f$) + 4
$(p%+4) = f$ : !p% = p%+4
= p%</lang>
Output:
1.234567 1.234567 2.345678 2.345678 3.456789 3.456789
Bori
<lang bori>double acos (double d) { return Math.acos(d); } double asin (double d) { return Math.asin(d); } double cos (double d) { return Math.cos(d); } double sin (double d) { return Math.sin(d); } double croot (double d) { return Math.pow(d, 1/3); } double cube (double x) { return x * x * x; }
Var compose (Var f, Var g, double x) { Func ff = f; Func fg = g; return ff(fg(x)); }
void button1_onClick (Widget widget) { Array arr1 = [ sin, cos, cube ]; Array arr2 = [ asin, acos, croot ];
str s; for (int i = 1; i <= 3; i++) { s << compose(arr1.get(i), arr2.get(i), 0.5) << str.newline; } label1.setText(s); }</lang> Output on Android phone: <lang bori>0.5 0.4999999999999999 0.5000000000000001</lang>
C
Since one can't create new functions dynamically within a C program, C doesn't have first class functions. But you can pass references to functions as parameters and return values and you can have a list of function references, so I guess you can say C has second class functions.
Here goes.
<lang c>#include <stdlib.h>
- include <stdio.h>
- include <math.h>
/* declare a typedef for a function pointer */ typedef double (*Class2Func)(double);
/*A couple of functions with the above prototype */ double functionA( double v) {
return v*v*v;
} double functionB(double v) {
return exp(log(v)/3);
}
/* A function taking a function as an argument */ double Function1( Class2Func f2, double val ) {
return f2(val);
}
/*A function returning a function */ Class2Func WhichFunc( int idx) {
return (idx < 4) ? &functionA : &functionB;
}
/* A list of functions */ Class2Func funcListA[] = {&functionA, &sin, &cos, &tan }; Class2Func funcListB[] = {&functionB, &asin, &acos, &atan };
/* Composing Functions */ double InvokeComposed( Class2Func f1, Class2Func f2, double val ) {
return f1(f2(val));
}
typedef struct sComposition {
Class2Func f1; Class2Func f2;
} *Composition;
Composition Compose( Class2Func f1, Class2Func f2) {
Composition comp = malloc(sizeof(struct sComposition)); comp->f1 = f1; comp->f2 = f2; return comp;
}
double CallComposed( Composition comp, double val ) {
return comp->f1( comp->f2(val) );
} /** * * * * * * * * * * * * * * * * * * * * * * * * * * */
int main(int argc, char *argv[]) {
int ix;
Composition c;
printf("Function1(functionA, 3.0) = %f\n", Function1(WhichFunc(0), 3.0));
for (ix=0; ix<4; ix++) {
c = Compose(funcListA[ix], funcListB[ix]);
printf("Compostion %d(0.9) = %f\n", ix, CallComposed(c, 0.9));
}
return 0;
}</lang>
Non-portable function body duplication
Following code generates true functions at run time. Extremely unportable, and should be considered harmful in general, but it's one (again, harmful) way for the truly desperate (or perhaps for people supporting only one platform -- and note that some other languages only work on one platform). <lang C>#include <stdio.h>
- include <stdlib.h>
- include <string.h>
- include <math.h>
typedef double (*f_dbl)(double);
- define TAGF (f_dbl)0xdeadbeef
- define TAGG (f_dbl)0xbaddecaf
double dummy(double x) { f_dbl f = TAGF; f_dbl g = TAGG; return f(g(x)); }
f_dbl composite(f_dbl f, f_dbl g) { size_t len = (void*)composite - (void*)dummy; f_dbl ret = malloc(len); char *ptr; memcpy(ret, dummy, len); for (ptr = (char*)ret; ptr < (char*)ret + len - sizeof(f_dbl); ptr++) { if (*(f_dbl*)ptr == TAGF) *(f_dbl*)ptr = f; else if (*(f_dbl*)ptr == TAGG) *(f_dbl*)ptr = g; } return ret; }
double cube(double x) { return x * x * x; }
/* uncomment next line if your math.h doesn't have cbrt() */ /* double cbrt(double x) { return pow(x, 1/3.); } */
int main() { int i; double x;
f_dbl A[3] = { cube, exp, sin }; f_dbl B[3] = { cbrt, log, asin}; /* not sure about availablity of cbrt() */ f_dbl C[3];
for (i = 0; i < 3; i++) C[i] = composite(A[i], B[i]);
for (i = 0; i < 3; i++) { for (x = .2; x <= 1; x += .2) printf("C%d(%g) = %g\n", i, x, C[i](x)); printf("\n"); } return 0; }</lang>(Boring) output<lang>C0(0.2) = 0.2 C0(0.4) = 0.4 C0(0.6) = 0.6 C0(0.8) = 0.8 C0(1) = 1
C1(0.2) = 0.2 C1(0.4) = 0.4 C1(0.6) = 0.6 C1(0.8) = 0.8 C1(1) = 1
C2(0.2) = 0.2 C2(0.4) = 0.4 C2(0.6) = 0.6 C2(0.8) = 0.8 C2(1) = 1</lang>
C#
<lang csharp>using System;
class Program {
delegate Func<A,C> Composer<A,B,C>(Func<B,C> f, Func<A,B> g);
static void Main(string[] args)
{
Func<double, double> cube = x => Math.Pow(x, 3);
Func<double, double> croot = x => Math.Pow(x, (double)1/3);
var fun = new[] { Math.Sin, Math.Cos, cube };
var inv = new[] { Math.Asin, Math.Acos, croot };
Composer<double, double, double> compose = (f, g) => delegate(double x) { return f(g(x)); };
for (var i = 0; i < fun.Length; ++i)
{
Console.WriteLine(compose(fun[i],inv[i])(0.5));
}
}
} </lang>
Output:
0.5 0.5 0.5
C++
<lang cpp>
- include <functional>
- include <algorithm>
- include <iostream>
- include <vector>
- include <cmath>
using std::cout; using std::endl; using std::vector; using std::function; using std::transform; using std::back_inserter;
typedef function<double(double)> FunType;
vector<FunType> A = {sin, cos, tan, [](double x) { return x*x*x; } }; vector<FunType> B = {asin, acos, atan, [](double x) { return exp(log(x)/3); } };
template <typename A, typename B, typename C> function<C(A)> compose(function<C(B)> f, function<B(A)> g) {
return [f,g](A x) { return f(g(x)); };
}
int main() {
vector<FunType> composedFuns;
auto exNums = {0.0, 0.2, 0.4, 0.6, 0.8, 1.0};
transform(B.begin(), B.end(),
A.begin(),
back_inserter(composedFuns),
compose<double, double, double>);
for (auto num: exNums)
for (auto fun: composedFuns)
cout << u8"f\u207B\u00B9.f(" << num << ") = " << fun(num) << endl;
return 0;
} </lang>
Clojure
<lang clojure> (use 'clojure.contrib.math) (let [fns [#(Math/sin %) #(Math/cos %) (fn [x] (* x x x))]
inv [#(Math/asin %) #(Math/acos %) #(expt % 1/3)]] (map #(% 0.5) (map #(comp %1 %2) fns inv)))
</lang> Output:
(0.5 0.4999999999999999 0.5000000000000001)
CoffeeScript
<lang coffeescript># Functions as values of a variable cube = (x) -> Math.pow x, 3 cuberoot = (x) -> Math.pow x, 1 / 3
- Higher order function
compose = (f, g) -> (x) -> f g(x)
- Storing functions in a array
fun = [Math.sin, Math.cos, cube] inv = [Math.asin, Math.acos, cuberoot]
- Applying the composition to 0.5
console.log compose(inv[i], fun[i])(0.5) for i in [0..2]</lang> Output:
0.5 0.4999999999999999 0.5
Common Lisp
<lang lisp>(defun compose (f g) (lambda (x) (funcall f (funcall g x)))) (defun cube (x) (expt x 3)) (defun cube-root (x) (expt x (/ 3)))
(loop with value = 0.5
for function in (list #'sin #'cos #'cube )
for inverse in (list #'asin #'acos #'cube-root)
for composed = (compose inverse function)
do (format t "~&(~A ∘ ~A)(~A) = ~A~%"
inverse
function
value
(funcall composed value)))</lang>
Output:
<lang lisp>(#<FUNCTION ASIN> ∘ #<FUNCTION SIN>)(0.5) = 0.5 (#<FUNCTION ACOS> ∘ #<FUNCTION COS>)(0.5) = 0.5 (#<FUNCTION CUBE-ROOT> ∘ #<FUNCTION CUBE>)(0.5) = 0.5</lang>
D
Using Standard Compose
We need wrappers because the standard functions have different signatures (eg pure/nothrow). <lang d>import std.stdio, std.math, std.typetuple, std.functional;
enum sin = (in real x) => std.math.sin(x),
asin = (in real x) => std.math.asin(x),
cos = (in real x) => std.math.cos(x),
acos = (in real x) => std.math.acos(x),
cube = (in real x) => x ^^ 3,
cbrt = (in real x) => std.math.cbrt(x);
void main() {
alias TypeTuple!(sin, cos, cube) dir;
alias TypeTuple!(asin, acos, cbrt) inv;
foreach (i, f; dir) {
writefln("%6.3f", compose!(f, inv[i])(0.5));
}
}</lang>
- Output:
0.500 0.500 0.500
Defining Compose
Same output: <lang d>T delegate(S) compose(T, U, S)(in T function(in U) f,
in U function(in S) g) {
return s => f(g(s));
}
void main() {
import std.stdio, std.math, std.range;
immutable sin = (in real x) => sin(x),
asin = (in real x) => asin(x),
cos = (in real x) => cos(x),
acos = (in real x) => acos(x),
cube = (in real x) => x ^^ 3,
cbrt = (in real x) => cbrt(x);
foreach (f, g; zip([sin, cos, cube], [asin, acos, cbrt]))
writefln("%6.3f", compose(f, g)(0.5));
}</lang>
Dart
<lang dart>cube(x) { return x * x * x; } inv_cube(x) { return Math.pow(x, 1/3); }
compo(f1, f2) {
return func(x) { return f1(f2(x));};
}
main() {
var funcs = [Math.sin, Math.exp, cube];
var invs = [Math.asin, Math.log, inv_cube];
for (int i = 0; i < 3; i++)
print(compo(funcs[i], invs[i])(1));
}</lang>
Déjà Vu
<lang dejavu>compose f g: labda: f g
negate: - 0
set :A [ @++ compose @negate @-- ]
set :B [ @-- compose @++ @negate ]
test n: for i range 0 -- len A: if /= n call get-from B i call get-from A i n: return false true
test to-num input print\ "Enter a number: " if: print "f^-1(f(x)) = x" else: print "Something went wrong."</lang>
E
First, a brief summary of the relevant semantics: In E, every value, including built-in and user-defined functions, "is an object" — it has methods which respond to messages. Methods are distinguished by the given name (verb) and the number of parameters (arity). By convention and syntactic sugar, a function is an object which has a method whose verb is "run".
The relevant mathematical operations are provided as methods on floats, so the first thing we must do is define them as functions.
<lang e>def sin(x) { return x.sin() } def cos(x) { return x.cos() } def asin(x) { return x.asin() } def acos(x) { return x.acos() } def cube(x) { return x ** 3 } def curt(x) { return x ** (1/3) }
def forward := [sin, cos, cube] def reverse := [asin, acos, curt]</lang>
There are no built-in functions in this list, since the original author couldn't easily think of any which had one parameter and were inverses of each other, but composition would work just the same with them.
Defining composition. fn params { expr } is shorthand for an anonymous function returning a value.
<lang e>def compose(f, g) {
return fn x { f(g(x)) }
}</lang>
<lang e>? def x := 0.5 \ > for i => f in forward { > def g := reverse[i] > println(`x = $x, f = $f, g = $g, compose($f, $g)($x) = ${compose(f, g)(x)}`) > }
x = 0.5, f = <sin>, g = <asin>, compose(<sin>, <asin>)(0.5) = 0.5 x = 0.5, f = <cos>, g = <acos>, compose(<cos>, <acos>)(0.5) = 0.4999999999999999 x = 0.5, f = <cube>, g = <curt>, compose(<cube>, <curt>)(0.5) = 0.5000000000000001</lang>
Note: def g := reverse[i] is needed here because E as yet has no defined protocol for iterating over collections in parallel. Page for this issue.
Ela
Translation of Haskell:
<lang ela>open number //sin,cos,asin,acos open list //zipWith
cube x = x ** 3 croot x = x ** (1/3)
funclist = [sin, cos, cube] funclisti = [asin, acos, croot]
zipWith (\f inversef -> (inversef << f) 0.5) funclist funclisti</lang>
Function (<<) is defined in standard prelude as:
<lang ela>(<<) f g x = f (g x)</lang>
Output (calculations are performed on 32-bit floats):
<lang ela>[0.5,0.5,0.499999989671302]</lang>
F#
<lang fsharp>open System
let cube x = x ** 3.0 let croot x = x ** (1.0/3.0)
let funclist = [Math.Sin; Math.Cos; cube] let funclisti = [Math.Asin; Math.Acos; croot] let composed = List.map2 (<<) funclist funclisti
let main() = for f in composed do printfn "%f" (f 0.5)
main()</lang>
Output:
0.500000 0.500000 0.500000
Factor
The constants A and B consist of arrays containing quotations (aka anonymous functions). <lang factor>USING: assocs combinators kernel math.functions prettyprint sequences ; IN: rosettacode.first-class-functions
CONSTANT: A { [ sin ] [ cos ] [ 3 ^ ] } CONSTANT: B { [ asin ] [ acos ] [ 1/3 ^ ] }
- compose-all ( seq1 seq2 -- seq ) [ compose ] 2map ;
- test-fcf ( -- )
0.5 A B compose-all [ call( x -- y ) ] with map . ;</lang>
- Output:
{ 0.5 0.4999999999999999 0.5 }
Fantom
Methods defined for classes can be pulled out into functions, e.g. "Float#sin.func" pulls the sine method for floats out into a function accepting a single argument. This function is then a first-class value.
<lang fantom> class FirstClassFns {
static |Obj -> Obj| compose (|Obj -> Obj| fn1, |Obj -> Obj| fn2)
{
return |Obj x -> Obj| { fn2 (fn1 (x)) }
}
public static Void main ()
{
cube := |Float a -> Float| { a * a * a }
cbrt := |Float a -> Float| { a.pow(1/3f) }
|Float->Float|[] fns := [Float#sin.func, Float#cos.func, cube]
|Float->Float|[] inv := [Float#asin.func, Float#acos.func, cbrt]
|Float->Float|[] composed := fns.map |fn, i| { compose(fn, inv[i]) }
composed.each |fn| { echo (fn(0.5f)) }
}
} </lang>
Output:
0.5 0.4999999999999999 0.5
Forth
<lang forth>: compose ( xt1 xt2 -- xt3 )
>r >r :noname
r> compile,
r> compile,
postpone ;
- cube fdup fdup f* f* ;
- cuberoot 1e 3e f/ f** ;
- table create does> swap cells + @ ;
table fn ' fsin , ' fcos , ' cube , table inverse ' fasin , ' facos , ' cuberoot ,
- main
3 0 do i fn i inverse compose ( xt ) 0.5e execute f. loop ;
main \ 0.5 0.5 0.5</lang>
GAP
<lang gap># Function composition Composition := function(f, g)
local h; h := function(x) return f(g(x)); end; return h;
end;
- Apply each function in list u, to argument x
ApplyList := function(u, x)
local i, n, v; n := Size(u); v := [ ]; for i in [1 .. n] do v[i] := u[i](x); od; return v;
end;
- Inverse and Sqrt are in the built-in library. Note that GAP doesn't have real numbers nor floating point numbers. Therefore, Sqrt yields values in cyclotomic fields.
- For example,
- gap> Sqrt(7);
- E(28)^3-E(28)^11-E(28)^15+E(28)^19-E(28)^23+E(28)^27
- where E(n) is a primitive n-th root of unity
a := [ i -> i + 1, Inverse, Sqrt ];
- [ function( i ) ... end, <Operation "InverseImmutable">, <Operation "Sqrt"> ]
b := [ i -> i - 1, Inverse, x -> x*x ];
- [ function( i ) ... end, <Operation "InverseImmutable">, function( x ) ... end ]
- Compose each couple
z := ListN(a, b, Composition);
- Now a test
ApplyList(z, 3); [ 3, 3, 3 ]</lang>
Go
<lang go>package main
import "math" import "fmt"
// user-defined function, per task. Other math functions used are built-in. func cube(x float64) float64 { return math.Pow(x, 3) }
// ffType and compose function taken from Function composition task type ffType func(float64) float64
func compose(f, g ffType) ffType {
return func(x float64) float64 {
return f(g(x))
}
}
func main() {
// collection A
funclist := []ffType{math.Sin, math.Cos, cube}
// collection B
funclisti := []ffType{math.Asin, math.Acos, math.Cbrt}
for i := 0; i < 3; i++ {
// apply composition and show result
fmt.Println(compose(funclisti[i], funclist[i])(.5))
}
}</lang> Output:
0.49999999999999994 0.5 0.5
Groovy
Solution: <lang groovy>def compose = { f, g -> { x -> f(g(x)) } }</lang>
Test program: <lang groovy>def cube = { it * it * it } def cubeRoot = { it ** (1/3) }
funcList = [ Math.&sin, Math.&cos, cube ] inverseList = [ Math.&asin, Math.&acos, cubeRoot ]
println [funcList, inverseList].transpose().collect { compose(it[0],it[1]) }.collect{ it(0.5) } println [inverseList, funcList].transpose().collect { compose(it[0],it[1]) }.collect{ it(0.5) }</lang>
Output:
[0.5, 0.4999999999999999, 0.5000000000346574] [0.5, 0.4999999999999999, 0.5000000000346574]
Haskell
<lang haskell>Prelude> let cube x = x ^ 3 Prelude> let croot x = x ** (1/3) Prelude> let compose f g = \x -> f (g x) -- this is already implemented in Haskell as the "." operator Prelude> -- we could have written "let compose f g x = f (g x)" but we show this for clarity Prelude> let funclist = [sin, cos, cube] Prelude> let funclisti = [asin, acos, croot] Prelude> zipWith (\f inversef -> (compose inversef f) 0.5) funclist funclisti [0.5,0.4999999999999999,0.5]</lang>
Icon and Unicon
The Unicon solution can be modified to work in Icon. See Function_composition#Icon_and_Unicon. <lang Unicon>link compose procedure main(arglist)
fun := [sin,cos,cube]
inv := [asin,acos,cuberoot]
x := 0.5
every i := 1 to *inv do
write("f(",x,") := ", compose(inv[i],fun[i])(x))
end
procedure cube(x) return x*x*x end
procedure cuberoot(x) return x ^ (1./3) end</lang> Please refer to See Function_composition#Icon_and_Unicon for 'compose'.
Sample Output:
f(0.5) := 0.5 f(0.5) := 0.4999999999999999 f(0.5) := 0.5
J
J has some subtleties which are not addressed in this specification (J functions have grammatical character and their gerundial form may be placed in data structures where the spec sort of implies that there be no such distinction).
However, here are the basics which were requested: <lang j> sin=: 1&o.
cos=: 2&o. cube=: ^&3
square=: *:
unqo=: `:6
unqcol=: `:0
quot=: 1 :'{.u`
A=: sin`cos`cube`square
B=: monad def'y unqo inv quot'"0 A
BA=. A dyad def'x unqo@(y unqo) quot'"0 B</lang>
<lang> A unqcol 0.5 0.479426 0.877583 0.125 0.25
BA unqcol 0.5
0.5 0.5 0.5 0.5</lang>
Java
Java doesn't technically have first-class functions. Java can simulate first-class functions to a certain extent, with anonymous classes and generic function interface.
<lang java5>import java.util.ArrayList;
public class FirstClass{
public interface Function<A,B>{ B apply(A x); }
public static <A,B,C> Function<A, C> compose( final Function<B, C> f, final Function<A, B> g) { return new Function<A, C>() { @Override public C apply(A x) { return f.apply(g.apply(x)); } }; }
public static void main(String[] args){ ArrayList<Function<Double, Double>> functions = new ArrayList<Function<Double,Double>>();
functions.add( new Function<Double, Double>(){ @Override public Double apply(Double x){ return Math.cos(x); } }); functions.add( new Function<Double, Double>(){ @Override public Double apply(Double x){ return Math.tan(x); } }); functions.add( new Function<Double, Double>(){ @Override public Double apply(Double x){ return x * x; } });
ArrayList<Function<Double, Double>> inverse = new ArrayList<Function<Double,Double>>();
inverse.add( new Function<Double, Double>(){ @Override public Double apply(Double x){ return Math.acos(x); } }); inverse.add( new Function<Double, Double>(){ @Override public Double apply(Double x){ return Math.atan(x); } }); inverse.add( new Function<Double, Double>(){ @Override public Double apply(Double x){ return Math.sqrt(x); } }); System.out.println("Compositions:"); for(int i = 0; i < functions.size(); i++){ System.out.println(compose(functions.get(i), inverse.get(i)).apply(0.5)); } System.out.println("Hard-coded compositions:"); System.out.println(Math.cos(Math.acos(0.5))); System.out.println(Math.tan(Math.atan(0.5))); System.out.println(Math.pow(Math.sqrt(0.5), 2)); } }</lang> Output:
Compositions: 0.4999999999999999 0.49999999999999994 0.5000000000000001 Hard-coded compositions: 0.4999999999999999 0.49999999999999994 0.5000000000000001
<lang java5>import java.util.ArrayList; import java.util.function.Function;
public class FirstClass{
public static <A,B,C> Function<A, C> compose( final Function<B, C> f, final Function<A, B> g) { return new Function<A, C>() { @Override public C apply(A x) { return f.apply(g.apply(x)); } }; }
public static void main(String[] args){ ArrayList<Function<Double, Double>> functions = new ArrayList<>();
functions.add(Math::cos); functions.add(Math::tan); functions.add(x -> x * x);
ArrayList<Function<Double, Double>> inverse = new ArrayList<>();
inverse.add(Math::acos); inverse.add(Math::atan); inverse.add(Math::sqrt); System.out.println("Compositions:"); for(int i = 0; i < functions.size(); i++){ System.out.println(compose(functions.get(i), inverse.get(i)).apply(0.5)); } System.out.println("Hard-coded compositions:"); System.out.println(Math.cos(Math.acos(0.5))); System.out.println(Math.tan(Math.atan(0.5))); System.out.println(Math.pow(Math.sqrt(0.5), 2)); } }</lang>
JavaScript
<lang javascript>// Functions as values of a variable var cube = function(x) {
return Math.pow(x, 3);
}; var cuberoot = function(x) {
return Math.pow(x, 1/3);
};
// Higher order function var compose = function (f, g) {
return function (x) {
return f(g(x));
};
};
// Storing functions in a array var fun = [Math.sin, Math.cos, cube]; var inv = [Math.asin, Math.acos, cuberoot];
for (var i = 0; i < 3; i++) {
// Applying the composition to 0.5 console.log(compose(inv[i], fun[i])(0.5));
}</lang> Output:
0.5 0.4999999999999999 0.5
Lua
<lang lua>function compose(f,g) return function(...) return f(g(...)) end end
fn = {math.sin, math.cos, function(x) return x^3 end} inv = {math.asin, math.acos, function(x) return x^(1/3) end}
for i, v in ipairs(fn) do
local f = compose(v, inv[i]) print(f(0.5))
end</lang>
Output: <lang>0.5 0.5 0.5</lang>
Maple
The composition operator in Maple is denoted by "@". We use "zip" to produce the list of compositions. The cubing procedure and its inverse are each computed. <lang Maple> > A := [ sin, cos, x -> x^3 ]: > B := [ arcsin, arccos, rcurry( surd, 3 ) ]: > zip( `@`, A, B )( 2/3 );
[2/3, 2/3, 2/3]
> zip( `@`, B, A )( 2/3 );
[2/3, 2/3, 2/3]
</lang>
Mathematica
The built-in function Composition can do composition, a custom function that does the same would be compose[f_,g_]:=f[g[#]]&. However the latter only works with 2 arguments, Composition works with any number of arguments. <lang Mathematica>funcs = {Sin, Cos, #^3 &}; funcsi = {ArcSin, ArcCos, #^(1/3) &}; compositefuncs = Composition @@@ Transpose[{funcs, funcsi}]; Table[i[0.666], {i, compositefuncs}]</lang> gives back: <lang Mathematica>{0.666, 0.666, 0.666}</lang> Note that I implemented cube and cube-root as pure functions. This shows that Mathematica is fully able to handle functions as variables, functions can return functions, and functions can be given as an argument. Composition can be done in more than 1 way: <lang Mathematica>Composition[f,g,h][x] f@g@h@x x//h//g//f</lang> all give back: <lang Mathematica>f[g[h[x]]]</lang>
Maxima
<lang maxima>a: [sin, cos, lambda([x], x^3)]$ b: [asin, acos, lambda([x], x^(1/3))]$ compose(f, g) := buildq([f, g], lambda([x], f(g(x))))$ map(lambda([fun], fun(x)), map(compose, a, b)); [x, x, x]</lang>
Mercury
This solution uses the compose/3 function defined in std_util (part of the Mercury standard library) to demonstrate the use of first-class functions. The following process is followed:
- A list of "forward" functions is provided (sin, cosine and a lambda that calls ln).
- A list of "reverse" functions is provided (asin, acosine and a lambda that calls exp).
- The lists are mapped in corresponding members through an anonymous function that composes the resulting pairs of functions and applies them to the value 0.5.
- The results are returned and printed when all function pairs have been processed.
firstclass.m
<lang Mercury>
- - module firstclass.
- - interface.
- - import_module io.
- - pred main(io::di, io::uo) is det.
- - implementation.
- - import_module exception, list, math, std_util.
main(!IO) :-
Forward = [sin, cos, (func(X) = ln(X))],
Reverse = [asin, acos, (func(X) = exp(X))],
Results = map_corresponding(
(func(F, R) = compose(R, F, 0.5)),
Forward, Reverse),
write_list(Results, ", ", write_float, !IO),
write_string("\n", !IO).
</lang>
Use and output
$ mmc -E firstclass.m && ./firstclass 0.5, 0.4999999999999999, 0.5
(Limitations of the IEEE floating point representation make the cos/acos pairing lose a little bit of accuracy.)
Nemerle
<lang Nemerle>using System; using System.Console; using System.Math; using Nemerle.Collections.NCollectionsExtensions;
module FirstClassFunc {
Main() : void
{
def cube = fun (x) {x * x * x};
def croot = fun (x) {Pow(x, 1.0/3.0)};
def compose = fun(f, g) {fun (x) {f(g(x))}};
def funcs = [Sin, Cos, cube];
def ifuncs = [Asin, Acos, croot];
WriteLine($[compose(f, g)(0.5) | (f, g) in ZipLazy(funcs, ifuncs)]);
}
}</lang>
Use and Output
C:\Rosetta>ncc -o:FirstClassFunc FirstClassFunc.n C:Rosetta>FirstClassFunc [0.5, 0.5, 0.5]
newLISP
<lang newLISP>> (define (compose f g) (expand (lambda (x) (f (g x))) 'f 'g)) (lambda (f g) (expand (lambda (x) (f (g x))) 'f 'g)) > (define (cube x) (pow x 3)) (lambda (x) (pow x 3)) > (define (cube-root x) (pow x (div 1 3))) (lambda (x) (pow x (div 1 3))) > (define functions '(sin cos cube)) (sin cos cube) > (define inverses '(asin acos cube-root)) (asin acos cube-root) > (map (fn (f g) ((compose f g) 0.5)) functions inverses) (0.5 0.5 0.5) </lang>
OCaml
<lang ocaml># let cube x = x ** 3. ;; val cube : float -> float = <fun>
- let croot x = x ** (1. /. 3.) ;;
val croot : float -> float = <fun>
- let compose f g = fun x -> f (g x) ;; (* we could have written "let compose f g x = f (g x)" but we show this for clarity *)
val compose : ('a -> 'b) -> ('c -> 'a) -> 'c -> 'b = <fun>
- let funclist = [sin; cos; cube] ;;
val funclist : (float -> float) list = [<fun>; <fun>; <fun>]
- let funclisti = [asin; acos; croot] ;;
val funclisti : (float -> float) list = [<fun>; <fun>; <fun>]
- List.map2 (fun f inversef -> (compose inversef f) 0.5) funclist funclisti ;;
- : float list = [0.5; 0.499999999999999889; 0.5]</lang>
Octave
<lang octave>function r = cube(x)
r = x.^3;
endfunction
function r = croot(x)
r = x.^(1/3);
endfunction
compose = @(f,g) @(x) f(g(x));
f1 = {@sin, @cos, @cube}; f2 = {@asin, @acos, @croot};
for i = 1:3
disp(compose(f1{i}, f2{i})(.5))
endfor</lang>
Oz
To be executed in the REPL.
<lang oz>declare
fun {Compose F G}
fun {$ X}
{F {G X}}
end
end
fun {Cube X} X*X*X end
fun {CubeRoot X} {Number.pow X 1.0/3.0} end
in
for
F in [Float.sin Float.cos Cube]
I in [Float.asin Float.acos CubeRoot]
do
{Show {{Compose I F} 0.5}}
end
</lang>
PARI/GP
<lang parigp>compose(f,g)={
x -> f(g(x))
};
fcf()={
my(A,B); A=[x->sin(x), x->cos(x), x->x^2]; B=[x->asin(x), x->acos(x), x->sqrt(x)]; for(i=1,#A, print(compose(A[i],B[i])(.5)) )
};</lang> Usage note: In Pari/GP 2.4.3 the vectors can be written as <lang parigp> A=[sin, cos, x->x^2];
B=[asin, acos, x->sqrt(x)];</lang>
Output:
0.5000000000000000000000000000 0.5000000000000000000000000000 0.5000000000000000000000000000
Perl
<lang perl>use Math::Complex ':trig';
sub compose {
my ($f, $g) = @_;
sub {
$f -> ($g -> (@_));
};
}
my $cube = sub { $_[0] ** (3) }; my $croot = sub { $_[0] ** (1/3) };
my @flist1 = ( \&Math::Complex::sin, \&Math::Complex::cos, $cube ); my @flist2 = ( \&asin, \&acos, $croot );
print join "\n", map {
compose($flist1[$_], $flist2[$_]) -> (0.5)
} 0..2;</lang> Output:
0.5 0.5 0.5
Perl 6
Here we use the Z ("zipwith") metaoperator to zip the 𝐴 and 𝐵 lists with a user-defined compose function, expressed as an infix operator, ⚬. The .() construct invokes the function contained in the $_ (current topic) variable. <lang perl6>sub infix:<⚬> (&𝑔, &𝑓) { -> \x { 𝑔 𝑓 x } }
my \𝐴 = &sin, &cos, { $_ ** <3/1> } my \𝐵 = &asin, &acos, { $_ ** <1/3> }
say .(.5) for 𝐴 Z⚬ 𝐵</lang> Output:
0.5 0.5 0.5
PHP
Non-anonymous functions can only be passed around by name, but the syntax for calling them is identical in both cases. Object or class methods require a different syntax involving array pseudo-types and call_user_func. So PHP could be said to have some first class functionality.
<lang php>$compose = function ($f, $g) {
return function ($x) use ($f, $g) {
return $f($g($x));
};
};
$fn = array('sin', 'cos', function ($x) { return pow($x, 3); }); $inv = array('asin', 'acos', function ($x) { return pow($x, 1/3); });
for ($i = 0; $i < 3; $i++) {
$f = $compose($inv[$i], $fn[$i]); echo $f(0.5), PHP_EOL;
}</lang>
Output:
0.5 0.5 0.5
PicoLisp
<lang PicoLisp>(load "@lib/math.l")
(de compose (F G)
(curry (F G) (X)
(F (G X)) ) )
(de cube (X)
(pow X 3.0) )
(de cubeRoot (X)
(pow X 0.3333333) )
(mapc
'((Fun Inv)
(prinl (format ((compose Inv Fun) 0.5) *Scl)) )
'(sin cos cube)
'(asin acos cubeRoot) )</lang>
Output:
0.500001 0.499999 0.500000
Prolog
Works with SWI-Prolog and module lambda, written by Ulrich Neumerkel found here: http://www.complang.tuwien.ac.at/ulrich/Prolog-inedit/lambda.pl
<lang Prolog>:- use_module(library(lambda)).
compose(F,G, FG) :-
FG = \X^Z^(call(G,X,Y), call(F,Y,Z)).
cube(X, Y) :- Y is X ** 3.
cube_root(X, Y) :- Y is X ** (1/3).
first_class :- L = [sin, cos, cube], IL = [asin, acos, cube_root],
% we create the composed functions maplist(compose, L, IL, Lst),
% we call the functions maplist(call, Lst, [0.5,0.5,0.5], R),
% we display the results maplist(writeln, R). </lang> Output :
?- first_class. 0.5 0.4999999999999999 0.5000000000000001 true.
Python
<lang python>>>> # Some built in functions and their inverses >>> from math import sin, cos, acos, asin >>> # Add a user defined function and its inverse >>> cube = lambda x: x * x * x >>> croot = lambda x: x ** (1/3.0) >>> # First class functions allow run-time creation of functions from functions >>> # return function compose(f,g)(x) == f(g(x)) >>> compose = lambda f1, f2: ( lambda x: f1(f2(x)) ) >>> # first class functions should be able to be members of collection types >>> funclist = [sin, cos, cube] >>> funclisti = [asin, acos, croot] >>> # Apply functions from lists as easily as integers >>> [compose(inversef, f)(.5) for f, inversef in zip(funclist, funclisti)] [0.5, 0.4999999999999999, 0.5] >>></lang>
R
<lang R>cube <- function(x) x^3 croot <- function(x) x^(1/3) compose <- function(f, g) function(x){f(g(x))}
f1 <- c(sin, cos, cube) f2 <- c(asin, acos, croot)
for(i in 1:3) {
print(compose(f1i, f2i)(.5))
}</lang>
Alternatively:
<lang R> sapply(mapply(compose,f1,f2),do.call,list(.5)) </lang>
Racket
<lang racket>
- lang racket
(define (compose f g) (λ (x) (f (g x)))) (define (cube x) (expt x 3)) (define (cube-root x) (expt x (/ 1 3))) (define funlist (list sin cos cube)) (define ifunlist (list asin acos cube-root))
(for ([f funlist] [i ifunlist])
(displayln ((compose i f) 0.5)))
</lang>
REBOL
<lang REBOL>REBOL [ Title: "First Class Functions" Author: oofoe Date: 2009-12-05 URL: http://rosettacode.org/wiki/First-class_functions ]
- 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]]
cube: func [x][x * x * x] croot: func [x][power x 1 / 3]
- "compose" means something else in REBOL, so I "fashion" an alternative.
fashion: func [f1 f2][ do compose/deep [func [x][(:f1) (:f2) x]]]
A: [foo sine cosine cube] B: [bar arcsine arccosine croot]
while [not tail? A][ fn: fashion get A/1 get B/1 source fn ; Prove that functions actually got composed. print [fn 0.5 crlf]
A: next A B: next B ; Advance to next pair. ]</lang>
Ruby
<lang ruby>irb(main):001:0> cube = proc{|x| x ** 3} => #<Proc:0x0000020c66b878@(irb):1> irb(main):002:0> croot = proc{|x| x ** (1.quo 3)} => #<Proc:0x00000201f6a6c8@(irb):2> irb(main):003:0> compose = proc {|f,g| proc {|x| f[g[x]]}} => #<Proc:0x00000205e4e768@(irb):3> irb(main):004:0> funclist = [Math.method(:sin), Math.method(:cos), cube] => [#<Method: Math.sin>, #<Method: Math.cos>, #<Proc:0x0000020c66b878@(irb):1>] irb(main):005:0> invlist = [Math.method(:asin), Math.method(:acos), croot] => [#<Method: Math.asin>, #<Method: Math.acos>, #<Proc:0x00000201f6a6c8@(irb):2>] irb(main):006:0> funclist.zip(invlist).map {|f, invf| compose[invf, f][0.5]} => [0.5, 0.4999999999999999, 0.5]</lang>
Scala
<lang scala>import math._
// functions as values val cube = (x: Double) => x * x * x val cuberoot = (x: Double) => pow(x, 1 / 3d)
// higher order function, as a method def compose[A,B,C](f: B => C, g: A => B) = (x: A) => f(g(x))
// partially applied functions in Lists val fun = List(sin _, cos _, cube) val inv = List(asin _, acos _, cuberoot)
// composing functions from the above Lists val comp = (fun, inv).zipped map (_ compose _)
// output results of applying the functions comp foreach {f => print(f(0.5) + " ")}</lang> Output:
0.5 0.4999999999999999 0.5000000000000001
Scheme
<lang scheme>(define (compose f g) (lambda (x) (f (g x)))) (define (cube x) (expt x 3)) (define (cube-root x) (expt x (/ 1 3)))
(define function (list sin cos cube)) (define inverse (list asin acos cube-root))
(define x 0.5) (define (go f g)
(if (not (or (null? f)
(null? g)))
(begin (display ((compose (car f) (car g)) x))
(newline)
(go (cdr f) (cdr g)))))
(go function inverse)</lang> Output:
0.5 0.5 0.5
Slate
Compose is already defined in slate as (note the examples in the comment):
<lang slate>m@(Method traits) ** n@(Method traits) "Answers a new Method whose effect is that of calling the first method on the results of the second method applied to whatever arguments are passed. This composition is associative, i.e. (a ** b) ** c = a ** (b ** c). When the second method, n, does not take a *rest option or the first takes more than one input, then the output is chunked into groups for its consumption. E.g.:
- `er ** #; `er applyTo
- {'a'. 'b'. 'c'. 'd'} => 'abcd'
- `er ** #name `er applyTo
- {#a. #/}. => 'a/'"
[
n acceptsAdditionalArguments \/ [m arity = 1]
ifTrue:
[[| *args | m applyTo: {n applyTo: args}]]
ifFalse:
[[| *args |
m applyTo:
([| :stream |
args do: [| *each | stream nextPut: (n applyTo: each)]
inGroupsOf: n arity] writingAs: {})]]
].
- `er asMethod: #compose: on: {Method traits. Method traits}.</lang>
used as: <lang slate>n@(Number traits) cubed [n raisedTo: 3]. n@(Number traits) cubeRoot [n raisedTo: 1 / 3]. define: #forward -> {#cos `er. #sin `er. #cube `er}. define: #reverse -> {#arcCos `er. #arcSin `er. #cubeRoot `er}.
define: #composedMethods -> (forward with: reverse collect: #compose: `er). composedMethods do: [| :m | inform: (m applyWith: 0.5)].</lang>
Smalltalk
<lang smalltalk>|forward reverse composer compounds| "commodities" Number extend [
cube [ ^self raisedTo: 3 ]
]. Number extend [
cubeRoot [ ^self raisedTo: (1 / 3) ]
].
forward := #( #cos #sin #cube ). reverse := #( #arcCos #arcSin #cubeRoot ).
composer := [ :f :g | [ :x | f value: (g value: x) ] ].
"let us create composed funcs" compounds := OrderedCollection new.
1 to: 3 do: [ :i |
compounds add: ([ :j | composer value: [ :x | x perform: (forward at: j) ]
value: [ :x | x perform: (reverse at: j) ] ] value: i)
].
compounds do: [ :r | (r value: 0.5) displayNl ].</lang>
Output:
0.4999999999999999 0.5 0.5000000000000001
Standard ML
<lang sml>- fun cube x = Math.pow(x, 3.0); val cube = fn : real -> real - fun croot x = Math.pow(x, 1.0 / 3.0); val croot = fn : real -> real - fun compose (f, g) = fn x => f (g x); (* this is already implemented in Standard ML as the "o" operator = we could have written "fun compose (f, g) x = f (g x)" but we show this for clarity *) val compose = fn : ('a -> 'b) * ('c -> 'a) -> 'c -> 'b - val funclist = [Math.sin, Math.cos, cube]; val funclist = [fn,fn,fn] : (real -> real) list - val funclisti = [Math.asin, Math.acos, croot]; val funclisti = [fn,fn,fn] : (real -> real) list - ListPair.map (fn (f, inversef) => (compose (inversef, f)) 0.5) (funclist, funclisti); val it = [0.5,0.5,0.500000000001] : real list</lang>
Tcl
The following is a transcript of an interactive session:
<lang Tcl>% namespace path tcl::mathfunc ;# to import functions like abs() etc. % proc cube x {expr {$x**3}} % proc croot x {expr {$x**(1/3.)}} % proc compose {f g} {list apply {{f g x} {{*}$f [{*}$g $x]}} $f $g}
% compose abs cube ;# returns a partial command, without argument apply {{f g x} {{*}$f [{*}$g $x]}} abs cube
% {*}[compose abs cube] -3 ;# applies the partial command to argument -3 27
% set forward [compose [compose sin cos] cube] ;# omitting to print result % set backward [compose croot [compose acos asin]] % {*}$forward 0.5 0.8372297964617733 % {*}$backward [{*}$forward 0.5] 0.5000000000000017</lang> Obviously, the (C) library implementation of some of the trigonometric functions (on which Tcl depends for its implementation) on the platform used for testing is losing a little bit of accuracy somewhere.
TI-89 BASIC
See the comments at Function as an Argument#TI-89 BASIC for more information on first-class functions or the lack thereof in TI-89 BASIC. In particular, it is not possible to do proper function composition, because functions cannot be passed as values nor be closures.
Therefore, this example does everything but the composition.
(Note: The names of the inverse functions may not display as intended unless you have the “TI Uni” font.)
<lang ti89b>Prgm
Local funs,invs,composed,x,i
Define rc_cube(x) = x^3 © Cannot be local variables Define rc_curt(x) = x^(1/3)
Define funs = {"sin","cos","rc_cube"}
Define invs = {"sin","cos","rc_curt"}
Define x = 0.5 Disp "x = " & string(x) For i,1,3 Disp "f=" & invs[i] & " g=" & funs[i] & " f(g(x))=" & string(#(invs[i])(#(funs[i])(x))) EndFor
DelVar rc_cube,rc_curt © Clean up our globals
EndPrgm</lang>
Ursala
The algorithm is to zip two lists of functions into a list of pairs of functions, make
that a list of functions by composing each pair, "gang" the list of
functions into a single function returning a list, and apply it to the
argument 0.5.
<lang Ursala>#import std
- import flo
functions = <sin,cos,times^/~& sqr> inverses = <asin,acos,math..cbrt>
- cast %eL
main = (gang (+)*p\functions inverses) 0.5</lang> In more detail,
(+)*p\functions inversesevaluates to(+)*p(inverses,functions)by definition of the reverse binary to unary combinator (\)- This expression evaluates to
(+)*p(<asin,acos,math..cbrt>,<sin,cos,times^/~& sqr>)by substitution. - The zipping is indicated by the
psuffix on the map operator, (*) so that(+)*pevaluates to(+)* <(asin,sin),(acos,cos),(cbrt,times^/~& sqr)>. - The composition (
(+)) operator is then mapped over the resulting list of pairs of functions, to obtain the list of functions<asin+sin,acos+cos,cbrt+ times^/~& sqr>. gang<aisn+sin,acos+cos,cbrt+ times^/~& sqr>expresses a function returning a list in terms of a list of functions.
output:
<5.000000e-01,5.000000e-01,5.000000e-01>
- Programming Tasks
- Programming language concepts
- ActionScript
- Ada
- Aikido
- Aikido examples needing attention
- Examples needing attention
- ALGOL 68
- AutoHotkey
- AutoHotkey examples needing attention
- Axiom
- BBC BASIC
- Bori
- C
- C sharp
- C++
- Clojure
- CoffeeScript
- Common Lisp
- D
- Dart
- Dart examples needing attention
- Déjà Vu
- Déjà Vu examples needing attention
- E
- Ela
- F Sharp
- Factor
- Fantom
- Forth
- GAP
- Go
- Groovy
- Haskell
- Icon
- Unicon
- J
- Java
- JavaScript
- Lua
- Maple
- Mathematica
- Maxima
- Mercury
- Nemerle
- NewLISP
- OCaml
- Octave
- Octave examples needing attention
- Oz
- Oz examples needing attention
- PARI/GP
- Perl
- Perl 6
- PHP
- PicoLisp
- Prolog
- Python
- R
- R examples needing attention
- Racket
- REBOL
- REBOL examples needing attention
- Ruby
- Scala
- Scheme
- Slate
- Slate examples needing attention
- Smalltalk
- Standard ML
- Tcl
- TI-89 BASIC
- Ursala
- AWK/Omit
- Fortran/Omit
- Gnuplot/Omit
- LaTeX/Omit
- Make/Omit
- Pascal/Omit
- PlainTeX/Omit
- PureBasic/Omit
- Functions and subroutines