Partial function application: Difference between revisions

{{task|Programming language concepts}}

parameters and apply arguments to some of the parameters to create a new

function that needs only the application of the remaining arguments to

: Then <code>partial(f, param1=v1)</code> returns <code>f'(param2)</code>

: And <code>f(param1=v1, param2=v2) == f'(param2=v2)</code> (for any value v2)

 

Note that in the partial application of a parameter, (in the above case param1), other parameters are not explicitly mentioned. This is a recurring feature of partial function application.

 

;Task

 

* Test fsf1 and fsf2 by evaluating them with s being the sequence of integers from 0 to 3 inclusive and then the sequence of even integers from 2 to 8 inclusive.

 

;Notes

* In partially applying the functions f1 or f2 to fs, there should be no ''explicit'' mention of any other parameters to fs, although introspection of fs within the partial applicator to find its parameters ''is'' allowed.

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

 

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

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

Arg arg;

 

PApply( F_&& f, Arg_&& arg )

: f(std::forward<F_>(f)), arg(std::forward<Arg_>(arg))

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

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

 

 

 

Output:

 

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

let fsf2 = fs f2

 

 

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

 

fsf1 = fs f1

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

 

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

This example highlights two related syntactic limitations: only a statically-defined function (using <code>#define ORDER_PP_DEF_</code> etc.) can have a multi-character name, so variables - i.e. the result of expressions - are limited to <code>8A</code>-<code>8Z</code>; and similarly only statically-defined functions can be applied using the C-like <code>8name(args)</code> syntax: variables or expression results must be applied using the <code>8ap</code> operator (which is semantically identical, but not quite as pretty).

 

=={{header|Perl}}==

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>

 

 

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

end /*a*/

 

 

end /*b*/

 

f2: return arg(1)**2

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

 

 

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

=={{header|TXR}}==

 

 

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

 

 

 

 

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

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

(defvar fsf2 (op fs f2))

 

 

{{omit from|Euphoria}}

 

[[Category:Functions and subroutines]]