First-class functions/Use numbers analogously: Difference between revisions

In [[First-class functions]], a language is showing how its manipulation of functions is similar to its manipulation of other types.

 

 

 

 

<small>To paraphrase the task description: Do what was done before, but with numbers rather than functions</small>

 

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

{{trans|python}}{{wont work with|ALGOL 68|Revision 1 - scoping rules forbid exporting a procedure out of it's scope}}

{{wont work with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny] - scoping rules forbid exporting a procedure out of it's scope - detected at compile time and again at runtime}}

 

Note: Standard ALGOL 68's scoping rules forbids exporting a '''proc'''[edure] (or '''format''') out of it's scope (closure). Hence this specimen will run on [[ELLA ALGOL 68]], but is non-standard. For a discussion of first-class functions in ALGOL 68 consult [http://www.cs.ru.nl/~kees/home/papers/psi96.pdf "The Making of Algol 68"] - [[wp:Cornelis_H.A._Koster|C.H.A. Koster]] (1993). <!-- Retrieved April 28, 2007 -->

x := 2,

xi := 0.5,

inv n = inv num list[key];

print ((multiplier(inv n, n)(.5), new line))

Output:

<pre>

+.500000000000000e +0

</pre>

 

=={{header|Axiom}}==

(z,zi) := (x+y,1/(x+y))

(numbers,invers) := ([x,y,z],[xi,yi,zi])

multiplier(a:Float,b:Float):(Float->Float) == (m +-> a*b*m)

We can also curry functions, possibly with function composition, with the same output as before:

[mult(number*inver) 0.5 for number in numbers for inver in invers]

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

[(f*g) 0.5 for f in fns for g in inv]

- which has the same output.

 

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

{{works with|C#|4.0}}

The structure here is exactly the same as the C# entry in [[First-class functions]]. The "var" keyword allows us to use the same initialization code for an array of doubles as an array of functions. Note that variable names have been changed to correspond with the new functionality.

using System.Linq;

 

}

}

 

=={{header|Clojure}}==

(def xi 0.5)

(def y 4.0)

> (for [[n i] (zipmap numbers invers)]

((multiplier n i) 0.5))

For comparison:

(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|Common Lisp}}==

 

#'(lambda (x) (* f g x)))

 

inverse

value

 

Output:

The code from [[First-class functions]], for comparison:

 

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

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

function

value

 

Output:

 

=={{header|D}}==

 

 

 

 

Output:

 

=={{header|E}}==

This is written to have identical structure to [[First-class functions#E]], though the variable names are different.

 

def xi := 0.5

def y := 4.0

def b := reverse[i]

println(`s = $s, a = $a, b = $b, multiplier($a, $b)($s) = ${multiplier(a, b)(s)}`)

 

Output:

 

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

CONSTANT: x 2.0

CONSTANT: xi 0.5

CONSTANT: y 4.0

CONSTANT: yi .25

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

The <code>combine</code> function is very similar to the <code>compose</code> function in 'First-class functions'. In both cases a new function is returned:

 

static |Obj -> Obj| compose (|Obj -> Obj| fn1, |Obj -> Obj| fn2)

{

return |Obj x -> Obj| { fn2 (fn1 (x)) }

}

 

=={{header|Go}}==

At point C, numbers and their inverses have been multiplied and bound to first class functions. The ordered collection arrays could be modified at this point and the function objects would be unaffected.

 

 

import "fmt"

return n1n2 * m

}

Output:

<pre>

 

At point C, changes to x, xi, y, and yi will still propagate through and affect the results returned by the mfs objects. This can be seen as like the First-class functions task in that nothing (nothing numberic anyway) is evaluated until the final composed objects are evaluated.

 

import "fmt"

panic("unsupported multiplier type")

return 0 // never reached

 

=={{header|Haskell}}==

 

where

 

in printf "%f * %f * 0.5 = %f\n" number inverse (new_function 0.5)

mapM_ print_pair pairs

 

This is very close to the first-class functions example, but given as a full Haskell program rather than an interactive session.

[[First-class functions]] task solution. The solution here

is simpler and more direct since it handles a specific function definition.

 

procedure main(A)

procedure multiplier(n1,n2)

return makeProc { repeat inVal := n1 * n2 * (inVal@&source)[1] }

 

A sample run:

 

=={{header|J}}==

This seems to satisfy the new problem statement:

 

xi =: 0.5

y =: 4.0

rev =: xi,yi,zi

 

 

Example use:

 

 

For contrast, here are the final results from [[First-class functions#J]]:

 

 

 

 

 

 

 

 

=={{header|Nemerle}}==

{{trans|Python}}

using System.Console;

using Nemerle.Collections.NCollectionsExtensions;

WriteLine($[multiplier(n, m) (0.5)|(n, m) in ZipLazy(nums, inums)]);

}

 

=={{header|OCaml}}==

 

 

# let y = 4.0;;

(* or just apply the generated function immediately... *)

# List.map2 (fun n inv -> (multiplier n inv) 0.5) coll inv_coll;;

 

=={{header|Oz}}==

 

[X Y Z] = [2.0 4.0 Z=X+Y]

do

{Show {{Multiplier N I} 0.5}}

 

"Multiplier" is like "Compose", but with multiplication instead of function application. Otherwise the code is identical except for the argument types (numbers instead of functions).

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

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

x -> n1 * n2 * x

};

print(multiplier(y,yi)(0.5));

print(multiplier(z,zi)(0.5));

The two are very similar, though as requested the test numbers are in 6 variables instead of two vectors.

my $x = 2.0;

my $xi = 0.5;

my $zi = 1.0 / ( $x + $y );

 

Output:

<pre>0.5

0.5

 

=={{header|PicoLisp}}==

 

(de multiplier (N1 N2)

(prinl (format ((multiplier Inv Num) 0.5) *Scl)) )

(list X Y Z)

Output:

<pre>0.500000

that the function 'multiplier' above accepts two numbers, while 'compose'

below accepts two functions:

 

(de compose (F G)

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

'(sin cos cube)

With a similar output:

<pre>0.500001

=={{header|Python}}==

This new task:

>>> # Number literals

>>> x,xi, y,yi = 2.0,0.5, 4.0,0.25

>>> [multiplier(inversen, n)(.5) for n, inversen in zip(numlist, numlisti)]

[0.5, 0.5, 0.5]

 

The Python solution to First-class functions for comparison:

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

As can be see, the treatment of functions is very close to the treatment of numbers. there are no extra wrappers, or function pointer syntax added, for example.

 

=={{header|R}}==

x = 2.0

xi = 0.5

Output

[1] 0.5 0.5 0.5

 

Compared to original first class functions

 

=={{header|Ruby}}==

numlist = [x=2, y=4, x+y]

invlist = [0.5, 0.25, 1.0/(x+y)]

p numlist.zip(invlist).map {|n, invn| multiplier[invn, n][0.5]}

 

This structure is identical to the treatment of Ruby's [[First-class functions#Ruby|first-class functions]] -- create a Proc object that returns a Proc object (a closure). These examples show that 0.5 times number ''n'' (or passed to function ''f'') times inverse of ''n'' (or passed to inverse of ''f'') returns the original number, 0.5.

 

=={{header|Scala}}==

x: Double = 2.0

 

0.5

0.5

 

=={{header|Scheme}}==

This implementation closely follows the Scheme implementation of the [[First-class functions]] problem.

(define xi 0.5)

(define y 4.0)

(newline))

n1 n2))

Output:

0.5

0.5

0.5

 

=={{header|Slate}}==

{{incorrect|Slate|Compare and contrast the resultant program with the corresponding entry in First-class functions.}}

define: #x -> 2.

define: #y -> 4.

define: #numlisti -> (numlist collect: [| :x | 1.0 / x]).

 

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

proc multiplier {a b} {

list apply {{ab m} {expr {$ab*$m}}} [expr {$a*$b}]

Note that, as with Tcl's solution for [[First-class functions#Tcl|First-class functions]], the resulting term must be expanded on application. For example, study this interactive session:

apply {{ab m} {expr {$ab*$m}}} 6

% {*}$mult23 5

Formally, for the task:

set xi 0.5

set y 4.0

foreach a $numlist b $numlisti {

puts [format "%g * %g * 0.5 = %g" $a $b [{*}[multiplier $a $b] 0.5]]

Which produces this output:

<pre>2 * 0.5 * 0.5 = 0.5

4 * 0.25 * 0.5 = 0.5

6 * 0.166667 * 0.5 = 0.5</pre>

 

=={{header|Ursala}}==

composition operator (+), and is named in compliance

with the task specification.

#import flo

 

#cast %eL

 

The multiplier could have been written in pattern

matching form like this.

The main program might also have been written with an

anonymous function like this.

output:

<pre>

</pre>

 

{{omit from|Java|Can't pass around expressions like that.}}

{{omit from|PureBasic}}

[[Category:Functions and subroutines]]