martes, 16 de julio de 2024

Actualizaciones de registros en Gleam


import gleam/io


pub type SchoolPerson {

  Teacher(name: String, subject: String, floor: Int, room: Int)

}


pub fn main() {

  let teacher1 = Teacher(name: "Mr Dodd", subject: "ICT", floor: 2, room: 2)


  // Use the update syntax

  let teacher2 = Teacher(..teacher1, subject: "PE", room: 6)


  io.debug(teacher1)

  io.debug(teacher2)

}


La sintaxis de actualización de registros se puede utilizar para crear un nuevo registro a partir de uno existente del mismo tipo, pero con algunos campos modificados.

Gleam es un lenguaje inmutable, por lo que el uso de la sintaxis de actualización de registros no muta ni cambia el registro original.

Mapas, filtros, pliegues y más


Implementemos la función map:


map(_, []) -> [];

map(F, [H|T]) -> [F(H)|map(F,T)].


Existen muchas otras abstracciones similares que se pueden construir a partir de funciones recursivas que ocurren comúnmente. Veamos estas funciones :


%% only keep even numbers

even(L) -> lists:reverse(even(L,[])).

 

even([], Acc) -> Acc;

even([H|T], Acc) when H rem 2 == 0 -> even(T, [H|Acc]);

even([_|T], Acc) -> even(T, Acc).

 

%% only keep men older than 60

old_men(L) -> lists:reverse(old_men(L,[])).

 

old_men([], Acc) -> Acc;

old_men([Person = {male, Age}|People], Acc) when Age > 60 ->

old_men(People, [Person|Acc]);

old_men([_|People], Acc) ->

old_men(People, Acc).


El primero toma una lista de números y devuelve sólo aquellos que son pares. El segundo revisa una lista de personas del tipo {Género, Edad} y solo mantiene aquellos que son hombres mayores de 60 años. Las similitudes son un poco más difíciles de encontrar aquí, pero tenemos algunos puntos en común. Ambas funciones operan en listas y tienen el mismo objetivo de mantener los elementos que superan alguna prueba (también un predicado) y luego descartar los demás. De esta generalización podemos extraer toda la información útil que necesitamos y abstraerla:


filter(Pred, L) -> lists:reverse(filter(Pred, L,[])).

 

filter(_, [], Acc) -> Acc;

filter(Pred, [H|T], Acc) ->

    case Pred(H) of

        true  -> filter(Pred, T, [H|Acc]);

        false -> filter(Pred, T, Acc)

    end.

Para usar la función de filtrado ahora solo necesitamos realizar la prueba fuera de la función. Compilemos el módulo hhfuns y pruébemoslo :

1> c(hhfuns).
{ok, hhfuns}
2> Numbers = lists:seq(1,10).
[1,2,3,4,5,6,7,8,9,10]
3> hhfuns:filter(fun(X) -> X rem 2 == 0 end, Numbers).
[2,4,6,8,10]
4> People = [{male,45},{female,67},{male,66},{female,12},{unknown,174},{male,74}].
[{male,45},{female,67},{male,66},{female,12},{unknown,174},{male,74}]
5> hhfuns:filter(fun({Gender,Age}) -> Gender == male andalso Age > 60 end, People).
[{male,66},{male,74}]


Estos dos ejemplos muestran que con el uso de la función filter/2, el programador sólo tiene que preocuparse por producir el predicado y la lista. Ya no es necesario pensar en el acto de recorrer la lista para descartar elementos no deseados. Esto es algo importante acerca de la abstracción de código funcional: intenta deshacerse de lo que siempre es igual y deja que el programador proporcione las partes que cambian.

Otro tipo de manipulación recursiva que aplicamos a las listas fue observar cada elemento de una lista uno tras otro y reducirlos a una única respuesta. Esto se llama pliegue y se puede utilizar en las siguientes funciones:

%% find the maximum of a list
max([H|T]) -> max2(T, H).
 
max2([], Max) -> Max;
max2([H|T], Max) when H > Max -> max2(T, H);
max2([_|T], Max) -> max2(T, Max).
 
%% find the minimum of a list
min([H|T]) -> min2(T,H).
 
min2([], Min) -> Min;
min2([H|T], Min) when H < Min -> min2(T,H);
min2([_|T], Min) -> min2(T, Min).
 
%% sum of all the elements of a list
sum(L) -> sum(L,0).
 
sum([], Sum) -> Sum;
sum([H|T], Sum) -> sum(T, H+Sum).

Para encontrar cómo debería comportarse el pliegue, tenemos que encontrar todos los puntos comunes de estas acciones y luego qué es diferente. Como se mencionó anteriormente, siempre tenemos una reducción de una lista a un valor único. En consecuencia, nuestro grupo solo debería considerar la iteración manteniendo un solo elemento, sin necesidad de crear listas. Entonces debemos ignorar los guardias, porque no siempre están ahí: deben estar en la función del usuario. En este sentido, nuestra función de plegado probablemente se parecerá mucho a la suma.

Un elemento sutil de las tres funciones que no se mencionó todavía es que cada función debe tener un valor inicial con el que empezar a contar. En el caso de suma/2, usamos 0 mientras sumamos y dado X = X + 0, el valor es neutral y no podemos estropear el cálculo comenzando allí. Si estuviéramos haciendo una multiplicación, usaríamos 1 dado X = X * 1. Las funciones min/1 y max/1 no pueden tener un valor inicial predeterminado: si la lista fuera solo de números negativos y comenzamos en 0, la respuesta estaría mal. Como tal, necesitamos utilizar el primer elemento de la lista como punto de partida. Lamentablemente, no siempre podemos decidir de esta manera, por lo que dejaremos esa decisión al programador. Tomando todos estos elementos, podemos construir la siguiente abstracción:

