Partial function application: Difference between revisions

* This task is more about ''how'' results are generated rather than just getting results.

<br><br>

 

=={{header|Ada}}==

Ada allows to define generic functions with generic parameters, which are partially applicable.

 

 

procedure Partial_Function_Application is

Print(FSF1((2,4,6,8)));

Print(FSF2((2,4,6,8)));

 

Output:

{{works 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].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

 

MODE F = PROC(INT)INT,

printf((set fmt, fsf1((2, 4, 6, 8)))); # prints (4, 8, 12, 16) #

printf((set fmt, fsf2((2, 4, 6, 8)))) # prints (4, 16, 36, 64) #

Output:

<pre>

</pre>

 

{{works with|BBC BASIC for Windows}}

fsf2 = FNpartial(PROCfs(), FNf2())

DEF FNf1(n) = n * 2

'''Output:'''

<pre>

4 16 36 64

</pre>

 

=={{header|Bracmat}}==

Output:

<pre>0 2 4 6

4 8 12 16

4 16 36 64</pre>

 

=={{header|C}}==

Nasty hack, but the partial does return a true C function pointer, which is otherwise hard to achieve. (In case you are wondering, no, this is not a good or serious solution.) Compiled with <code>gcc -Wall -ldl</code>.

#include <unistd.h>

#include <stdlib.h>

 

return 0;

1

4

4

6

 

=={{header|C++}}==

#include <algorithm>

#include <array>

<< "\tfsf1: " << fsf1(ys) << '\n'

<< "\tfsf2: " << fsf2(ys) << '\n';

 

=={{header|Ceylon}}==

function fs(Integer f(Integer n), {Integer*} s) => s.map(f);

value evens = (2..8).by(2);

print("fsf1(``evens``) is ``fsf1(evens)`` and fsf2(``evens``) is ``fsf2(evens)``");

 

=={{header|CoffeeScript}}==

partial = (f, g) ->

(s) -> f(g, s)

console.log fsf1 seq

console.log fsf2 seq

output

> coffee partials.coffee

[ 0, 2, 4, 6 ]

[ 4, 8, 12, 16 ]

[ 4, 16, 36, 64 ]

 

 

=={{header|D}}==

fs has a static template argument f and the runtime argument s. The template constraints of fs statically require f to be a callable with just one argument, as requested by the task.

 

auto fs(alias f)(in int[] s) pure nothrow

d.fsf2.writeln;

}

{{out}}

<pre>[0, 2, 4, 6]

=={{header|E}}==

 

