Preguntas sobre Programación Funcional y Declarativa

import java.util.function.Function;

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

def square(x):
    return x * x

print(square(5))  # Output: 25

using System;

class Program {
    static void Main() {
        Func square = x => x * x;
        Console.WriteLine(square(5));  // Output: 25
    }
}

const square = (x: number): number => x * x;
console.log(square(5));  // Output: 25

import java.util.Arrays;

public class DeclarativeExample {
    public static void main(String[] args) {
        Arrays.asList(1, 2, 3, 4, 5).stream()
            .filter(x -> x % 2 == 0)
            .forEach(System.out::println);  // Output: 2, 4
    }
}

evens = [x for x in range(1, 6) if x % 2 == 0]
print(evens)  # Output: [2, 4]

using System;
using System.Linq;

class Program {
    static void Main() {
        var numbers = new[] { 1, 2, 3, 4, 5 };
        var evens = numbers.Where(x => x % 2 == 0);
        foreach (var even in evens) {
            Console.WriteLine(even);  // Output: 2, 4
        }
    }
}

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

import java.util.function.Function;

public class SideEffectExample {
    public static void main(String[] args) {
        Function addFive = x -> x + 5; // No side effect
        System.out.println(addFive.apply(10));  // Output: 15
    }
}

def add_five(x):
    return x + 5  # No side effect

print(add_five(10))  # Output: 15

using System;

class Program {
    static void Main() {
        Func addFive = x => x + 5; // No side effect
        Console.WriteLine(addFive(10));  // Output: 15
    }
}

const addFive = (x: number): number => x + 5; // No side effect
console.log(addFive(10));  // Output: 15

import java.util.function.Function;

public class HigherOrderFunctionExample {
    public static void main(String[] args) {
        Function multiplyBy = factor -> x -> x * factor;
        Function doubleValue = multiplyBy.apply(2);
        System.out.println(doubleValue.apply(5));  // Output: 10
    }
}

def multiplier(factor):
    return lambda x: x * factor

double_value = multiplier(2)
print(double_value(5))  # Output: 10

using System;

class Program {
    static void Main() {
        Func> multiplier = factor => x => x * factor;
        var doubleValue = multiplier(2);
        Console.WriteLine(doubleValue(5));  // Output: 10
    }
}

const multiplier = (factor: number) => (x: number): number => x * factor;
const doubleValue = multiplier(2);
console.log(doubleValue(5));  // Output: 10

public class ClosureExample {
    public static void main(String[] args) {
        int factor = 2;
        Function multiplier = x -> x * factor;
        System.out.println(multiplier.apply(5));  // Output: 10
    }
}

def make_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier

double_value = make_multiplier(2)
print(double_value(5))  # Output: 10

using System;

class Program {
    static void Main() {
        int factor = 2;
        Func multiplier = x => x * factor;
        Console.WriteLine(multiplier(5));  // Output: 10
    }
}

const makeMultiplier = (factor: number) => (x: number): number => x * factor;
const doubleValue = makeMultiplier(2);
console.log(doubleValue(5));  // Output: 10

import java.util.Optional;

public class MonadExample {
    public static void main(String[] args) {
        Optional result = Optional.of(5)
            .map(x -> x * 2)
            .map(x -> x + 3);
        System.out.println(result.orElse(0));  // Output: 13
    }
}

from typing import Optional

result = Optional.of(5).map(lambda x: x * 2).map(lambda x: x + 3)
print(result.get_or_default(0))  # Output: 13

using System;

class Program {
    static void Main() {
        var result = Optional.Of(5)
            .Map(x => x * 2)
            .Map(x => x + 3);
        Console.WriteLine(result.GetValueOrDefault(0));  // Output: 13
    }
}

class Maybe {
    constructor(private value: T | null) {}

    static of(value: U | null) {
        return new Maybe(value);
    }

    map(fn: (value: T) => U): Maybe {
        return this.value === null ? new Maybe(null) : new Maybe(fn(this.value));
    }

    getOrElse(defaultValue: T): T {
        return this.value === null ? defaultValue : this.value;
    }
}

const result = Maybe.of(5)
    .map(x => x * 2)
    .map(x => x + 3);

console.log(result.getOrElse(0));  // Output: 13

import java.util.function.Function;

public class CurryingExample {
    public static void main(String[] args) {
        Function> multiply = x -> y -> x * y;
        System.out.println(multiply.apply(2).apply(3));  // Output: 6
    }
}

def multiply(x):
    def inner(y):
        return x * y
    return inner

result = multiply(2)(3)
print(result)  # Output: 6

using System;

class Program {
    static void Main() {
        Func> multiply = x => y => x * y;
        Console.WriteLine(multiply(2)(3));  // Output: 6
    }
}

const multiply = (x: number) => (y: number): number => x * y;
console.log(multiply(2)(3));  // Output: 6

public final class ImmutablePerson {
    private final String name;
    private final int age;

    public ImmutablePerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

from typing import NamedTuple

class ImmutablePerson(NamedTuple):
    name: str
    age: int

person = ImmutablePerson(name='John', age=30)
print(person.name)  # Output: John

public class ImmutablePerson {
    public string Name { get; }
    public int Age { get; }

    public ImmutablePerson(string name, int age) {
        Name = name;
        Age = age;
    }
}

class ImmutablePerson {
    constructor(public readonly name: string, public readonly age: number) {}
}

const person = new ImmutablePerson('John', 30);
console.log(person.name);  // Output: John