User:Coderjoe/Sandbox2

Nemerle

Translation of: Python

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

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>

1. let croot x = x ** (1. /. 3.) ;;

val croot : float -> float = <fun>

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

1. let funclist = [sin; cos; cube] ;;

val funclist : (float -> float) list = [<fun>; <fun>; <fun>]

1. let funclisti = [asin; acos; croot] ;;

val funclisti : (float -> float) list = [<fun>; <fun>; <fun>]

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

Works with: PARI/GP version 2.4.2 and above

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

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>

Perl 6

Works with: Rakudo version 2011.06

<lang perl6>sub compose (&g, &f) { return { g f $^x } }

my $x = *.sin; my $xi = *.asin; my $y = *.cos; my $yi = *.acos; my $z = * ** 3; my $zi = * ** (1/3);

my @functions = $x, $y, $z; my @inverses = $xi, $yi, $zi;

for @functions Z @inverses { say compose($^g, $^f)(.5) }</lang> Output:

0.5
0.5
0.5