return def partial {

match [`run`, args2] {

println(f(s))

}

 

=={{header|Egison}}==

 

(define $fs (map $1 $2))

 

(test (fsf1 {2 4 6 8}))

(test (fsf2 {2 4 6 8}))

'''Output:'''

{0 2 4 6}

{0 1 4 9}

{4 8 12 16}

{4 16 36 64}

 

Translation of Racket

 

let fs f s = List.map f s

let f1 n = n * 2

printfn "%A" (fsf2 [0; 1; 2; 3])

printfn "%A" (fsf2 [2; 4; 6; 8])

Output:

<pre>

[0; 1; 4; 9]

[4; 16; 36; 64]

</pre>

 

=={{header|FunL}}==

f1 = (* 2)

f2 = (^ 2)

println( fsf2(0..3) )

println( fsf1(2..8 by 2) )

 

{{out}}

{{works with|Go|1.1}} (The first way shown uses [http://golang.org/ref/spec#Method_values Method values] which were added in Go 1.1. The second uses a function returning a function which was always possible.)

[http://play.golang.org/p/fbmK4qfFZr Run this in the Go playground].

 

import "fmt"

fmt.Println(" fsf3:", fsf3(s...))

fmt.Println(" fsf3(fsf1):", fsf3(fsf1(s...)...))

{{out}}

<pre>For s = [0 1 2 3]

 

=={{header|Groovy}}==

def f1 = { v -> v * 2 }

def f2 = { v -> v ** 2 }

def fsf1 = fs.curry(f1)

Testing:

println "fsf1$seq = ${fsf1(seq)}"

println "fsf2$seq = ${fsf2(seq)}"

Output:

<pre>fsf1[0, 1, 2, 3] = [0, 2, 4, 6]

=={{header|Haskell}}==

Haskell functions are curried. i.e. All functions actually take exactly one argument. Functions of multiple arguments are simply functions that take the first argument, which returns another function to take the remaining arguments, etc. Therefore, partial function application is trivial. Not giving a multi-argument function all of its arguments will simply return a function that takes the remaining arguments.

f1 = (* 2)

f2 = (^ 2)

print $ fsf2 [0, 1, 2, 3] -- prints [0, 1, 4, 9]

print $ fsf1 [2, 4, 6, 8] -- prints [4, 8, 12, 16]

 

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

 

procedure main()

every (s := "[ ") ||:= !L || " "

return s || "]"

 

{{libheader|Icon Programming Library}}

Given:

 

f1=:*&2

f2=:^&2

fsf1=:f1 fs

 

The required examples might look like this:

 

0 2 4 6

fsf2 i.4

4 8 12 16

fsf2 fsf1 1+i.4

 

That said, note that much of this is unnecessary, since f1 and f2 already work the same way on list arguments.

 

0 2 4 6

f2 i.4

2 4 6 8

f2 f1 1+i.4

 

That said, note that if we complicated the definitions of f1 and f2, so that they would not work on lists, the fs approach would still work:

In other words, given:

 

assert.1=#y

u y

F2=: f2 crippled

fsF1=: F1 fs

 

the system behaves like this:

 

|assertion failure: F1

| 1=#y

fsF1 i.4

0 2 4 6

 

=={{header|Java}}==

To solve this task, I wrote <tt>fs()</tt> as a curried method. I changed the syntax from <tt>fs(arg1, arg2)</tt> to <tt>fs(arg1).call(arg2)</tt>. Now I can use <tt>fs(arg1)</tt> as partial application.

 

 

public class PartialApplication {

}

}

 

The aforementioned code, lambda-ized in Java 8.

 

import java.util.function.BiFunction;

import java.util.function.Function;

;

}

 

Compilation and output for both versions: <pre>$ javac PartialApplication.java

fsf1(array): [4, 8, 12, 16]

fsf2(array): [4, 16, 36, 64]</pre>

 

=={{header|JavaScript}}==

(No special libraries are required for the creation or application of partial functions)

 

f2 = function (x) { return x * x; },

 

fsf1([2, 4, 6, 8]),

fsf2([2, 4, 6, 8])

 

Output:

For additional flexibility ( allowing for an arbitrary number of arguments in applications of a partially applied function, and dropping the square brackets from the function calls in the tests above ) we can make use of the array-like ''arguments'' object, which is a property of any JavaScript function.

 

f2 = function (x) { return x * x; },

 

fsf1(2, 4, 6, 8, 10, 12),

fsf2(2, 4, 6, 8)

 

Output:

 

===ES6===

'use strict';

 

fsf2([2, 4, 6, 8])

];

{{Out}}

<pre>[[0, 2, 4, 6], [0, 1, 4, 9], [4, 8, 12, 16], [4, 16, 36, 64]]</pre>

 

=={{header|Kotlin}}==

 

typealias Func = (Int) -> Int

fun fs(f: Func, seq: List<Int>) = seq.map { f(it) }

 

 

fun f1(n: Int) = 2 * n

fun f2(n: Int) = n * n

 

val fsf1 = partial(::fs, ::f1)

val fsf2 = partial(::fs, ::f2)

println()

}

 

{{out}}

 

=={{header|Lambdatalk}}==

{def fs {lambda {:f} map :f}}

{def f1 {lambda {:x} {* :x 2}}}

4 8 12 16

4 16 36 64

 

=={{header|LFE}}==

 

Here is the code, made more general to account for different arrities (note that to copy and paste into the LFE REPL, you'll need to leave out the docstring):

(defun partial

"The partial function is arity 2 where the first parameter must be a

((arg-2)

(funcall func arg-1 arg-2)))))

 

Here is the problem set:

(defun fs (f s) (lists:map f s))

(defun f1 (i) (* i 2))

(4.0 16.0 36.0 64.0)

 

 

=={{header|Logtalk}}==

Using Logtalk's built-in and library meta-predicates:

:- object(partial_functions).

 

 

:- end_object.

Output:

| ?- partial_functions::show.

[0,1,2,3] -> fs(f1) -> [0,2,4,6]

[2,4,6,8] -> fs(f2) -> [4,16,36,64]

yes

 

=={{header|Lua}}==

 

local t = {}

for k, v in ipairs(...) do

print(table.concat(squared_s{0, 1, 2, 3}, ', '))

print(table.concat(timestwo_s{2, 4, 6, 8}, ', '))

 

'''Output:'''

4, 16, 36, 64

 

f1 [n_] := n*2

f2 [n_] := n^2

fsf1[s_] := fs[f1, s]

Example usage:

<pre>fsf1[{0, 1, 2, 3}]

 

=={{header|Mercury}}==

:- interface.

 

:- func fsf2 = (func(list(int)) = list(int)).

 

 

=={{header|Nemerle}}==

using System.Console;

 

}

 

=={{header|OCaml}}==

OCaml functions are curried. i.e. All functions actually take exactly one argument. Functions of multiple arguments are simply functions that take the first argument, which returns another function to take the remaining arguments, etc. Therefore, partial function application is trivial. Not giving a multi-argument function all of its arguments will simply return a function that takes the remaining arguments.

let fs f s = List.map f s

let f1 value = value * 2

- : int list = [4; 8; 12; 16]

# fsf2 [2; 4; 6; 8];;

 

=={{header|Oforth}}==

 

: f1 2 * ;

: f2 sq ;

 

#f1 #fs curry => fsf1

 

{{out}}

=={{header|Order}}==

Much like Haskell and ML, not giving a multi-argument function all of its arguments returns a function that will accept the rest.

 

