/* Composición de funciones: Combina dos funciones en una sola. */
const compose = (f, g) => (x) => f(g(x));

// Ejemplo en JavaScript/TypeScript
const add1 = x => x + 1;
const multiply2 = x => x * 2;
const add1ThenMultiply2 = compose(multiply2, add1);
console.log(add1ThenMultiply2(3)); // 8

import java.util.function.Function;

public class FunctionComposition {
    public static void main(String[] args) {
        Function add1 = x -> x + 1;
        Function multiply2 = x -> x * 2;
        Function add1ThenMultiply2 = add1.andThen(multiply2);
        System.out.println(add1ThenMultiply2.apply(3)); // 8
    }
}

def add1(x):
    return x + 1

def multiply2(x):
    return x * 2

def compose(f, g):
    return lambda x: f(g(x))

add1_then_multiply2 = compose(multiply2, add1)
print(add1_then_multiply2(3))  # 8

using System;

public class FunctionComposition {
    public static void Main() {
        Func add1 = x => x + 1;
        Func multiply2 = x => x * 2;
        Func add1ThenMultiply2 = x => multiply2(add1(x));
        Console.WriteLine(add1ThenMultiply2(3)); // 8
    }
}

/* Currificación: Transformar una función con múltiples argumentos en una secuencia de funciones con un solo argumento. */
const curry = (fn) => (a) => (b) => fn(a, b);

const add = (a, b) => a + b;
const curriedAdd = curry(add);
console.log(curriedAdd(1)(2)); // 3

import java.util.function.Function;

public class CurryingExample {
    public static void main(String[] args) {
        Function> add = a -> b -> a + b;
        Function add1 = add.apply(1);
        System.out.println(add1.apply(2)); // 3
    }
}

def curry_add(a):
    def add(b):
        return a + b
    return add

add1 = curry_add(1)
print(add1(2))  # 3

using System;

public class CurryingExample {
    public static void Main() {
        Func> add = a => b => a + b;
        var add1 = add(1);
        Console.WriteLine(add1(2)); // 3
    }
}

const curryAdd = (a: number) => (b: number) => a + b;

const add1 = curryAdd(1);
console.log(add1(2)); // 3

/* Transformación de datos: Aplicar funciones a datos para cambiar su forma o estructura. */
const numbers = [1, 2, 3];
const doubled = numbers.map(x => x * 2);
console.log(doubled); // [2, 4, 6]

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class DataTransformation {
    public static void main(String[] args) {
        List numbers = Arrays.asList(1, 2, 3);
        List doubled = numbers.stream().map(x -> x * 2).collect(Collectors.toList());
        System.out.println(doubled); // [2, 4, 6]
    }
}

numbers = [1, 2, 3]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # [2, 4, 6]

using System;
using System.Linq;

public class DataTransformation {
    public static void Main() {
        var numbers = new[] { 1, 2, 3 };
        var doubled = numbers.Select(x => x * 2).ToArray();
        Console.WriteLine(string.Join(", ", doubled)); // 2, 4, 6
    }
}

const numbers = [1, 2, 3];
const doubled = numbers.map(x => x * 2);
console.log(doubled); // [2, 4, 6]

/* Función de orden superior: Función que acepta otras funciones como argumentos o devuelve una función. */
const applyFunction = (fn, value) => fn(value);

// Ejemplo en JavaScript/TypeScript
const square = x => x * x;
console.log(applyFunction(square, 5)); // 25

import java.util.function.Function;

public class HigherOrderFunction {
    public static void main(String[] args) {
        Function square = x -> x * x;
        System.out.println(applyFunction(square, 5)); // 25
    }

    private static int applyFunction(Function fn, int value) {
        return fn.apply(value);
    }
}

def apply_function(fn, value):
    return fn(value)

def square(x):
    return x * x

print(apply_function(square, 5))  # 25

using System;

public class HigherOrderFunction {
    public static void Main() {
        Func square = x => x * x;
        Console.WriteLine(ApplyFunction(square, 5)); // 25
    }

    private static int ApplyFunction(Func fn, int value) {
        return fn(value);
    }
}

const applyFunction = (fn: (x: number) => number, value: number): number => fn(value);

const square = (x: number): number => x * x;

console.log(applyFunction(square, 5)); // 25

/* La función map aplica una función a cada elemento de una colección. */
const numbers = [1, 2, 3];
const doubled = numbers.map(x => x * 2);
console.log(doubled); // [2, 4, 6]

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class MapFunction {
    public static void main(String[] args) {
        List numbers = Arrays.asList(1, 2, 3);
        List doubled = numbers.stream().map(x -> x * 2).collect(Collectors.toList());
        System.out.println(doubled); // [2, 4, 6]
    }
}

numbers = [1, 2, 3]
doubled = list(map(lambda x: x * 2, numbers))
print(doubled)  # [2, 4, 6]

using System;
using System.Linq;

public class MapFunction {
    public static void Main() {
        var numbers = new[] { 1, 2, 3 };
        var doubled = numbers.Select(x => x * 2).ToArray();
        Console.WriteLine(string.Join(", ", doubled)); // 2, 4, 6
    }
}

const numbers = [1, 2, 3];
const doubled = numbers.map(x => x * 2);
console.log(doubled); // [2, 4, 6]

/* La función filter selecciona elementos de una colección que cumplen con una condición. */
const numbers = [1, 2, 3, 4];
const even = numbers.filter(x => x % 2 === 0);
console.log(even); // [2, 4]

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class FilterFunction {
    public static void main(String[] args) {
        List numbers = Arrays.asList(1, 2, 3, 4);
        List even = numbers.stream().filter(x -> x % 2 == 0).collect(Collectors.toList());
        System.out.println(even); // [2, 4]
    }
}

numbers = [1, 2, 3, 4]
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # [2, 4]

using System;
using System.Linq;

public class FilterFunction {
    public static void Main() {
        var numbers = new[] { 1, 2, 3, 4 };
        var even = numbers.Where(x => x % 2 == 0).ToArray();
        Console.WriteLine(string.Join(", ", even)); // 2, 4
    }
}

const numbers = [1, 2, 3, 4];
const even = numbers.filter(x => x % 2 === 0);
console.log(even); // [2, 4]

/* La función reduce acumula valores en una colección para obtener un único resultado. */
const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((acc, x) => acc + x, 0);
console.log(sum); // 10

import java.util.Arrays;
import java.util.List;

public class ReduceFunction {
    public static void main(String[] args) {
        List numbers = Arrays.asList(1, 2, 3, 4);
        int sum = numbers.stream().reduce(0, (acc, x) -> acc + x);
        System.out.println(sum); // 10
    }
}

from functools import reduce

numbers = [1, 2, 3, 4]
sum = reduce(lambda acc, x: acc + x, numbers, 0)
print(sum)  # 10

using System;
using System.Linq;

public class ReduceFunction {
    public static void Main() {
        var numbers = new[] { 1, 2, 3, 4 };
        var sum = numbers.Aggregate(0, (acc, x) => acc + x);
        Console.WriteLine(sum); // 10
    }
}

const numbers = [1, 2, 3, 4];
const sum = numbers.reduce((acc, x) => acc + x, 0);
console.log(sum); // 10