First-class functions: Difference between revisions

 

{{trans|JavaScript}}

var cube:Function = function(x) {

return Math.pow(x, 3);

}

 

Output:

<pre>

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.

 

Ada.Integer_Text_IO,

Ada.Text_IO,

end;

end loop;

 

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.

{{incomplete|Aikido|Fails to 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}}

{{trans|Javascript}}

import math

 

}

 

 

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

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

parsing, and then - if run out of scope - rejects during runtime.

OP ** = (REAL x, power)REAL: exp(ln(x)*power);

 

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

Output:

<pre>+.500000000000000e +0

AppleScript does not have built-in functions like sine or cosine.

 

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

on compose(f, g)

call(0.5)

end repeat

 

Putting math libraries aside for the moment (we can always shell out to bash functions like '''bc'''), a deeper issue is that the architectural position of functions in the AppleScript type system is simply a little too incoherent and second class to facilitate really frictionless work with first-class functions. (This is clearly not what AppleScript was originally designed for).

Once we have a function like mReturn, however, we can readily write higher order functions like '''map''', '''zipWith''' and '''mCompose''' below.

 

set fs to {sin_, cos_, cube_}

on acos:r

(do shell script "echo 'a(sqrt(1-" & r & "^2)/" & r & ")' | bc -l") as real

{{Out}}

 

=={{header|AutoHotkey}}==

By '''just me'''. [http://ahkscript.org/boards/viewtopic.php?f=17&t=1363&p=16454#p16454 Forum Post]

; Set the floating-point precision

SetFormat, Float, 0.15

Result .= "`n" . Compose(FuncArray1[Index], FuncArray2[Index]).(X)

MsgBox, 0, First-Class Functions, % Result

 

{{Output}}

=={{header|Axiom}}==

Using the interpreter:

inv := [asin$Float, acos$Float, (x:Float):Float +-> x^(1/3)]

Using the Spad compiler:

TestPackage(T:SetCategory) : with

_*: (List((T->T)),List((T->T))) -> (T -> List T)

import MappingPackage3(T,T,T)

fs * gs ==

This would be called using:

Output:

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

Strictly speaking you cannot return a ''function'', but you can return a ''function pointer'' which allows the task to be implemented.

DEF FNsin(a) = SIN(a)

DEF FNasn(a) = ASN(a)

DIM p% LEN(f$) + 4

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

'''Output:'''

<pre>

 

=={{header|Bori}}==

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

double cos (double d) { return Math.cos(d); }

}

label1.setText(s);

Output on Android phone:

0.4999999999999999

 

=={{header|Bracmat}}==

The <code>compose</code> function uses macro substitution.

& (log=.e\L!arg)

& (A=x2d (=.!arg^2) log (=.!arg*pi))

& out$((compose$(!F.!G))$3210)

)

Output:

<pre>3210

Here goes.

 

#include <stdio.h>

#include <math.h>

return 0;

===Non-portable function body duplication===

Following code generates true functions at run time. Extremely unportable, and [http://en.wikipedia.org/wiki/Considered_harmful 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).

#include <stdlib.h>

#include <string.h>

}

return 0;

C0(0.4) = 0.4

C0(0.6) = 0.6

C2(0.6) = 0.6

C2(0.8) = 0.8

 

=={{header|C sharp|C#}}==

 

class Program

}

}

 

Output:

{{works with|C++11}}

 

#include <functional>

#include <algorithm>

return 0;

}

 

=={{header|Ceylon}}==

{{works with|Ceylon 1.2.1}}

First, you need to import the numeric module in you module.ceylon file

import ceylon.numeric "1.2.1";

And then you can use the math functions in your run.ceylon file

 

sin, exp, asin, log

print(compose(func, inv)(0.5));

}

 

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

Output:

<pre>(0.5 0.4999999999999999 0.5000000000000001)</pre>

=={{header|CoffeeScript}}==

{{trans|JavaScript}}

cube = (x) -> Math.pow x, 3