#define ORDER_PP_DEF_8fs ORDER_PP_FN( 8fn(8F, 8S, 8seq_map(8F, 8S)) )

8print(8ap(8G, 8seq(0, 1, 2, 3)) 8comma 8space),

8print(8ap(8F, 8seq(2, 4, 6, 8)) 8comma 8space),

{{out}}

<pre>(0)(2)(4)(6), (0)(1)(4)(9), (4)(8)(12)(16), (4)(16)(36)(64)</pre>

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

This pure-GP solution cheats slightly, since GP lacks variadic arguments and reflection.

f1(x)=2*x;

f2(x)=x^2;

fsf1(2([1..4])

fsf2([0..3])

 

PARI can do true partial function application, along the lines of [[#C|C]]; see also the <code>E*</code> parser code.

=={{header|Perl}}==

Note: this is written according to my understanding of the task spec and the discussion page; it doesn't seem a consensus was reached regarding what counts as a "partial" yet.

my $func = shift;

sub { map $func->($_), @_ }

}

 

 

my $fs_double = fs(\&double);

@s = (2, 4, 6, 8);

print "fs_double(@s): @{[ $fs_double->(@s) ]}\n";

Output: <pre>fs_double(0 1 2 3): 0 2 4 6

fs_square(0 1 2 3): 0 1 4 9

fs_square(2 4 6 8): 4 16 36 64</pre>

 

{{out}}

<pre>

</pre>

 

=={{header|PicoLisp}}==

(de f1 (N) (* 2 N))

(de f2 (N) (* N N))

(for S '((0 1 2 3) (2 4 6 8))

(println (fsf1 S))

Output:

<pre>(0 2 4 6)

=={{header|Prolog}}==

Works with SWI-Prolog.

maplist(P, S, S1).

 

call(FSF1,S2, S21), format('~w : ~w ==> ~w~n',[FSF2, S2, S21]),

call(FSF2,S2, S22), format('~w : ~w ==> ~w~n',[FSF1, S2, S22]).

Output :

<pre>?- fs.

 

=={{header|Python}}==

 

def fs(f, s): return [f(value) for value in s]

s = [2, 4, 6, 8]

assert fs(f1, s) == fsf1(s) # == [4, 8, 12, 16]

 

The program runs without triggering the assertions.

 

def fg(*x): return f(g, *x)

return fg

 

print fsf1(1, 2, 3, 4)

 

=={{header|R}}==

 

capture <- list(...)

function(...) {

fsf2(0:3)

fsf1(seq(2,8,2))

 

=={{header|Racket}}==

 

#lang racket

 

(fsf2 '(0 1 2 3))

(fsf2 '(2 4 6 8))

 

=={{header|REXX}}==

s=; do a=0 to 3 /*build 1st series of some low integers*/

s=strip(s a) /*append to the integer to the S list*/

interpret '$=$' f"("z')'

end /*j*/

'''output'''

<pre>

for f1, series= 2 4 6 8, result= 4 8 12 16

for f2, series= 2 4 6 8, result= 4 16 36 64

</pre>

 

 

{{works with|Ruby|1.9}}

f1 = proc { |n| n * 2 }

f2 = proc { |n| n ** 2 }

p fsf1[e]

p fsf2[e]

 

Output

 

=={{header|Scala}}==

def f1(x:Int) = x * 2

def f2(x:Int) = x * x

 

assert(fsf1(List(0,1,2,3)) == List(0,2,4,6))

 

=={{header|Sidef}}==

{{trans|Perl}}

func(*args) {

args.map {f(_)}

s = [2, 4, 6, 8];

say "fs_double(#{s}): #{fs_double(s...)}";

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|Pharo|1.3-13315}}

| f1 f2 fs fsf1 fsf2 partial |

 

fsf2 value: #(2 4 6 8).

" #(4 16 36 64)"

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

proc partial {f1 f2} {

variable ctr

}

}} $f1 $f2

Demonstration:

set r {}

foreach n $s {

puts "$s ==f1==> [$fsf1 $s]"

puts "$s ==f2==> [$fsf2 $s]"

Output:

<pre>

Indeed, functional language purists would probably say that even the explicit <code>op</code> operator spoils it, somewhat.

 

((0 2 4 6) (4 8 12 16))

 

$ txr -p "(mapcar (op mapcar (op * @1 @1)) (list (range 0 3) (range 2 8 2)))"

 

Note how in the above, '''no''' function arguments are explicitly mentioned at all except the necessary reference <code>@1</code> to an argument whose existence is implicit.

Now, without further ado, we surrender the concept of partial application to meet the task requirements:

 

(defun fs (fun seq) (mapcar fun seq))

(defun f1 (num) (* 2 num))

(print [fs fsf2 '((0 1 2 3) (2 4 6 8))]) (put-line \"\"))"

((0 2 4 6) (4 8 12 16))

 

=={{header|zkl}}==

var fsf1=fs.fp(f1), fsf2=fs.fp(f2);

fsf1([0..3]); //-->L(0,2,4,6)

 

 

{{omit from|Euphoria}}