Rosetta Stone: Lambda expressions

Question

How are anonymous functions/lambda expressions expressed in various programming languages? Are the syntax and semantics especially useful or not useful in that language? Are there any programming languages for which true anonymous functions aren't possible?

Like other Rosetta Stone questions, responses should start with the name of the language being demonstrated, and the demo should (hopefully) be interesting to people seeking new languages to learn.

Answer 1

LISP (Common Lisp/Scheme):

(lambda (y) (* y 2))

JavaScript:

x = function(y) { return 2*y; };

Python:

lambda x: 2*x

PHP (>= 5.3):

$x = function(y) { return 2 * y; };

Answer 2

Perl:

$f = sub { 2 * $_[0] };

Answer 3

Haskell:

\x -> 2 * x

Answer 4

Lua:

f = function (x) return 2 * x end

Answer 5

Ocaml:

fun x -> 2 * x

Answer 6

Javascript

var f = function(x){ return x*2;};
f(3);

PHP

$f = create_function('$x', 'return $x*2;');
$f(3);

Python

f = lambda x: x*2
f(3)

It is worth noting that Python lambdas can only be expressions, not a sequence of arbitrary statements as a regular function can.

SML

val f = fn x=>x*2;
f(3);

Answer 7

erlang:

fun(X) -> 2 * X end

Answer 8

C# 3.0:

var f = x => 2 * x;

Answer 9

Ruby:

lambda {|x| x * 2}

or

Proc.new {|x| x * 2}

Answer 10

Mathematica:

2*#&

The #, #2, etc are the arguments and ampersand makes everything previous be the lambda function (use parens if that's ambiguous). You can also use ## for, essentially, the list of all the arguments.

The above is syntactic sugar for

Function[x, 2*x]

Also, the * is optional, making Mathematica, I reckon, the winner by character count:

2#&

Answer 11

Java:

public interface Lambda<A,V> {

    V call(A a);

}

public class LambdaTest extends Object {

    public static void main(String argv[]) {

        Lambda<String, Integer> lambda=new Lambda<String, Integer>() {
            public Integer call(String s) {
                return Integer.parseInt(s);
            }
        };

        System.out.printf("Got %d\n", lambda.call(argv[0]));

    }

}

Answer 12

Reverse Polish Lisp (my first highlevel programming language):

<< 2 * >>

edit

I should point out that the same in factor looks like this:

[ 2 * ]

Answer 13

Arc:

[* 2 _]

Answer 14

VB

Dim a = Function(x) x * 2

Answer 15

MATLAB:

f = @(x) x^2;
g = @(k) @(x) x+k;
g3 = g(3);
% g is a function that returns a function

Answer 16

Scala:

(x => 2 * x)

Answer 17

Perl 6

As always with Perl, TMTOWTDI (There is more than one way to do it).

my $square_pointy  =  ->  $num {  $num ** 2 };
my $square_block   =           {    $_ ** 2 };
my $square_block_n =           { $^num ** 2 };
my $square_sub     = sub ($num){  $num ** 2 };

say $square_pointy(4);
say $square_block(4);
say $square_block_n(4);
say $square_sub(4);

Answer 18

There are actually two ways to do this in JavaScript, although so far I've only seen this one mentioned:

var f = function(x){ return x*2;};

As of JavaScript 1.8, you can do this:

var f = function(x) x * 2;

Answer 19

F#:

fun x -> x * x

Answer 20

C++

#include <boost/lambda.hpp>

using namespace boost::lambda;

boost::function<int (int)> f = (_1 * 2);

Answer 21

Haskell:

\x y -> x * y

or \x -> x *

or (x *)

Almost all descendants of Lisp and ISWIM (ML, Haskell, etc.) support some kind of terse syntax for lambda expressions. The latter family also generally allows automatic currying, which means that instead of writing x => (y => f(x, y)) you can write f(x,) and the language will automatically interpret this as a sort of lambda expression.

In some languages this even extends to binary operators. In Haskell, for example, (* 2) is a valid (and commonplace) expression for an anonymous function that multiplies its argument by two.

Historically, descendants of Algol and Fortran (including the entire C and Pascal family) have not supported any kind of lambda expression until very recently. Languages with some degree of OOP support (including C++ and Java) allow you to write "functor objects," but that's usually much more verbose and a bit less flexible than "real" lambda expressions.

Answer 22

Hi! My first answer :)

Smalltalk:

The definition ....

[:x | x * 2]

The evaluation ....

[:x | x * 2] value: 4

Answer 23

C++0x:

auto f = [](int x){ return x*2; }; // Definition
std::cout << f(3);                 // Usage

Read more about this new feature here.

Answer 24

ActionScript 3.0

var stringFilter:Function = function(input:String):String { return input.toUpperCase(); };

var multiplyer:Function = function(x:Number):Number { return x * 2.0; };

Similar to Javascript, but more type-safe.

Answer 25

J

This doesn't really use lambdas, but it's an anonymous function at least.

2&*

Demonstration:

    (2&*) 6
 12
    (2&*) 3 4 5
 6 8 10

Answer 26

Tcl (8.5+)

# Create a lambda term; note there's no particularly special syntax here
set mulBy2 [list x {expr {$x * 2}}]

# Use it; [apply] is synthesizable in 8.4 and before, but very costly
apply $mulBy2 21

Note that it's advisable if doing this to use command prefixes and expansion for application:

set mul2 [list ::apply [list x {expr {$x * 2}}]]
{*}$mul2 21

This is preferable as it allows other ways to express the same thing, for example:

set mul2 [list ::tcl::mathop::* 2]

Answer 27

Does this count as lambda for C/C++ ?

#include <stdlib.h>
#include <stdio.h>
#define lambda(x) (x*2)
float x(float x) { return x+20; }
int main() { float v=1; printf("%f",lambda(x(v))); }