fold(_, Start, []) -> Start;
fold(F, Start, [H|T]) -> fold(F, F(H,Start), T).

Y si compilamos:

6> c(hhfuns).
{ok, hhfuns}
7> [H|T] = [1,7,3,5,9,0,2,3].   
[1,7,3,5,9,0,2,3]
8> hhfuns:fold(fun(A,B) when A > B -> A; (_,B) -> B end, H, T).
9
9> hhfuns:fold(fun(A,B) when A < B -> A; (_,B) -> B end, H, T).
0
10> hhfuns:fold(fun(A,B) -> A + B end, 0, lists:seq(1,6)).
21

Prácticamente cualquier función que se te ocurra y que reduzca listas a 1 elemento se puede expresar como un pliegue.

Lo curioso es que puedes representar un acumulador como un solo elemento (o una sola variable), y un acumulador puede ser una lista. Por lo tanto, podemos usar un pliegue para construir una lista. Esto significa que plegar es universal en el sentido de que puedes implementar prácticamente cualquier otra función recursiva en listas con un map y filtro plegado, uniforme:

reverse(L) ->
fold(fun(X,Acc) -> [X|Acc] end, [], L).
 
map2(F,L) ->
reverse(fold(fun(X,Acc) -> [F(X)|Acc] end, [], L)).
 
filter2(Pred, L) -> F = fun(X,Acc) ->
    case Pred(X) of
        true  -> [X|Acc];
        false -> Acc
    end
end,
reverse(fold(F, [], L)).


Y todos funcionan igual que los escritos a mano antes. ¿Qué te parece eso de abstracciones poderosas?

Mapa, filtros y pliegues son sólo una de las muchas abstracciones de las listas proporcionadas por la biblioteca estándar de Erlang. Otras funciones incluyen all/2 y any/2, que toman un predicado y prueban si todos los elementos devuelven verdadero o si al menos uno de ellos devuelve verdadero, respectivamente. Luego tienes drop while/2 que ignorará los elementos de una lista hasta que encuentre uno que se ajuste a un determinado predicado, su opuesto, take while/2, que mantendrá todos los elementos hasta que haya uno que no devuelva verdadero al predicado. Una función complementaria a las dos anteriores es partition/2, que tomará una lista y devolverá dos: una que tiene los términos que satisfacen un predicado determinado, y una lista para los demás. Otras funciones de listas utilizadas con frecuencia incluyen flatten/1, flatlength/1, flatmap/2, merge/1, nth/2, nthtail/2, split/2 y muchas otras.


lunes, 15 de julio de 2024

Coincidencia de patrones de registro en Gleam


 import gleam/io


pub type Fish {

  Starfish(name: String, favourite_color: String)

  Jellyfish(name: String, jiggly: Bool)

}


pub fn main() {

  let lucy = Starfish("Lucy", "Pink")


  case lucy {

    Starfish(_, favourite_color) -> io.debug(favourite_color)

    Jellyfish(name, ..) -> io.debug(name)

  }

}


Es posible establecer una coincidencia de patrones en un registro, lo que permite extraer múltiples valores de campo de un registro en variables distintas, similar a la coincidencia en una tupla o una lista.

La palabra clave let solo puede coincidir con tipos personalizados de variante única. Para tipos con más variantes se debe utilizar una expresión de caso.

Es posible utilizar el guión bajo _ o la sintaxis extendida... para descartar campos que no son obligatorios.

jueves, 11 de julio de 2024

Como podemos manejar las referencias nulas?


El error más frecuente en Java es NullPointerException y me imagino que en otros lenguajes alguno similar...  Para abordar esto, se han introducido estructuras y operadores que ayudan a manejar la ausencia de valores de manera más segura y explícita. 

Por ejemplo en Java se introdujo la clase `Optional` en la versión 8 para manejar valores potencialmente nulos de una manera más segura. `Optional` es un contenedor que puede o no contener un valor no nulo.

import java.util.Optional;


public class OptionalExample {

    public static void main(String[] args) {

        Optional<String> optional = Optional.of("Hello, World!");

        

        // Verificar si hay un valor presente

        if (optional.isPresent()) {

            System.out.println(optional.get());

        }

        

        // Uso del método ifPresent

        optional.ifPresent(System.out::println);

        

        // Proveer un valor predeterminado

        String value = optional.orElse("Default Value");

        System.out.println(value);

        

        // Proveer un valor predeterminado usando un Supplier

        value = optional.orElseGet(() -> "Default Value from Supplier");

        System.out.println(value);

    }

}


Scala utiliza la clase `Option` para representar un valor opcional. `Option` tiene dos subclases: `Some` y `None`, lo que proporciona una forma elegante y funcional de manejar valores que pueden estar ausentes. Esta idea es similar a la monada `Maybe` en Haskell.


object OptionExample extends App {

  val someValue: Option[String] = Some("Hello, World!")

  val noneValue: Option[String] = None


  // Uso de getOrElse

  println(someValue.getOrElse("Default Value"))

  println(noneValue.getOrElse("Default Value"))


  // Uso del patrón de coincidencia (Pattern Matching)

  someValue match {

    case Some(value) => println(value)

    case None => println("No value")

  }


  noneValue match {

    case Some(value) => println(value)

    case None => println("No value")

  }

}


Scala "copio" esta forma de Haskell. Haskell utiliza el tipo de datos `Maybe` para manejar valores opcionales `Maybe` puede ser `Just` un valor o `Nothing`.


main :: IO ()

main = do

    let someValue = Just "Hello, World!"

    let noneValue = Nothing


    -- Uso de fromMaybe

    putStrLn (fromMaybe "Default Value" someValue)

    putStrLn (fromMaybe "Default Value" noneValue)


    -- Uso del patrón de coincidencia (Pattern Matching)

    case someValue of

        Just value -> putStrLn value

        Nothing -> putStrLn "No value"


    case noneValue of

        Just value -> putStrLn value

        Nothing -> putStrLn "No value"


