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

{{trans|Python}}

V z = x + y

V zi = 1.0 / (x + y)

V numlist = [x, y, z]

V numlisti = [xi, yi, zi]

{{out}}

=={{header|Ada}}==

procedure Firstclass is

generic

end;

end loop;

{{out}}

<pre>5.00000E-01

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>

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

[multiplier(number,inver) 0.5 for number in numbers for inver in invers]

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]

Using the Spad code in [[First-class functions#Axiom]], this can be done more economically using:

For comparison, [[First-class functions#Axiom]] gave:

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

{{works with|BBC BASIC for Windows}}

x = 2 : xi = 1/2

y = 4 : yi = 0.25

DIM p% LEN(f$) + 4

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

'''Output:'''

<pre>

</pre>

Compare with the implementation of First-class functions:

DEF FNsin(a) = SIN(a)

DEF FNasn(a) = ASN(a)

DIM p% LEN(f$) + 4

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

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

#include <iostream>

}

}

{{out}}

<pre>

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

auto multiplier(double a, double b)

writefln("%f * %f * %f == %f", f[i], r[i], 1.0, mult(1));

}

Output:

<pre>2.000000 * 0.500000 * 1.000000 == 1.000000

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:

{{trans|C#}}

ELENA 5.0 :

import extensions;

multiplied.forEach:(multiplier){ console.printLine(multiplier(0.5r)) }

{{out}}

<pre>

=={{header|Erlang}}==

-module( first_class_functions_use_numbers ).

multiplier( N1, N2 ) -> fun(M) -> N1 * N2 * M end.

{{out}}

<pre>

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

let x = 2.0

let xi = 0.5

|> List.map ((|>) 0.5)

|> printfn "%A"

{{out}}

<pre>

=={{header|Factor}}==

Compared to http://rosettacode.org/wiki/First-class_functions, the call to "compose" is replaced with the call to "mutliplier"

IN: q

: example ( -- )

0.5 A B create-all

{{out}}

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

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

[[/Go interface type|This can also be done with an interface type]] rather than the "empty interface" (<code>interface{}</code>) for better type safety and to avoid the <code>eval</code> function and type switch.

import "fmt"

panic("unsupported multiplier type")

return 0 // never reached

=={{header|Groovy}}==

def ε = 0.00000001 // tolerance(epsilon): acceptable level of "wrongness" to account for rounding error

}

println()

{{out}}

<pre>2.000 * 0.500 * 1.000 == 1.000

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

This seems to satisfy the new problem statement:

xi =: 0.5

y =: 4.0

rev =: xi,yi,zi

An equivalent but perhaps prettier definition of multiplier would be:

Or, if J's "right bracket is the right identity function" bothers you, you might prefer the slightly more verbose but still equivalent:

Example use:

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

===Tacit (unorthodox) version===

Although the pseudo-code to generate the numbers can certainly be written (see above [http://rosettacode.org/wiki/First-class_functions/Use_numbers_analogously#Explicit_version Explicit version] ) this is not done for this version because it would destroy part of the analogy (J encourages, from the programming perspective, to process all components at once as opposed to one component at a time). In addition, this version is done in terms of boxed lists of numbers instead of plain list of numbers, again, to preserve the analogy.

]A=. 2 ; 4 ; (2 + 4) NB. Corresponds to ]A=. box (1&o.)`(2&o.)`(^&3)

└───┴───┴───┘

BA of &> 0.5 NB. Corresponds to BA of &> 0.5 (exactly)

Please refer to [http://rosettacode.org/wiki/First-class_functions#Tacit_.28unorthodox.29_version First-class functions tacit (unorthodox) version] for the definitions of the functions train, an and of.

=={{header|jq}}==

It may be helpful to compare the following definition of "multiplier" with its Ruby counterpart [[#Ruby|below]]. Whereas the Ruby definition must name all its positional parameters, the jq equivalent is defined as a filter that obtains them implicitly from its input.

# zip this and that

def zip(that):

def multiplier(j): .[0] * .[1] * j;

{{out}}

$ jq -n -c -f First_class_functions_Use_numbers_analogously.jq

=={{header|JavaScript}}==

const xi = 0.5;

const y = 4.0;

}

{{out}}

<pre>

In Julia, like Python and R, functions can be treated as like as other Types.

y, yi = 4.0, 0.25

z, zi = x + y, 1.0 / ( x + y )

numlisti = [xi, yi, zi]

{{out}}

=={{header|Kotlin}}==

fun multiplier(n1: Double, n2: Double) = { m: Double -> n1 * n2 * m}

println("${multiplier(a[i], ai[i])(m)} = multiplier(${a[i]}, ${ai[i]})($m)")

}

{{out}}

=={{header|Lua}}==

-- This function returns another function that

-- keeps n1 and n2 in scope, ie. a closure.

print(v .. " * " .. invs[k] .. " * 0.5 = " .. new_function(0.5))

end

{{out}}

<pre>

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

Module CheckIt {

\\ by default numbers are double

}

{{out}}

<pre>

This code demonstrates the example using structure similar to function composition, however the composition function is replace with the multiplier function.

num={2,4,2+4};

numi=1/num;

multiplierfuncs = multiplier @@@ Transpose[{num, numi}];

The resulting functions are unity multipliers:

Note that unlike Composition, the above definition of multiplier only allows for exactly two arguments. The definition can be changed to allow any nonzero number of arguments:

=={{header|Nemerle}}==

{{trans|Python}}

using System.Console;

using Nemerle.Collections.NCollectionsExtensions;

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

}

=={{header|Never}}==

func multiplier(a : float, b : float) -> (float) -> float {

let func(m : float) -> float { a * b * m }

0

}

{{output}}

<pre>

=={{header|Nim}}==

func multiplier(a, b: float): auto =

let ab = a * b

let f = multiplier(list[i], invlist[i])

# ... and apply it.

{{out}}

=={{header|Objeck}}==

Similar however this code does not generate a list of functions.

class FirstClass {

}

}

{{output}}

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

: firstClassNum

x y + ->z

x y + inv ->zi

{{out}}

<pre>

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

=={{header|Perl}}==

my ( $n1, $n2 ) = @_;

sub {

print multiplier( $number, $inverse )->(0.5), "\n";

}

Output:

<pre>0.5

</pre>

The entry in first-class functions uses the same technique:

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

...

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

=={{header|Phix}}==

Just as there is no real support for first class functions, not much that is pertinent to this task for numbers either, but the manual way is just as trivial:

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

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

<span style="color: #0000FF;">?</span><span style="color: #000000;">call_multiplier</span><span style="color: #0000FF;">(</span><span style="color: #000000;">multiplier</span><span style="color: #0000FF;">(</span><span style="color: #000000;">y</span><span style="color: #0000FF;">,</span><span style="color: #000000;">yi</span><span style="color: #0000FF;">),</span><span style="color: #000000;">0.5</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #000000;">call_multiplier</span><span style="color: #0000FF;">(</span><span style="color: #000000;">multiplier</span><span style="color: #0000FF;">(</span><span style="color: #000000;">z</span><span style="color: #0000FF;">,</span><span style="color: #000000;">zi</span><span style="color: #0000FF;">),</span><span style="color: #000000;">0.5</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

Compared to first class functions, there are (as in my view there should be) significant differences in the treatment of numbers and functions, but as mentioned on that page tagging ctable entries should be quite sufficient.

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

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

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

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

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

#lang racket

((multiplier n i) 0.5))

;; -> '(0.5 0.5 0.5)

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2015-09-10}}

