The => Arrow Operator: From JavaScript to Modern Programming

The => symbol appears in many languages:

// JavaScript - arrow function
const double = x => x * 2;

// C# - lambda expression
Func<int, int> double = x => x * 2;

// Rust - match arm
match value {
    1 => "one",
    _ => "other"
}

// PHP - array syntax
$array = ["key" => "value"];

Same symbol, different contexts.

JavaScript Arrow Functions

The most common use:

const add = (a, b) => a + b;
[1, 2, 3].map(x => x * 2);
setTimeout(() => console.log('done'), 1000);

Shorter syntax than function keyword, lexical this binding.

C# Lambda Expressions

Similar to JavaScript:

// C# lambda
Func<int, int> square = x => x * x;

// LINQ query
var adults = users.Where(u => u.Age >= 18);

Rust Match Arms

Pattern matching uses =>:

match status {
    200 => println!("OK"),
    404 => println!("Not Found"),
    _ => println!("Other")
}

Also in closures:

let double = |x| => x * 2;

PHP Arrays

Key-value pair syntax:

$user = [
    "name" => "Alice",
    "email" => "alice@example.com"
];

Replaced old array() syntax.

Python (Not =>, but lambda)

Python uses lambda keyword instead:

# Python doesn't use =>
double = lambda x: x * 2

Kotlin

Lambda syntax:

val double = { x: Int -> x * 2 }
// Note: -> not =>

Scala

Anonymous functions:

val double = (x: Int) => x * 2
List(1, 2, 3).map(x => x * 2)

TypeScript

Same as JavaScript, with types:

const add = (a: number, b: number): number => a + b;

// Type definition
type Mapper = (x: number) => number;

Java (Since Java 8)

Lambda expressions:

// Java lambda
Function<Integer, Integer> double = x -> x * 2;
// Note: -> not =>

list.forEach(item -> System.out.println(item));

Java uses -> (single arrow), not =>.

Haskell

Type signatures:

-- Function type
add :: Int -> Int -> Int

Not quite the same symbol, but related concept.

Mathematical Origin

The arrow represents mapping:

f: x ↦ x²
// "f maps x to x squared"

Programming adopted this notation.

Historical Context

CoffeeScript (2009) popularized => for functions:

# CoffeeScript
double = (x) -> x * 2

ES6 (2015) added arrow functions to JavaScript, using =>.

Readability

Arrows clarify intent:

// Clear transformation
const transform = input => output;

// vs function keyword
function transform(input) {
    return output;
}

When Not to Use (JavaScript)

Avoid for methods needing dynamic this:

// Bad - arrow doesn't bind 'this'
const obj = {
    value: 42,
    getValue: () => this.value  // Wrong 'this'
};

// Good
const obj = {
    value: 42,
    getValue() { return this.value; }
};