Kotlin es similar a Scala en muchos aspectos pero no en este. Kotlin introduce el operador `?` para facilitar la gestión de valores nulos. Este operador se utiliza para declarar tipos de datos que pueden ser nulos y para realizar operaciones seguras contra nulos.


fun main() {

    var nullableString: String? = "Hello, World!"


    // Uso del operador ?. para llamadas seguras

    println(nullableString?.length)


    // Uso del operador ?: para proporcionar un valor predeterminado

    val length = nullableString?.length ?: 0

    println(length)


    nullableString = null


    // Uso de let para ejecutar código solo si el valor no es nulo

    nullableString?.let {

        println(it)

    }

}


C# ha incluido varias características para manejar valores nulos, como el operador `?`, que facilita el manejo seguro de tipos que pueden ser nulos.


using System;


class Program

{

    static void Main()

    {

        string? nullableString = "Hello, World!";

        

        // Uso del operador ?. para llamadas seguras

        Console.WriteLine(nullableString?.Length);


        // Uso del operador ?? para proporcionar un valor predeterminado

        int length = nullableString?.Length ?? 0;

        Console.WriteLine(length);


        nullableString = null;


        // Uso de pattern matching para verificar nulos

        if (nullableString is string nonNullString)

        {

            Console.WriteLine(nonNullString);

        }

    }

}


Rust maneja la ausencia de valores y los errores de una manera robusta utilizando los tipos `Option` y `Result`. `Option` puede ser `Some` o `None`, mientras que `Result` puede ser `Ok` o `Err`.


fn main() {

    let some_value: Option<String> = Some("Hello, World!".to_string());

    let none_value: Option<String> = None;


    // Uso de unwrap_or

    println!("{}", some_value.unwrap_or("Default Value".to_string()));

    println!("{}", none_value.unwrap_or("Default Value".to_string()));


    // Uso del patrón de coincidencia (Pattern Matching)

    match some_value {

        Some(value) => println!("{}", value),

        None => println!("No value"),

    }


    match none_value {

        Some(value) => println!("{}", value),

        None => println!("No value"),

    }

}


Go no tiene un tipo de datos específico para manejar valores opcionales, pero utiliza la convención de retornar múltiples valores, incluyendo un valor y un `error`. Que la verdad no me gusta, te pasas preguntando todo el tiempo si hay error o si los valores son nulos. 


package main


import (

    "errors"

    "fmt"

)


func getValue() (string, error) {

    return "Hello, World!", nil

}


func getNullableValue() (string, error) {

    return "", errors.New("no value")

}


func main() {

    value, err := getValue()

    if err != nil {

        fmt.Println("Error:", err)

    } else {

        fmt.Println("Value:", value)

    }


    nullableValue, err := getNullableValue()

    if err != nil {

        fmt.Println("Error:", err)

    } else {

        fmt.Println("Value:", nullableValue)

    }

}


Python utiliza la palabra clave `None` para representar la ausencia de valor. Aunque no tiene una estructura específica como `Optional`, los desarrolladores pueden utilizar condicionales y manejo de excepciones.


def get_value():

    return "Hello, World!"


def get_nullable_value():

    return None


value = get_value()

nullable_value = get_nullable_value()


if value is not None:

    print(value)

else:

    print("Default Value")


if nullable_value is not None:

    print(nullable_value)

else:

    print("Default Value")


Ruby utiliza `nil` para representar la ausencia de valor. Al igual que en Python, no tiene una estructura específica para valores opcionales, pero proporciona métodos para manejar `nil`.


value = "Hello, World!"

nullable_value = nil


# Uso del operador ||

puts value || "Default Value"

puts nullable_value || "Default Value"


# Uso de condicionales

puts value.nil? ? "Default Value" : value

puts nullable_value.nil? ? "Default Value" : nullable_value


C++ utiliza punteros inteligentes (`smart pointers`) para gestionar la memoria y prevenir errores relacionados con punteros nulos. Los punteros inteligentes, como `std::unique_ptr` y `std::shared_ptr`, se encargan de la gestión automática de la memoria.


#include <iostream>

#include <memory>


int main() {

    std::unique_ptr<int> uniquePtr(new int(42));

    if (uniquePtr) {

        std::cout << *uniquePtr << std::endl;

    }


    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);

    if (sharedPtr) {

        std::cout << *sharedPtr << std::endl;

    }


    // Uso de weak_ptr para evitar ciclos de referencia

    std::weak_ptr<int> weakPtr = sharedPtr;

    if (auto lockedPtr = weakPtr.lock()) {

        std::cout << *lockedPtr << std::endl;

    }


    return 0;

}


TypeScript, un superconjunto de JavaScript, permite tipos opcionales y tiene un soporte robusto para manejar valores `null` y `undefined`.


let nullableString: string | null = "Hello, World!";


// Uso del operador ? para llamadas seguras

console.log(nullableString?.length ?? 0);


// Uso de if para asegurar valores no nulos

if (nullableString !== null) {

    console.log(nullableString);

}


TypeScript utiliza tipos opcionales para manejar valores que pueden ser `null` o `undefined`, proporcionando un enfoque seguro para evitar errores comunes relacionados con valores nulos. El operador `?.` permite realizar llamadas seguras, y el operador `??` proporciona valores predeterminados en caso de valores `null` o `undefined`.

En fin, aunque la gestión de valores nulos varía entre lenguajes, la idea subyacente es la misma: proporcionar mecanismos más seguros y expresivos para manejar la ausencia de valores. Ya sea mediante clases contenedoras como `Optional` en Java y `Option` en Scala, tipos de datos como `Maybe` en Haskell, operadores específicos como `?` en Kotlin y C#, punteros inteligentes en C++, o enfoques específicos en Rust, Go, Python y Ruby, estos enfoques ayudan a reducir los errores y a escribir un código más robusto y mantenible.