my $x = 2.0;

my @inverses = $xi, $yi, $zi;

Output:

<pre>0.5

The REXX language doesn't have an easy method to call functions by using a variable name,

<br>but the '''interpret''' instruction can be used to provide that capability.

nums= 2.0 4.0 6.0 /*various numbers, can have fractions.*/

invs= 1/2.0 1/4.0 1/6.0 /*inverses of the above (real) numbers.*/

@: return left( arg(1) / 1, 15) /*format the number, left justified. */

multiplier: procedure expose n1n2; parse arg n1,n2; n1n2= n1 * n2; return 'a_new_func'

{{out|output|text=&nbsp; when using the internal default inputs:}}

<pre>

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

fn main() {

let (x, xi) = (2.0, 0.5);

move |m| x*y*m

}

This is very similar to the [[First-class functions#Rust|first-class functions]] implementation save that the type inference works a little bit better here (e.g. when declaring <code>numlist</code> and <code>invlist</code>) and <code>multiplier</code>'s declaration is substantially simpler than <code>compose</code>'s. Both of these boil down to the fact that closures and regular functions are actually different types in Rust so we have to be generic over them but here we are only dealing with 64-bit floats.

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

=={{header|Sidef}}==

func (n3) {

n1 * n2 * n3

for f,g (numbers ~Z inverses) {

say multiplier(f, g)(0.5)

{{out}}

<pre>

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

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>

=={{header|Wren}}==

{{libheader|Wren-fmt}}

var multiplier = Fn.new { |n1, n2| Fn.new { |m| n1 * n2 * m } }

var m = 0.5 // rather than 1 to compare with first-class functions task

Fmt.print("$0.1g * $g * $0.1g = $0.1g", x, y, m, multiplier.call(x, y).call(m))

{{out}}

=={{header|zkl}}==

This is actually partial evaluation, multiplier returns n1*n2*X where X isn't known yet. So multiplier(2,3)(4) --> (2*3*)4 --> 24. Even better, multiplier(2,3)(4,5) --> 120, multiplier(2,3)(4,5,6) --> 720, multiplier(2,3)() --> 6.

Alternatively,

//-->L(Deferred,Deferred,Deferred) // lazy eval of n*(1/n)*X

ms.run(True,1.0) //-->L(1,1,1)

ms.run(True,5.0) //-->L(5,5,5)

List.run(True,X), for each item in the list, does i(X) and collects the results into another list. Sort of an inverted map or fold.