cuberoot = (x) -> Math.pow x, 1 / 3

 

# Applying the composition to 0.5

Output:

<pre>0.5

 

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

(defun cube (x) (expt x 3))

(defun cube-root (x) (expt x (/ 3)))

func

value

 

Output:

 

(#<FUNCTION ACOS> ∘ #<FUNCTION COS>)(0.5) = 0.5

 

=={{header|D}}==

===Using Standard Compose===

import std.stdio, std.math, std.typetuple, std.functional;

 

foreach (immutable i, f; dir)

writefln("%6.3f", compose!(f, inv[i])(0.5));

{{out}}

<pre> 0.500

===Defining Compose===

Here we need wrappers because the standard functions have different signatures (eg pure/nothrow). Same output.

import std.stdio, std.math, std.range;

 

foreach (f, g; [sin, cos, cube].zip([asin, acos, cbrt]))

writefln("%6.3f", compose(f, g)(0.5));

 

=={{header|Dart}}==

cube(x) => x*x*x;

cuberoot(x) => Math.pow(x, 1/3);

print(compose(functions[i], inverses[i])(0.5));

}

{{out}}

<pre>

{{libheader| System.Math}}

{{Trans|C#}}

program First_class_functions;

 

 

readln;

{{out}}

<pre>0.50

Using partial application:

 

 

func sum(x, y) { x + y }

 

 

===Store functions in collections===

 

func doubleMe(x) { x + x }

 

var arr = []

 

===Use functions as arguments to other functions===

 

for x in this when pred(x) {

yield x

}

 

 

===Use functions as return values of other functions===

 

(y, x) => fun(x, y)

 

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

- 0

 

else:

!print "Something went wrong."

 

{{out}}

The relevant mathematical operations are provided as methods on floats, so the first thing we must do is define them as functions.

 

def cos(x) { return x.cos() }

def asin(x) { return x.asin() }

 

def forward := [sin, cos, cube]

 

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. <code>fn ''params'' { ''expr'' }</code> is shorthand for an anonymous function returning a value.

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

 

> for i => f in forward {

> def g := reverse[i]

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

 

Note: <code>def g := reverse[i]</code> is needed here because E as yet has no defined protocol for iterating over collections in parallel. [http://wiki.erights.org/wiki/Parallel_iteration Page for this issue.]

 

=={{header|EchoLisp}}==

;; adapted from Racket

;; (compose f g h ... ) is a built-in defined as :

0.4999999999999999

0.5

 

=={{header|Ela}}==

Translation of Haskell:

 

open list //zipWith

 

funclisti = [asin, acos, croot]

 

 

Function (<<) is defined in standard prelude as:

 

 

Output (calculations are performed on 32-bit floats):

 

 

=={{header|Elena}}==

import system'math;

import extensions'routines;

fs.zipBy(gs, (f,g => 0.5r.compose(f,g)))

{{out}}

<pre>

 

=={{header|Elixir}}==

def task(val) do

as = [&:math.sin/1, &:math.cos/1, fn x -> x * x * x end]

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module( first_class_functions ).

 

 

square_inverse( X ) -> math:sqrt( X ).

{{out}}

<pre>

 

=={{header|F_Sharp|F#}}==

 

let cube x = x ** 3.0

let main() = for f in composed do printfn "%f" (f 0.5)

 

 

Output:

=={{header|Factor}}==

The constants A and B consist of arrays containing quotations (aka anonymous functions).

IN: rosettacode.first-class-functions

 

: test-fcf ( -- )

0.5 A B compose-all

{{out}}

<pre>{ 0.5 0.4999999999999999 0.5 }</pre>

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.

 

class FirstClassFns

{

}

}

 

Output:

 

=={{header|Forth}}==

>r >r :noname

r> compile,

loop ;

 

 

=={{header|FreeBASIC}}==

Like C, FreeBASIC doesn't have first class functions so I've contented myself by translating their code:

{{trans|C}}

 

#Include "crt/math.bi" '' include math functions in C runtime library

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|GAP}}==

Composition := function(f, g)

local h;

# Now a test

ApplyList(z, 3);

 

=={{header|Go}}==

 

import "math"

fmt.Println(compose(funclisti[i], funclist[i])(.5))

}

Output:

<pre>

=={{header|Groovy}}==

Solution:

 

Test program:

def cubeRoot = { it ** (1/3) }

 

 

println ([funcList, inverseList].transpose().collect { f, finv -> compose(f, finv) }.collect{ it(0.5) })

 

Output:

 

=={{header|Haskell}}==

cube x = x ** 3.0

 

 

main :: IO ()

{{output}}

<pre>[0.5,0.4999999999999999,0.5000000000000001]</pre>

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

The Unicon solution can be modified to work in Icon. See [[Function_composition#Icon_and_Unicon]].

procedure main(arglist)

 

procedure cuberoot(x)

return x ^ (1./3)

Please refer to See [[Function_composition#Icon_and_Unicon]] for 'compose'.

 

 

However, here are the basics which were requested:

cos=: 2&o.

cube=: ^&3

A=: sin`cos`cube`square

B=: monad def'y unqo inv quot'"0 A

 

0.479426 0.877583 0.125 0.25

BA unqcol 0.5

 

===Tacit (unorthodox) version===

In J only adverbs and conjunctions (functionals) can produce verbs (functions)... Unless they are forced to cloak as verbs (functions). (Note that this takes advantage of a bug/feature of the interpreter ; see [http://rosettacode.org/wiki/Closures/Value_capture#Tacit_.28unorthodox.29_version unorthodox tacit] .) The resulting functions (which correspond to functionals) can take and produce functions:

 

inverse=. (<'^:')(0:`)(,^:)&_1 NB. Producing the function inverse corresponding to the functional ^:_1

compose=. (<'@:')(0:`)(,^:) NB. Producing the function compose corresponding to the functional @:

BA of &> 0.5 NB. Evaluating the compositions at 0.5

0.5 0.5 0.5

 

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

{{works with|Java|1.5+}}

 

public class FirstClass{

System.out.println(Math.pow(Math.sqrt(0.5), 2));

}

Output:

<pre>Compositions:

 

{{works with|Java|8+}}

import java.util.function.Function;

 

System.out.println(Math.pow(Math.sqrt(0.5), 2));

}

 

=={{header|JavaScript}}==

===ES5===

var cube = function (x) {

return Math.pow(x, 3);

// Applying the composition to 0.5

console.log(compose(inv[i], fun[i])(0.5));

 

===ES6===

var cube = x => Math.pow(x, 3);

 

// Applying the composition to 0.5

console.log(compose(inv[i], fun[i])(0.5));

 

 

0.4999999999999999

0.5</pre>

 

=={{header|Julia}}==

 

function compose(f::Function, g::Function)

func, inverse = pair

println(compose(func, inverse)(value))

 

Output:

 

=={{header|Kotlin}}==

 

fun compose(f: (Double) -> Double, g: (Double) -> Double ): (Double) -> Double = { f(g(it)) }

fun cube(d: Double) = d * d * d

 

val x = 0.5

for (i in 0..2) println(compose(listA[i], listB[i])(x))

 

{{out}}

=={{header|Lambdatalk}}==

Tested in [http://epsilonwiki.free.fr/ELS_YAW/?view=p227]

{def cube {lambda {:x} {pow :x 3}}}

{def cuberoot {lambda {:x} {pow :x {/ 1 3}}}}

0.49999999999999994

0.5000000000000001

 

=={{header|Lasso}}==

 

define cube(x::decimal) => {

)

 

 

Output:

=={{header|Lingo}}==

Lingo does not support functions as first-class objects. But with the limitations described under [https://www.rosettacode.org/wiki/Function_composition#Lingo Function composition] the task can be solved:

A = [#sin, #cos, #square]

B = [#asin, #acos, #sqrt]

res = call(f, _movie, testValue)

put res = testValue

 

{{out}}

 

User-defined arithmetic functions used in code above:

return x*x

end

on acos (x)

return PI/2 - asin(x)

 

=={{header|Lua}}==

 

fn = {math.sin, math.cos, function(x) return x^3 end}

local f = compose(v, inv[i])

print(f(0.5))

 

Output:

0.5

 

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

Cos, Sin works with degrees, Number pop number from stack of values, so we didn't use a variable like this POW3INV =Lambda (x)->x**(1/3)

Module CheckFirst {

RAD = lambda -> number/180*pi

}

CheckFirst

 

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

> A := [ sin, cos, x -> x^3 ]:

> B := [ arcsin, arccos, rcurry( surd, 3 ) ]:

> zip( `@`, B, A )( 2/3 );

[2/3, 2/3, 2/3]

 

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

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.

funcsi = {ArcSin, ArcCos, #^(1/3) &};

compositefuncs = Composition @@@ Transpose[{funcs, funcsi}];

gives back:

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:

f@g@h@x

all give back:

 

=={{header|Maxima}}==

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

 

=={{header|Mercury}}==

 

===firstclass.m===

:- module firstclass.

 

write_list(Results, ", ", write_float, !IO),

write_string("\n", !IO).

 

===Use and output===

{{works with|min|0.19.3}}

Note <code>concat</code> is what performs the function composition, as functions are lists in min.

('asin 'acos (1 3 / pow)) =B

 

A rest #A

B rest #B

{{out}}

<pre>

 

{{trans|Python}}

using System.Console;

using System.Math;

WriteLine($[compose(f, g)(0.5) | (f, g) in ZipLazy(funcs, ifuncs)]);

}

 

===Use and Output===

 

=={{header|newLISP}}==

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

> (define (cube x) (pow x 3))

> (map (fn (f g) ((compose f g) 0.5)) functions inverses)

(0.5 0.5 0.5)

 

=={{header|Nim}}==

 

math.pow(x, 3)

 

math.pow(x, 1/3)

 

proc compose[A](f: proc(x: A): A, g: proc(x: A): A) : (proc(x: A): A) =

f(g(x))

return c

 

math.sin(x)

math.arccos(x)

 

 

for i in 0..2:

Output:

<pre>0.5

 

=={{header|Objeck}}==

 

lambdas Func {

func(13.5)->Get()->PrintLine();

}

 

=={{header|OCaml}}==

val cube : float -> float = <fun>

 

 

# List.map2 (fun f inversef -> (compose inversef f) 0.5) funclist funclisti ;;

 

=={{header|Octave}}==

r = x.^3;

endfunction

for i = 1:3

disp(compose(f1{i}, f2{i})(.5))

 

{{Out}}

 

=={{header|Oforth}}==

 

[ #cos, #sin, #[ 3 pow ] ] [ #acos, #asin, #[ 3 inv powf ] ] zipWith(#compose)

map(#[ 0.5 swap perform ]) conform(#[ 0.5 == ]) println

{{Out}}

<pre>

 

=={{header|Ol}}==

; creation of new function from preexisting functions at run-time

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

(define identity (compose (ref collection 2) (ref collection 1)))

(print (identity 11211776))

 

=={{header|Oz}}==

(To be executed in the Oz OPI, by typing ctl+. ctl+b)

 

 

fun {Compose F G}

{Show {{Compose I F} 0.5}}

end

This will output the following in the Emulator output window

0.5

0.5

0.5

 

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

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

x -> f(g(x))

};

print(compose(A[i],B[i])(.5))

)

Usage note: In Pari/GP 2.4.3 the vectors can be written as

 

Output:

 

=={{header|Perl}}==

 

sub compose {

print join "\n", map {

compose($flist1[$_], $flist2[$_]) -> (0.5)

Output:

<pre>0.5

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

 

=={{header|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 <tt>call_user_func</tt>. So PHP could be said to have ''some'' first class functionality.

 

return function ($x) use ($f, $g) {

return $f($g($x));

$f = $compose($inv[$i], $fn[$i]);

echo $f(0.5), PHP_EOL;

 

Output:

 

=={{header|PicoLisp}}==

 

(de compose (F G)

(prinl (format ((compose Inv Fun) 0.5) *Scl)) )

'(sin cos cube)

Output:

<pre>0.500001

=={{header|PostScript}}==

 

% PostScript has 'sin' and 'cos', but not these

/asin { dup dup 1. add exch 1. exch sub mul sqrt atan } def

.5 exch exec ==

} for

 

=={{header|Prolog}}==

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

 

 

 

% we display the results

maplist(writeln, R).

Output :

<pre> ?- first_class.

=={{header|Python}}==

 

>>> from math import sin, cos, acos, asin

>>> # Add a user defined function and its inverse

>>> [compose(inversef, f)(.5) for f, inversef in zip(funclist, funclisti)]

[0.5, 0.4999999999999999, 0.5]

 

 

Or, equivalently:

{{Works with|Python|3.7}}

 

from math import (acos, cos, asin, sin)

 

if __name__ == '__main__':

{{Out}}

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

 

=={{header|R}}==

croot <- function(x) x^(1/3)

compose <- function(f, g) function(x){f(g(x))}

for(i in 1:3) {

print(compose(f1[[i]], f2[[i]])(.5))

 

{{Out}}

Alternatively:

 

 

{{Out}}

 

=={{header|Racket}}==

 

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

(for ([f funlist] [i ifunlist])

 

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

 

my \𝐵 = &asin, &acos, { $_ ** <1/3> }

 

<pre>0.5

 

 

my @op = &infix:<+>, &infix:<->, &infix:<*>;

 

{{output}}

=={{header|REBOL}}==

{{incomplete|REBOL|Fails to 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}}

Title: "First Class Functions"

URL: http://rosettacode.org/wiki/First-class_functions

 

A: next A B: next B ; Advance to next pair.

 

=={{header|REXX}}==

These six functions (generally) only support non-negative integers, so a special test in the program below only

<br>supplies appropriate integers when testing the first function listed in the &nbsp; '''A''' &nbsp; collection.

A = 'd2x square sin cos' /*a list of functions to demonstrate.*/

B = 'x2d sqrt Asin Acos' /*the inverse functions of above list. */

right(inv@, 3*w)'='left(left('', invV>=0)invV, w)

end /*k*/

'''output'''

<pre>

 

=={{header|Ruby}}==

croot = proc{|x| x ** (1.quo 3)}

compose = proc {|f,g| proc {|x| f[g[x]]}}

invlist = [Math.method(:asin), Math.method(:acos), croot]

 

 

{{out}}

This solution uses a feature of Nightly Rust that allows us to return a closure from a function without using the extra indirection of a pointer. Stable Rust can also accomplish this challenge -- the only difference being that compose would return a <code>Box<Fn(T) -> V></code> which would result in an extra heap allocation.

 

fn main() {

let cube = |x: f64| x.powi(3);

move |x| g(f(x))

 

 

=={{header|Scala}}==

 

// functions as values

 

// output results of applying the functions

Output:

<pre>0.5 0.4999999999999999 0.5000000000000001</pre>

Here's how you could add a composition operator to make that syntax prettier:

 

def o[A](g: A => B) = (x: A) => f(g(x))

}

 

// now functions can be composed thus

 

=={{header|Scheme}}==

(define (cube x) (expt x 3))

(define (cube-root x) (expt x (/ 1 3)))

(go (cdr f) (cdr g)))))

 

Output:

0.5

=={{header|Sidef}}==

{{trans|Perl}}

func (*args) {

f(g(args...))

for a,b (flist1 ~Z flist2) {

say compose(a, b)(0.5)

{{out}}

<pre>

Compose is already defined in slate as (note the examples in the comment):

 

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

].

 

used as:

n@(Number traits) cubeRoot [n raisedTo: 1 / 3].

define: #forward -> {#cos `er. #sin `er. #cube `er}.

 

define: #composedMethods -> (forward with: reverse collect: #compose: `er).

 

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

"commodities"

Number extend [

].

 

 

Output:

 

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

val cube = fn : real -> real

- fun croot x = Math.pow(x, 1.0 / 3.0);

val funclisti = [fn,fn,fn] : (real -> real) list

- ListPair.map (fn (f, inversef) => (compose (inversef, f)) 0.5) (funclist, funclisti);

 

=={{header|Stata}}==

In Mata it's not possible to get the address of a builtin function, so here we define user functions.

 

return(sin(x))

}

for(i=1;i<=length(a);i++) {

printf("%10.5f\n",compose(a[i],b[i],0.5))

 

=={{header|SuperCollider}}==

a = [sin(_), cos(_), { |x| x ** 3 }];

b = [asin(_), acos(_), { |x| x ** (1/3) }];

c = a.collect { |x, i| x <> b[i] };

c.every { |x| x.(0.5) - 0.5 < 0.00001 }

 

=={{header|Swift}}==

{{works with|Swift|1.2+}}

func compose<A,B,C>(f: (B) -> C, g: (A) -> B) -> (A) -> C {

return { f(g($0)) }

let funclist = [ { (x: Double) in sin(x) }, { (x: Double) in cos(x) }, { (x: Double) in pow(x, 3) } ]

let funclisti = [ { (x: Double) in asin(x) }, { (x: Double) in acos(x) }, { (x: Double) in cbrt(x) } ]

{{out}}

<pre>

The following is a transcript of an interactive session:<br>

{{works with|tclsh|8.5}}

% proc cube x {expr {$x**3}}

% proc croot x {expr {$x**(1/3.)}}

0.8372297964617733

% {*}$backward [{*}$forward 0.5]

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.

 

(Note: The names of the inverse functions may not display as intended unless you have the “TI Uni” font.)

 

Local funs,invs,composed,x,i

 

 

DelVar rc_cube,rc_curt © Clean up our globals

 

=={{header|TXR}}==

<code>chain</code> composes a variable number of functions, but unlike <code>compose</code>, from left to right, not right to left.

 

cos

(op expt @1 3)])

 

(each ((f funlist) (i invlist))

 

{{out}}

functions into a single function returning a list, and apply it to the

argument 0.5.

#import flo

 

#cast %eL

 

In more detail,

* <code>(+)*p\functions inverses</code> evaluates to <code>(+)*p(inverses,functions)</code> by definition of the reverse binary to unary combinator (<code>\</code>)

=={{header|Wren}}==

In Wren, there is a distinction between functions and methods. Essentially, the former are independent objects which can do all the things required of 'first class functions' and the latter are subroutines which are tied to a particular class. As sin, cos etc. are instance methods of the Num class, we need to wrap them in functions to complete this task.

 

var A = [

for (i in 0..2) {

System.print(compose.call(A[i], B[i]).call(x))

 

{{out}}

0.5

0.5

</pre>

 

=={{header|zkl}}==

In zkl, methods bind their instance so something like x.sin is the sine method bound to x (whatever real number x is). eg var a=(30.0).toRad().sin; is a method and a() will always return 0.5 (ie basically a const in this case). Which means you can't just use the word "sin", it has to be used in conjunction with an instance.

var b=T(fcn(x){ x.asin().toDeg() }, fcn(x){ x.acos().toDeg() }, fcn(x){ x.pow(1.0/3) });

 

ab.run(True,5.0); //-->L(5.0,5.0,5.0)

 

fcomp is the function composition function, fcomp(b,a) returns the function (x)-->b(a(x)). List.run(True,x) is inverse of List.apply/map, it returns a list of list[i](x). The True is to return the result, False is just do it for the side effects.

 

{{omit from|PlainTeX}}

{{omit from|PureBasic}}

{{omit from|TI-83 BASIC|Cannot define functions.}}