lunes, 8 de julio de 2024

SQLAlchemy un ORM para Python


SQLAlchemy es una librería de SQL para Python que facilita el manejo de bases de datos relacionales. Combina un conjunto completo de herramientas de alto nivel y bajo nivel para la creación y manipulación de esquemas de bases de datos, la construcción de consultas SQL y la gestión de transacciones.

1. SQLAlchemy Core: Proporciona una capa de abstracción de SQL que permite escribir consultas SQL directamente, pero de una manera más segura y con mejor soporte para múltiples bases de datos.

2. SQLAlchemy ORM: Permite mapear clases de Python a tablas de bases de datos y proporciona una forma orientada a objetos para interactuar con las bases de datos.


Puedes instalar SQLAlchemy utilizando pip:


pip install sqlalchemy


Además, si planeas usar una base de datos específica, como SQLite, PostgreSQL o MySQL, necesitarás instalar el conector adecuado. Por ejemplo, para PostgreSQL:


pip install psycopg2


Vamos a empezar con un ejemplo básico de cómo definir un modelo de base de datos usando SQLAlchemy ORM.


from sqlalchemy import create_engine, Column, Integer, String

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy.orm import sessionmaker


engine = create_engine('sqlite:///example.db', echo=True)


Base = declarative_base()


class User(Base):

    __tablename__ = 'users'


    id = Column(Integer, primary_key=True)

    name = Column(String)

    age = Column(Integer)


    def __repr__(self):

        return f"<User(name={self.name}, age={self.age})>"


# Crear todas las tablas

Base.metadata.create_all(engine)


# Crear una sesión

Session = sessionmaker(bind=engine)

session = Session()

```


En este ejemplo, hemos configurado un motor de base de datos SQLite y definido una clase `User` que mapea a la tabla `users`. Luego, creamos todas las tablas necesarias y configuramos una sesión para interactuar con la base de datos.

Para insertar datos en la base de datos, simplemente creamos instancias de la clase del modelo y las añadimos a la sesión.


# Crear un nuevo usuario

new_user = User(name='John Doe', age=30)


# Añadir el usuario a la sesión

session.add(new_user)


# Confirmar la transacción

session.commit()


SQLAlchemy proporciona una API poderosa y flexible para consultar datos.


# Obtener todos los usuarios

users = session.query(User).all()

print(users)


# Obtener un usuario específico

user = session.query(User).filter_by(name='John Doe').first()

print(user)


Para actualizar un registro, primero lo consultas, modificas los atributos y luego confirmas la transacción.


# Obtener el usuario

user = session.query(User).filter_by(name='John Doe').first()


# Modificar el usuario

user.age = 31


# Confirmar la transacción

session.commit()


Para eliminar un registro, lo consultas, lo eliminas de la sesión y confirmas la transacción.


# Obtener el usuario

user = session.query(User).filter_by(name='John Doe').first()


# Eliminar el usuario

session.delete(user)


# Confirmar la transacción

session.commit()


SQLAlchemy es una herramienta poderosa y flexible para gestionar bases de datos en Python. Su combinación de mapeo orientado a objetos y capacidades de SQL crudo lo hace adecuado para una amplia variedad de aplicaciones. 

Dejo link: https://www.sqlalchemy.org/

sábado, 6 de julio de 2024

Registros en Gleam



import gleam/io


pub type SchoolPerson {

  Teacher(name: String, subject: String)

  Student(String)

}


pub fn main() {

  let teacher1 = Teacher("Mr Schofield", "Physics")

  let teacher2 = Teacher(name: "Miss Percy", subject: "Physics")

  let student1 = Student("Koushiar")

  let student2 = Student("Naomi")

  let student3 = Student("Shaheer")


  let school = [teacher1, teacher2, student1, student2, student3]

  io.debug(school)

}

Una variante de un tipo personalizado puede contener otros datos. En este caso la variante se llama registro.

A los campos de un registro se les pueden asignar etiquetas y, al igual que las etiquetas de argumentos de funciones, se pueden usar opcionalmente al llamar al constructor del registro. Normalmente se utilizarán etiquetas para las variantes que las definen.

Es común tener un tipo personalizado con una variante que contiene datos; este es el equivalente de Gleam de una estructura u objeto en otros lenguajes.

miércoles, 3 de julio de 2024

Aprende a programar en Java desde cero con Java Magician


Si empiezan en el mundo java, les quiere recomendar este sitio que contiene muy buenos tutoriales en español. Los cuales están escritos de forma divertida.  


Dejo link: https://javamagician.com/

martes, 2 de julio de 2024

Tipos personalizados en Gleam



import gleam/io

pub type Season {
  Spring
  Summer
  Autumn
  Winter
}

pub fn main() {
  io.debug(weather(Spring))
  io.debug(weather(Autumn))
}

fn weather(season: Season) -> String {
  case season {
    Spring -> "Mild"
    Summer -> "Hot"
    Autumn -> "Windy"
    Winter -> "Cold"
  }
}


Gleam tiene algunos tipos integrados como Int y String, pero los tipos personalizados permiten la creación de tipos completamente nuevos.

Un tipo personalizado se define con la palabra clave type seguida del nombre del tipo y un constructor para cada variante del tipo. Tanto el nombre del tipo como los nombres de los constructores comienzan con letras mayúsculas.

Las variantes de tipos personalizados pueden coincidir con patrones utilizando una expresión de caso.

lunes, 1 de julio de 2024

Funciones anónimas en Erlang


Las funciones anónimas, o funs, permiten declarar un tipo especial de función en línea, sin nombrarlas. Pueden hacer prácticamente todo lo que pueden hacer las funciones normales, excepto llamarse a sí mismas de forma recursiva (¿cómo podrían hacerlo si son anónimas?). Su sintaxis es:

fun(Args1) -> Expression1, Exp2, ..., ExpN;

     (Args2) -> Expression1, Exp2, ..., ExpN;

     (Args3) -> Expression1, Exp2, ..., ExpN

end


Y se puede utilizar de la siguiente manera:


7> Fn = fun() -> a end.

#Fun<erl_eval.20.67289768>

8> Fn().

a

9> hhfuns:map(fun(X) -> X + 1 end, L).

[2,3,4,5,6]

10> hhfuns:map(fun(X) -> X - 1 end, L).

[0,1,2,3,4]


Y ahora estás viendo una de las cosas que hace que a la gente le guste tanto la programación funcional: la capacidad de hacer abstracciones en un nivel muy bajo de código. De este modo, se pueden ignorar conceptos básicos como los bucles, lo que le permite centrarse en lo que se hace en lugar de en cómo hacerlo.

Las funciones anónimas ya son bastante buenas para este tipo de abstracciones, pero aún tienen más poderes ocultos:


11> PrepareAlarm = fun(Room) ->
11>                     io:format("Alarm set in ~s.~n",[Room]),
11>                     fun() -> io:format("Alarm tripped in ~s! Call Batman!~n",[Room]) end
11>                   end.
#Fun<erl_eval.20.67289768>
12> AlarmReady = PrepareAlarm("bathroom").
Alarm set in bathroom.
#Fun<erl_eval.6.13229925>
13> AlarmReady().
Alarm tripped in bathroom! Call Batman!
ok


¡Sostén el teléfono Batman! ¿Que está pasando aqui? Bueno, antes que nada, declaramos una función anónima asignada a PrepareAlarm. Esta función aún no se ha ejecutado: solo se ejecuta cuando PrepareAlarm("baño"). se llama. En ese momento se evalúa la llamada a io:format/2 y se emite el texto "Alarma configurada". La segunda expresión (otra función anónima) se devuelve a la persona que llama y luego se asigna a AlarmReady. Tenga en cuenta que en esta función, el valor de la variable Habitación se toma de la función 'principal' (PrepareAlarm). Esto está relacionado con un concepto llamado cierres.

Para entender los cierres, primero hay que entender el alcance. El alcance de una función se puede imaginar como el lugar donde se almacenan todas las variables y sus valores. En la función base(A) -> B = A + 1., A y B están definidos como parte del alcance de base/1. Esto significa que en cualquier lugar dentro de base/1, puede hacer referencia a A y B y esperar que se les vincule un valor. Y cuando digo "en cualquier lugar", no bromeo, chico; Esto también incluye funciones anónimas:


base(A) ->

     B = A + 1,

     F = fun() -> A * B end,

     F().


B y A todavía están vinculados al alcance de base/1, por lo que la función F aún puede acceder a ellos. Esto se debe a que F hereda el alcance de base/1. Como la mayoría de los tipos de herencia en la vida real, los padres no pueden obtener lo que tienen los hijos:


base(A) ->

    B = A + 1,

    F = fun() -> C = A * B end,

    F(),

    C.


En esta versión de la función, B sigue siendo igual a A + 1 y F seguirá ejecutándose bien. Sin embargo, la variable C solo está en el alcance de la función anónima en F. Cuando base/1 intenta acceder al valor de C en la última línea, solo encuentra una variable independiente. De hecho, si hubiera intentado compilar esta función, el compilador habría dado un error. La herencia sólo va en un sentido.

Es importante tener en cuenta que el alcance heredado sigue a la función anónima dondequiera que esté, incluso cuando se pasa a otra función:


a() ->

     Secret = "pony",

    fun() -> Secret end.

 

b(F) ->

    "a/0's password is "++F().


Entonces si la compilamos:

14> c(hhfuns).
{ok, hhfuns}
15> hhfuns:b(hhfuns:a()).
"a/0's password is pony"

¿Quién le dijo la contraseña a/0? Bueno, a/0 lo hizo. Si bien la función anónima tiene el alcance de a/0 cuando se declara allí, aún puede transportarla cuando se ejecuta en b/1, como se explicó anteriormente. Esto es muy útil porque nos permite transportar parámetros y contenido fuera de su contexto original, donde todo el contexto ya no es necesario (exactamente como hicimos con Batman en un ejemplo anterior).

Es más probable que utilices funciones anónimas para transportar el estado cuando tienes funciones definidas que toman muchos argumentos, pero tienes uno constante:


16> math:pow(5,2).
25.0
17> Base = 2.
2
18> PowerOfTwo = fun(X) -> math:pow(Base,X) end.
#Fun<erl_eval.6.13229925>
17> hhfuns:map(PowerOfTwo, [1,2,3,4]).
[2.0,4.0,8.0,16.0]

Al envolver la llamada a math:pow/2 dentro de una función anónima con la variable Base vinculada a su alcance, hicimos posible que cada una de las llamadas a PowerOfTwo en hhfuns:map/2 usara los números enteros de la lista como exponentes. de nuestra base.

Una pequeña trampa en la que puedes caer al escribir funciones anónimas es cuando intentas redefinir el alcance:

base() ->
    A = 1,
   (fun() -> A = 2 end)().

Esto declarará una función anónima y luego la ejecutará. Como la función anónima hereda el alcance de base/0, al intentar utilizar el operador = se compara 2 con la variable A (vinculada a 1). Está garantizado que esto fracasará. Sin embargo, es posible redefinir la variable si se hace en el encabezado de la función anidada:

base() ->
    A = 1,
   (fun(A) -> A = 2 end)(2).


Y esto funciona. Si intenta compilarlo, recibirá una advertencia sobre el sombreado ("Advertencia: variable 'A' sombreada en 'diversión'"). El sombreado es el término utilizado para describir el acto de definir una nueva variable que tiene el mismo nombre que una que estaba en el ámbito principal. Esto está ahí para evitar algunos errores (generalmente con razón), por lo que es posible que desee considerar cambiar el nombre de sus variables en estas circunstancias.

A partir de la versión 17.0, el lenguaje admite el uso de funciones anónimas con un nombre interno. Así es, funciones anónimas pero con nombre.

El truco es que el nombre es visible sólo dentro del alcance de la función, no fuera de ella. La principal ventaja de esto es que permite definir funciones recursivas anónimas. Por ejemplo, podríamos crear una función anónima que siga siendo ruidosa para siempre:

18> f(PrepareAlarm), f(AlarmReady).
ok
19> PrepareAlarm = fun(Room) ->
19>    io:format("Alarm set in ~s.~n",[Room]),
19>     fun Loop() ->
19>        io:format("Alarm tripped in ~s! Call Batman!~n",[Room]),
19>        timer:sleep(500),
19>         Loop()
19>     end
19> end.
#Fun<erl_eval.6.71889879>
20> AlarmReady = PrepareAlarm("bathroom").
Alarm set in bathroom.
#Fun<erl_eval.44.71889879>
21> AlarmReady().
Alarm tripped in bathroom! Call Batman!
Alarm tripped in bathroom! Call Batman!
Alarm tripped in bathroom! Call Batman!
...

La variable Loop se refiere a la función anónima en sí y, dentro de ese alcance, se podrá utilizar como cualquier otra variable similar que apunte a una función anónima. 

Dejaremos un poco de lado la teoría de funciones anónimas y exploraremos abstracciones más comunes para evitar tener que escribir más funciones recursivas.

Tuplas en Gleam



 import gleam/io


pub fn main() {

  let triple = #(1, 2.2, "three")

  io.debug(triple)


  let #(a, _, _) = triple

  io.debug(a)

  io.debug(triple.1)

}


Las listas son buenas cuando queremos una colección de un tipo, pero a veces queremos combinar múltiples valores de diferentes tipos. En este caso las tuplas son una opción rápida y cómoda.

La sintaxis de acceso a tupla se puede utilizar para obtener elementos de una tupla sin coincidencia de patrones. some_tuple.0 obtiene el primer elemento, some_tuple.1 obtiene el segundo elemento, etc.

Las tuplas son tipos genéricos, tienen parámetros de tipo para los tipos que contienen. #(1, "¡Hola!") tiene el tipo #(Int, String) y #(1.4, 10, 48) tiene el tipo #(Float, Int, Int).

Las tuplas se usan más comúnmente para devolver 2 o 3 valores de una función. A menudo es más claro utilizar un tipo personalizado donde se podría utilizar una tupla.

Funciones de orden superior en erlang


Una parte importante de todos los lenguajes de programación funcionales es la capacidad de tomar una función y pasarla como parámetro a otra función. Esto, a su vez, vincula ese parámetro de función a una variable que puede usarse como cualquier otra variable dentro de la función. Una función que puede aceptar otras funciones transportadas de esa manera se denomina función de orden superior. Las funciones de orden superior son un poderoso medio de abstracción y una de las mejores herramientas para dominar Erlang.

Nuevamente, este es un concepto arraigado en las matemáticas, principalmente en el cálculo lambda. No entraré en muchos detalles sobre el cálculo lambda porque a algunas personas les cuesta entenderlo y está un poco fuera de alcance. Sin embargo, lo definiré brevemente como un sistema donde todo es una función, incluso los números. Debido a que todo es una función, las funciones deben aceptar otras funciones como parámetros y pueden operar sobre ellas con aún más funciones.

Muy bien, esto puede resultar un poco extraño, así que comencemos con un ejemplo:


-module(hhfuns).

-compile(export_all).

 

one() -> 1.

two() -> 2.

 

add(X,Y) -> X() + Y().


Ahora abra el shell de Erlang, compile el módulo y comience:


1> c(hhfuns).

{ok, hhfuns}

2> hhfuns:add(one,two).

** exception error: bad function one

in function  hhfuns:add/2

3> hhfuns:add(1,2).

** exception error: bad function 1

in function  hhfuns:add/2

4> hhfuns:add(fun hhfuns:one/0, fun hhfuns:two/0).

3


¿Confuso? No tanto, una vez que sabes cómo funciona (¿no es siempre así?) En el comando 2, los átomos uno y dos se pasan a add/2, que luego usa ambos átomos como nombres de funciones (X() + Y ()). Si los nombres de las funciones se escriben sin una lista de parámetros, esos nombres se interpretan como átomos y los átomos no pueden ser funciones, por lo que la llamada falla. Esta es la razón por la que la expresión 3 también falla: los valores 1 y 2 tampoco se pueden llamar funciones, ¡y lo que necesitamos son funciones!

Es por eso que se debe agregar una nueva notación al lenguaje para permitirle pasar funciones desde fuera de un módulo. Esto es lo divertido que es Módulo: Función/Arity: le dice a la VM que use esa función específica y luego la vincule a una variable.

Entonces, ¿cuáles son las ventajas de utilizar funciones de esa manera? Bueno, quizá sea necesario un pequeño ejemplo para entenderlo. Agregaremos algunas funciones a hhfuns que funcionan de forma recursiva en una lista para sumar o restar uno de cada número entero de una lista:


increment([]) -> [];

increment([H|T]) -> [H+1|increment(T)].

 

decrement([]) -> [];

decrement([H|T]) -> [H-1|decrement(T)].


¿Ves cuán similares son estas funciones? Básicamente hacen lo mismo: recorren una lista, aplican una función en cada elemento (+ o -) y luego se llaman a sí mismos nuevamente. Casi nada cambia en ese código: solo la función aplicada y la llamada recursiva son diferentes. El núcleo de una llamada recursiva en una lista como esa es siempre el mismo. Resumiremos todas las partes similares en una sola función (mapa/2) que tomará otra función como argumento:


map(_, []) -> [];

map(F, [H|T]) -> [F(H)|map(F,T)].

 

incr(X) -> X + 1.

decr(X) -> X - 1.


Que luego se puede probar en el shell:


1> c(hhfuns).

{ok, hhfuns}

2> L = [1,2,3,4,5].

[1,2,3,4,5]

3> hhfuns:increment(L).

[2,3,4,5,6]

4> hhfuns:decrement(L).

[0,1,2,3,4]

5> hhfuns:map(fun hhfuns:incr/1, L).

[2,3,4,5,6]

6> hhfuns:map(fun hhfuns:decr/1, L).

[0,1,2,3,4]


Aquí los resultados son los mismos, ¡pero acabas de crear una abstracción muy inteligente! Cada vez que quieras aplicar una función a cada elemento de una lista, solo tienes que llamar a map/2 con tu función como parámetro. Sin embargo, es un poco molesto tener que poner cada función que queremos pasar como parámetro a map/2 en un módulo, nombrarla, exportarla, luego compilarla, etc. De hecho, es claramente poco práctico. Lo que necesitamos son funciones que puedan declararse sobre la marcha...

viernes, 28 de junio de 2024

Guards en Gleam


import gleam/io


pub fn main() {

  let numbers = [1, 2, 3, 4, 5]

  io.debug(get_first_larger(numbers, 3))

  io.debug(get_first_larger(numbers, 5))

}


fn get_first_larger(numbers: List(Int), limit: Int) -> Int {

  case numbers {

    [first, ..] if first > limit -> first

    [_, ..rest] -> get_first_larger(rest, limit)

    [] -> 0

  }

}

La palabra clave if se puede utilizar con expresiones para agregar una protección a un patrón. Una guardia es una expresión que debe evaluarse como Verdadera para que el patrón coincida.

Solo se puede utilizar un conjunto limitado de operadores y no se puede invocar ninguna función.

domingo, 23 de junio de 2024

Árboles binarios en Erlang


En primer lugar, es importante definir qué es un árbol. En nuestro caso, son nodos hasta abajo. Los nodos son tuplas que contienen una clave, un valor asociado a la clave y luego otros dos nodos. De estos dos nodos, necesitamos uno que tenga una clave más pequeña y otro que tenga una clave más grande que el nodo que los contiene. ¡Así que aquí está la recursividad! Un árbol es un nodo que contiene nodos, cada uno de los cuales contiene nodos, que a su vez también contienen nodos. Esto no puede continuar para siempre (no tenemos infinitos datos para almacenar), por lo que diremos que nuestros nodos también pueden contener nodos vacíos.

Para representar nodos, las tuplas son una estructura de datos apropiada. Para nuestra implementación, podemos definir estas tuplas como {node, {Key, Value, Smaller, Larger}} , donde Smaller y Larger pueden ser otro nodo similar o un nodo vacío ({nodo, nil} ). 

Comencemos a construir un módulo para nuestra implementación de árbol muy básica. La primera función, vacía/0, devuelve un nodo vacío. El nodo vacío es el punto de partida de un nuevo árbol, también llamado raíz:

-module(tree).

-export([empty/0, insert/3, lookup/2]).

 

empty() -> {node, 'nil'}.


Al usar esa función y luego encapsular todas las representaciones de nodos de la misma manera, ocultamos la implementación del árbol para que la gente no necesite saber cómo está construido. Toda esa información puede estar contenida únicamente en el módulo. Si alguna vez decide cambiar la representación de un nodo, puede hacerlo sin romper el código externo.

Para agregar contenido a un árbol, primero debemos entender cómo navegar recursivamente a través de él. Procedamos de la misma manera que lo hicimos con todos los demás ejemplos de recursividad, intentando encontrar el caso base. Dado que un árbol vacío es un nodo vacío, nuestro caso base es lógicamente un nodo vacío. Entonces, cada vez que lleguemos a un nodo vacío, ahí es donde podemos agregar nuestra nueva clave/valor. El resto del tiempo, nuestro código tiene que recorrer el árbol intentando encontrar un nodo vacío donde poner contenido.

Para encontrar un nodo vacío comenzando desde la raíz, debemos aprovechar el hecho de que la presencia de nodos más pequeños y más grandes nos permite navegar comparando la nueva clave que tenemos que insertar con la clave del nodo actual. Si la nueva clave es más pequeña que la clave del nodo actual, intentamos encontrar el nodo vacío dentro de Smaller, y si es más grande, dentro de Larger. Sin embargo, hay un último caso: ¿qué pasa si la nueva clave es igual a la clave del nodo actual? Allí tenemos dos opciones: dejar que el programa falle o reemplazar el valor por el nuevo. Esta es la opción que tomaremos aquí. Poner en una función toda esta lógica funciona de la siguiente manera:


insert(Key, Val, {node, 'nil'}) ->

    {node, {Key, Val, {node, 'nil'}, {node, 'nil'}}};

insert(NewKey, NewVal, {node, {Key, Val, Smaller, Larger}}) when NewKey < Key ->

    {node, {Key, Val, insert(NewKey, NewVal, Smaller), Larger}};

insert(NewKey, NewVal, {node, {Key, Val, Smaller, Larger}}) when NewKey > Key ->

    {node, {Key, Val, Smaller, insert(NewKey, NewVal, Larger)}};

insert(Key, Val, {node, {Key, _, Smaller, Larger}}) ->

    {node, {Key, Val, Smaller, Larger}}.


Tenga en cuenta aquí que la función devuelve un árbol completamente nuevo. Esto es típico de los lenguajes funcionales que tienen una sola asignación. Si bien esto puede considerarse ineficiente, la mayoría de las estructuras subyacentes de dos versiones de un árbol a veces resultan ser las mismas y, por lo tanto, la VM las comparte y las copia solo cuando es necesario.

Lo que queda por hacer en esta implementación de árbol de ejemplo es crear una función de búsqueda/2 que le permitirá encontrar un valor de un árbol proporcionando su clave. La lógica necesaria es extremadamente similar a la que se usa para agregar contenido nuevo al árbol: recorremos los nodos y verificamos si la clave de búsqueda es igual, menor o mayor que la clave del nodo actual. Tenemos dos casos base: uno cuando el nodo está vacío (la clave no está en el árbol) y otro cuando se encuentra la clave. Como no queremos que nuestro programa falle cada vez que buscamos una clave que no existe, devolveremos el átomo "indefinido". De lo contrario, devolveremos {ok, Valor}. La razón de esto es que si solo devolviéramos Valor y el nodo contuviera el átomo 'indefinido', no tendríamos forma de saber si el árbol devolvió el valor correcto o no pudo encontrarlo. Al agrupar los casos exitosos en una tupla de este tipo, facilitamos la comprensión de cuál es cuál. Aquí está la función implementada:


lookup(_, {node, 'nil'}) ->

undefined;

lookup(Key, {node, {Key, Val, _, _}}) ->

{ok, Val};

lookup(Key, {node, {NodeKey, _, Smaller, _}}) when Key < NodeKey ->

lookup(Key, Smaller);

lookup(Key, {node, {_, _, _, Larger}}) ->

lookup(Key, Larger).


Y hemos terminado. Probémoslo haciendo una pequeña libreta de direcciones de correo electrónico. Compile el archivo e inicie el shell:


1> T1 = tree:insert("Jim Woodland", "jim.woodland@gmail.com", tree:empty()).

{node,{"Jim Woodland","jim.woodland@gmail.com",

{node,nil},

{node,nil}}}

2> T2 = tree:insert("Mark Anderson", "i.am.a@hotmail.com", T1).

{node,{"Jim Woodland","jim.woodland@gmail.com",

{node,nil},

{node,{"Mark Anderson","i.am.a@hotmail.com",

{node,nil},

{node,nil}}}}}

3> Addresses = tree:insert("Anita Bath", "abath@someuni.edu", tree:insert("Kevin Robert", "myfairy@yahoo.com", tree:insert("Wilson Longbrow", "longwil@gmail.com", T2))).

{node,{"Jim Woodland","jim.woodland@gmail.com",

{node,{"Anita Bath","abath@someuni.edu",

{node,nil},

{node,nil}}},

{node,{"Mark Anderson","i.am.a@hotmail.com",

{node,{"Kevin Robert","myfairy@yahoo.com",

{node,nil},

{node,nil}}},

{node,{"Wilson Longbrow","longwil@gmail.com",

{node,nil},

{node,nil}}}}}}}


Y ahora puedes buscar direcciones de correo electrónico con él:

4> tree:lookup("Anita Bath", Addresses).

{ok, "abath@someuni.edu"}

5> tree:lookup("Jacques Requin", Addresses).

undefined


¡Esto concluye nuestro ejemplo de libreta de direcciones funcional construida a partir de una estructura de datos recursiva distinta de una lista!


viernes, 21 de junio de 2024

Hola mundo en Vaadin


Vamos a hacer un hola mundo en Vaadin. Yo voy a dar por sobreentendido que sabemos crear un proyecto con spring. Si no lo sabes es tan fácil como ir a https://start.spring.io/ y de ahi vas configurando las cosas y agregamos el framework vaadin. 

Luego creamos un nuevo paquete como por ejemplo : com.example.vaadin.ui. Dentro del paquete, creamos una nueva clase MainView.java


package com.example.vaadin.ui;


import com.vaadin.flow.component.button.Button;

import com.vaadin.flow.component.notification.Notification;

import com.vaadin.flow.component.orderedlayout.VerticalLayout;

import com.vaadin.flow.router.Route;


@Route("")

public class MainView extends VerticalLayout {


    public MainView() {

        Button button = new Button("Haz clic aquí",

                event -> Notification.show("¡Hola, Mundo!"));

        add(button);

    }

}


Y listo!! Vamos a localhost:8080 para chequear nuestro "Hola mundo". 

martes, 18 de junio de 2024

Inyectar condicionalmente un bean con profiles


Tengo 2 beans que implementan una interfaz, por ejemplo un repositorio jpa con una base de datos y otro con archivos o en memoria, ponele... Y quiero algunas veces utilizar un bean y otras otro dependiendo de una configuración, esto se puede resolver de 2 maneras. Se puedes utilizar la anotación @Conditional o @Profile.

Veamos ejemplo utilizando profile: 


public interface MyService {

    void performService();

}


@Service

@Profile("serviceA")

public class ServiceA implements MyService {

    @Override

    public void performService() {

        System.out.println("Service A implementation");

    }

}


@Service

@Profile("serviceB")

public class ServiceB implements MyService {

    @Override

    public void performService() {

        System.out.println("Service B implementation");

    }

}


Tenemos que configurar el perfil activo en application.properties:


# Para usar ServiceA
spring.profiles.active=serviceA

# Para usar ServiceB
#spring.profiles.active=serviceB


Y inyectamos el bean:


@RestController
public class MyController {

    private final MyService myService;

    @Autowired
    public MyController(MyService myService) {
        this.myService = myService;
    }

    @GetMapping("/perform")
    public String perform() {
        myService.performService();
        return "Service performed";
    }
}

Y listo!!