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.

Á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!

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". 

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!!

Alias ​​en patrones en Gleam

import gleam/io

pub fn main() {

  io.debug(get_first_non_empty([[], [1, 2, 3], [4, 5]]))

  io.debug(get_first_non_empty([[1, 2], [3, 4, 5], []]))

  io.debug(get_first_non_empty([[], [], []]))

}

fn get_first_non_empty(lists: List(List(t))) -> List(t) {

  case lists {

    [[_, ..] as first, ..] -> first

    [_, ..rest] -> get_first_non_empty(rest)

    [] -> []

  }

}

El operador as se puede utilizar para asignar subpatrones a variables.

El patrón [_, ..] como primero coincidirá con cualquier lista que no esté vacía y asignará esa lista a la variable first.

Quicksort en Erlang

Una implementación ingenua de Quicksort funciona tomando el primer elemento de una lista, el pivote, y luego colocando todos los elementos más pequeños o iguales al pivote en una nueva lista, y todos los más grandes en otra lista. Luego tomamos cada una de estas listas y hacemos lo mismo con ellas hasta que cada lista se hace cada vez más pequeña. Esto continúa hasta que no tenga nada más que una lista vacía para ordenar, que será nuestro caso base. Se dice que esta implementación es ingenua porque las versiones más inteligentes de Quicksort intentarán elegir pivotes óptimos para ser más rápidos. Sin embargo, eso realmente no nos importa para nuestro ejemplo.

Necesitaremos dos funciones para esto: una primera función para dividir la lista en partes más pequeñas y más grandes y una segunda función para aplicar la función de partición en cada una de las nuevas listas y unirlas. En primer lugar, escribiremos la función de pegamento:

quicksort([]) -> [];

quicksort([Pivot|Rest]) ->

{Smaller, Larger} = partition(Pivot,Rest,[],[]),

quicksort(Smaller) ++ [Pivot] ++ quicksort(Larger).

Esto muestra el caso base, una lista ya dividida en partes más grandes y más pequeñas por otra función, el uso de un pivote con ambas listas ordenadas rápidamente añadidas antes y después. Entonces esto debería encargarse de armar listas. Ahora la función de partición:

partition(_,[], Smaller, Larger) -> {Smaller, Larger};

partition(Pivot, [H|T], Smaller, Larger) ->

if H =< Pivot -> partition(Pivot, T, [H|Smaller], Larger);

H >  Pivot -> partition(Pivot, T, Smaller, [H|Larger])

end.

Y ahora puede ejecutar su función de clasificación rápida. Si ha buscado ejemplos de Erlang en Internet antes, es posible que haya visto otra implementación de clasificación rápida, una que es más simple y fácil de leer, pero que utiliza listas por comprensión. Las piezas fáciles de reemplazar son las que crean nuevas listas, la función partición/4:

lc_quicksort([]) -> [];

lc_quicksort([Pivot|Rest]) ->

lc_quicksort([Smaller || Smaller <- Rest, Smaller =< Pivot])

++ [Pivot] ++

lc_quicksort([Larger || Larger <- Rest, Larger > Pivot]).

Las principales diferencias son que esta versión es mucho más fácil de leer, pero a cambio, tiene que recorrer la lista dos veces para dividirla en dos partes. Esta es una lucha entre la claridad y el rendimiento, pero el verdadero perdedor aquí eres tú, porque ya existe una función listas:ordenar/1. Usa ese en su lugar.

Toda esta concisión es buena para fines educativos, pero no para el rendimiento. ¡Muchos tutoriales de programación funcional nunca mencionan esto! En primer lugar, aquí ambas implementaciones deben procesar valores que sean iguales al pivote más de una vez. En su lugar, podríamos haber decidido devolver 3 listas: elementos más pequeños, más grandes e iguales al pivote para hacerlo más eficiente.

Patrones alternativos en Gleam

import gleam/int

import gleam/io

pub fn main() {

  let number = int.random(10)

  io.debug(number)

  let result = case number {

    2 | 4 | 6 | 8 -> "This is an even number"

    1 | 3 | 5 | 7 -> "This is an odd number"

    _ -> "I'm not sure"

  }

  io.debug(result)

}

Se puede realizar una acción con varias cohicidencias de patrones con el operador | . Si alguno de los patrones coincide, entonces la cláusula coincide.

Si un patrón define una variable, entonces todos los patrones alternativos para esa cláusula también deben definir una variable con el mismo nombre y el mismo tipo.

Actualmente no es posible tener patrones alternativos anidados, por lo que el patrón [1 | 2 | 3] no es válido.

Patrones con múltiples valores en Gleam

import gleam/int

import gleam/io

pub fn main() {

  let x = int.random(2)

  let y = int.random(2)

  io.debug(x)

  io.debug(y)

  let result = case x, y {

    0, 0 -> "Both are zero"

    0, _ -> "First is zero"

    _, 0 -> "Second is zero"

    _, _ -> "Neither are zero"

  }

  io.debug(result)

}

A veces necesitaamos patrones en múltiples valores.  Para hacer esto, puedes dar múltiples temas y múltiples patrones, separados por comas.

Al hacer coincidir varios temas, debe haber la misma cantidad de patrones que temas.

Más Funciones Recursivas en Erlang parte 4

Para llevar las cosas un poco más allá, escribiremos una función de compresión. Una función de compresión tomará dos listas de la misma longitud como parámetros y las unirá como una lista de tuplas que contienen dos términos. Nuestra propia función zip/2 se comportará de esta manera:

1> recursive:zip([a,b,c],[1,2,3]).

[{a,1},{b,2},{c,3}]

Dado que queremos que nuestros parámetros tengan la misma longitud, el caso base comprimirá dos listas vacías:

zip([],[]) -> [];

zip([X|Xs],[Y|Ys]) -> [{X,Y}|zip(Xs,Ys)].

Sin embargo, si desea una función zip más indulgente, puede decidir que finalice cada vez que finalice una de las dos listas. Por lo tanto, en este escenario, tiene dos casos base:

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

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

lenient_zip([X|Xs],[Y|Ys]) -> [{X,Y}|lenient_zip(Xs,Ys)].

Observe que no importa cuáles sean nuestros casos base, la parte recursiva de la función sigue siendo la misma. 

La recursividad de cola como se ve aquí no hace que la memoria crezca porque cuando la máquina virtual ve una función que se llama a sí misma en una posición de cola (la última expresión que se evaluará en una función), elimina el marco de pila actual. Esto se denomina optimización de llamada final (TCO) y es un caso especial de una optimización más general denominada optimización de última llamada (LCO).

LCO se realiza siempre que la última expresión que se evaluará en el cuerpo de una función es otra llamada de función. Cuando eso sucede, al igual que con el TCO, Erlang VM evita almacenar el marco de la pila. Como tal, la recursividad de cola también es posible entre múltiples funciones. Como ejemplo, la cadena de funciones a() -> b(). b()->c(). c()->a(). creará efectivamente un bucle infinito que no se quedará sin memoria ya que LCO evita el desbordamiento de la pila. Este principio, combinado con nuestro uso de acumuladores, es lo que hace que la recursividad de cola sea útil.

Más Funciones Recursivas en Erlang parte 3

Otra función a implementar podría ser sublist/2, que toma una lista L y un número entero N, y devuelve los N primeros elementos de la lista. Como ejemplo, sublista([1,2,3,4,5,6],3) devolvería [1,2,3]. Nuevamente, el caso base intenta obtener 0 elementos de una lista. Sin embargo, tenga cuidado, porque sublist/2 es un poco diferente. ¡Tienes un segundo caso base cuando la lista aprobada está vacía! Si no verificamos si hay listas vacías, se generará un error al llamar a recursive:sublist([1],2). mientras que queremos [1] en su lugar. Una vez definido esto, la parte recursiva de la función solo tiene que recorrer la lista, manteniendo los elementos a medida que avanza, hasta llegar a uno de los casos base:

sublist(_,0) -> [];

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

sublist([H|T],N) when N > 0 -> [H|sublist(T,N-1)].

Que luego se puede transformar a una forma recursiva de cola de la misma manera que antes:

tail_sublist(L, N) -> tail_sublist(L, N, []).

 

tail_sublist(_, 0, SubList) -> SubList;

tail_sublist([], _, SubList) -> SubList;

tail_sublist([H|T], N, SubList) when N > 0 -> tail_sublist(T, N-1, [H|SubList]).

Hay un defecto en esta función. ¡Un defecto fatal! Usamos una lista como acumulador exactamente de la misma manera que lo hicimos para invertir nuestra lista. Si compila esta función tal como está, sublist([1,2,3,4,5,6],3) no devolverá [1,2,3], sino [3,2,1]. Lo único que podemos hacer es tomar el resultado final y revertirlo nosotros mismos. Simplemente cambie la llamada tail_sublist/2 y deje intacta toda nuestra lógica recursiva:

tail_sublist(L, N) -> reverse(tail_sublist(L, N, [])).

El resultado final estará ordenado correctamente. Podría parecer que revertir nuestra lista después de una llamada recursiva de cola es una pérdida de tiempo y estaría en parte en lo cierto (todavía ahorramos memoria al hacer esto). En listas más cortas, es posible que descubra que su código se ejecuta más rápido con llamadas recursivas normales que con llamadas recursivas de cola por este motivo, pero a medida que sus conjuntos de datos crezcan, invertir la lista será comparativamente más ligero.

Recursividad de listas en Gleam

import gleam/io

pub fn main() {

  let sum = sum_list([18, 56, 35, 85, 91], 0)

  io.debug(sum)

}

fn sum_list(list: List(Int), total: Int) -> Int {

  case list {

    [first, ..rest] -> sum_list(rest, total + first)

    [] -> total

  }

}

Si bien es más común usar funciones en el módulo gleam/list para iterar a través de una lista, en ocasiones es posible que prefieras trabajar con la lista directamente.

El patrón [primero, ..rest] coincide en una lista con al menos un elemento, asignando primero el primer elemento a la variable y el resto de la lista a la variable resto. Al usar este patrón y un patrón para la lista vacía [], una función puede ejecutar código en cada elemento de una lista hasta llegar al final.

Este código suma una lista recurriendo a la lista y agregando cada int a un argumento total, devolviéndolo cuando se llega al final.

Más Funciones Recursivas en Erlang parte 2

Hay una propiedad interesante que podemos "descubrir" cuando comparamos funciones recursivas y recursivas de cola escribiendo una función inversa/1, que invertirá una lista de términos. Para tal función, el caso base es una lista vacía, para la cual no tenemos nada que revertir. Podemos simplemente devolver una lista vacía cuando eso suceda. Cualquier otra posibilidad debería intentar converger al caso base llamándose a sí mismo, como con duplicado/2. Nuestra función iterará a través de la lista haciendo coincidir el patrón [H|T] y luego poniendo H después del resto de la lista:

reverse([]) -> [];

reverse([H|T]) -> reverse(T)++[H].

En listas largas, esto será una verdadera pesadilla: no solo acumularemos todas nuestras operaciones de agregados, sino que también necesitaremos recorrer toda la lista para cada uno de estos agregados hasta el último. Para los lectores visuales, los numerosos controles se pueden representar como:

reverse([1,2,3,4]) = [4]++[3]++[2]++[1]

                      ↑    ↵

                   = [4,3]++[2]++[1]

                      ↑ ↑    ↵

                   = [4,3,2]++[1]

                      ↑ ↑ ↑    ↵

                   = [4,3,2,1]

Aquí es donde la recursividad de cola viene al rescate. Debido a que usaremos un acumulador y le agregaremos un nuevo encabezado cada vez, nuestra lista se invertirá automáticamente. Primero veamos la implementación:

tail_reverse(L) -> tail_reverse(L,[]).

 

tail_reverse([],Acc) -> Acc;

tail_reverse([H|T],Acc) -> tail_reverse(T, [H|Acc]).

Si representamos ésta de manera similar a la versión normal, obtenemos:

tail_reverse([1,2,3,4]) = tail_reverse([2,3,4], [1])

                        = tail_reverse([3,4], [2,1])

                        = tail_reverse([4], [3,2,1])

                        = tail_reverse([], [4,3,2,1])

                        = [4,3,2,1]   

Lo que muestra que la cantidad de elementos visitados para revertir nuestra lista ahora es lineal: no solo evitamos hacer crecer la pila, ¡sino que también hacemos nuestras operaciones de una manera mucho más eficiente!

Más Funciones Recursivas en Erlang

Escribiremos algunas funciones recursivas más, sólo para acostumbrarnos un poco más. Después de todo, al ser la recursividad la única construcción de bucle que existe en Erlang (excepto las listas por comprensión), es uno de los conceptos más importantes que hay que comprender. También es útil en cualquier otro lenguaje de programación funcional.

La primera función que escribiremos será duplicar/2. Esta función toma un número entero como primer parámetro y luego cualquier otro término como segundo parámetro. Luego creará una lista de tantas copias del término como especifique el número entero. Como antes, pensar primero en el caso base es lo que podría ayudarle a ponerse en marcha. Para duplicado/2, pedir repetir algo 0 veces es lo más básico que se puede hacer. Todo lo que tenemos que hacer es devolver una lista vacía, sin importar cuál sea el término. Todos los demás casos deben intentar llegar al caso base llamando a la función misma. También prohibiremos los valores negativos para el número entero, porque no puedes duplicar algo -n veces:

duplicate(0,_) -> [];

duplicate(N,Term) when N > 0 -> [Term|duplicate(N-1,Term)].

Una vez que se encuentra la función recursiva básica, resulta más fácil transformarla en una función recursiva de cola moviendo la construcción de la lista a una variable temporal:

tail_duplicate(N,Term) -> tail_duplicate(N,Term,[]).

 

tail_duplicate(0,_,List) -> List;

tail_duplicate(N,Term,List) when N > 0 -> tail_duplicate(N-1, Term, [Term|List]).

Recursión por cola en Gleam

import gleam/io

pub fn main() {

  io.debug(factorial(5))

  io.debug(factorial(7))

}

pub fn factorial(x: Int) -> Int {

  // The public function calls the private tail recursive function

  factorial_loop(x, 1)

}

fn factorial_loop(x: Int, accumulator: Int) -> Int {

  case x {

    0 -> accumulator

    1 -> accumulator

    // The last thing this function does is call itself

    // In the previous lesson the last thing it did was multiply two ints

    _ -> factorial_loop(x - 1, accumulator * x)

  }

}

Cuando se llama a una función, se crea un nuevo marco de pila en la memoria para almacenar los argumentos y las variables locales de la función. Si se crean muchos de estos fotogramas durante la recursividad, entonces el programa utilizará una gran cantidad de memoria o incluso bloqueará el programa si se alcanza algún límite.

Para evitar este problema, Gleam admite la optimización de llamadas de cola, lo que permite al compilador reutilizar el marco de pila para la función actual si una llamada a función es lo último que hace la función, eliminando el costo de memoria.

Las funciones recursivas no optimizadas a menudo se pueden reescribir en funciones optimizadas de llamada final mediante el uso de un acumulador. Un acumulador es una variable que se pasa además de los datos, similar a una variable mutable en un lenguaje con bucles while.

Los acumuladores deben estar ocultos a los usuarios de su código, son detalles de implementación interna. Para hacer esto, escriba una función pública que llame a una función privada recursiva con el valor inicial del acumulador.

Alpaca, un lenguaje funcional, de tipado estático que corre en la VM de Erlang

Me quedo relargo el titulo :( 

Alpaca es un lenguaje de programación funcional inspirado en Elm y Haskell, diseñado para ser simple, seguro y eficiente.

Alpaca es un lenguaje de programación funcional que se ejecuta sobre la máquina virtual de Erlang (BEAM). Está diseñado para aprovechar las ventajas de la concurrencia y la tolerancia a fallos inherentes a la VM de Erlang, mientras proporciona una sintaxis limpia y moderna inspirada en lenguajes como Elm y Haskell. Alpaca está orientado a ser utilizado en el desarrollo de sistemas distribuidos y aplicaciones concurrentes.

Alpaca es un lenguaje puramente funcional, lo que significa que las funciones son ciudadanos de primera clase y no hay efectos secundarios.

Utiliza un sistema de tipos estático y fuerte, lo que ayuda a atrapar errores en tiempo de compilación, mejorando la fiabilidad del código.

Aprovecha la VM de Erlang, famosa por su modelo de actor y su capacidad para manejar grandes volúmenes de procesos concurrentes.

Ideal para desarrollar sistemas distribuidos y aplicaciones que requieren alta disponibilidad.

Alpaca puede interactuar fácilmente con código Erlang, permitiendo a los desarrolladores integrar nuevas funcionalidades en sistemas existentes escritos en Erlang.

Inspirado en Elm y Haskell, Alpaca presenta una sintaxis clara y concisa que facilita la lectura y escritura del código.

Enfocado en la simplicidad, lo que permite a los desarrolladores concentrarse en la lógica del negocio sin distraerse con detalles innecesarios del lenguaje.

Veamos un ejemplo: 

module Factorial

let rec fact n =

  if n == 0 then

    1

  else

    n * fact (n - 1)

En este ejemplo, la función fact calcula el factorial de un número n. Utiliza recursión, una característica común en los lenguajes funcionales, para realizar el cálculo.

Alpaca es un lenguaje de programación funcional prometedor que combina la potencia y fiabilidad de la VM de Erlang con una sintaxis moderna y clara. Es una excelente opción para desarrolladores interesados en sistemas concurrentes y distribuidos, y aquellos que disfrutan de los beneficios de la programación funcional. Con Alpaca, puedes escribir código limpio, eficiente y altamente concurrente, aprovechando al máximo las capacidades de Erlang.

Dejo link: 

https://github.com/alpaca-lang/alpaca

Función Length en erlang

Implementaremos una función para contar cuántos elementos contiene una lista. Entonces sabemos desde el principio que necesitaremos:

1. un caso base;
2. una función que se llama a sí misma;
3. una lista para probar nuestra función.

Con la mayoría de las funciones recursivas, encuentro que el caso base es más fácil de escribir primero: ¿cuál es la entrada más simple a partir de la cual podemos encontrar una longitud? Seguramente una lista vacía es la más simple, con una longitud de 0. Así que tomemos nota mental de que [] = 0 cuando se trata de longitudes. Entonces la siguiente lista más simple tiene una longitud de 1: [_] = 1. Esto parece suficiente para comenzar con nuestra definición. Podemos escribir esto:

len([]) -> 0;

len([_]) -> 1.

Se mencionó anteriormente que las listas se definen recursivamente como [1 | [2| ... [n | []]]]. Esto significa que podemos usar el patrón [H|T] para comparar listas de uno o más elementos, ya que una lista de longitud uno se definirá como [X|[]] y una lista de longitud dos se definirá como [X |[Y|[]]]. Tenga en cuenta que el segundo elemento es una lista en sí. Esto significa que solo necesitamos contar el primero y la función puede llamarse a sí misma en el segundo elemento. Dado que cada valor en una lista cuenta como una longitud de 1, la función se puede reescribir de la siguiente manera:

len([]) -> 0;

len([_|T]) -> 1 + len(T).

Y ahora tienes tu propia función recursiva para calcular la longitud de una lista. Para ver cómo se comportaría len/1 cuando se ejecute, probémoslo en una lista dada, digamos [1,2,3,4]:

len([1,2,3,4]) = len([1 | [2,3,4])

 = 1 + len([2 | [3,4]])

 = 1 + 1 + largo([3 | [4]])

 = 1 + 1 + 1 + len([4 | []])

 = 1 + 1 + 1 + 1 + longitud([])

 = 1 + 1 + 1 + 1 + 0

 = 1 + 1 + 1 + 1

 = 1 + 1 + 2

 = 1 + 3

 = 4

Cuál es la respuesta correcta. 

Recursion en erlang

La recursividad se puede explicar con la ayuda de conceptos y funciones matemáticas. Una función matemática básica como el factorial de un valor es un buen ejemplo de una función que se puede expresar de forma recursiva. El factorial de un número n es el producto de la secuencia 1 x 2 x 3 x ... x n, o alternativamente n x (n-1) x (n-2) x ... x 1. Para dar algunos ejemplos, el factorial de 3 es 3! = 3 x 2 x 1 = 6. ¡El factorial de 4 sería 4! = 4 x 3 x 2 x 1 = 24. Dicha función se puede expresar de la siguiente manera en notación matemática:

Lo que esto nos dice es que si el valor de n que tenemos es 0, devolvemos el resultado 1. Para cualquier valor superior a 0, devolvemos n multiplicado por el factorial de n-1, que se desarrolla hasta llegar a 1:

4! = 4 x 3!

4! = 4x3x2!

4! = 4x3x2x1!

4! = 4 x 3 x 2 x 1 x 1

¿Cómo se puede traducir una función así de la notación matemática a Erlang? La conversión es bastante simple. Eche un vistazo a las partes de la notación: n!, 1 y n((n-1)!) y luego los ifs. Lo que tenemos aquí es un nombre de función (n!), guardias (los if) y el cuerpo de la función (1 y n((n-1)!)). ¡Cambiaremos el nombre de n! a fac(N) para restringir un poco nuestra sintaxis y luego obtenemos lo siguiente:

-module(recursive).

-export([fac/1]).

 

fac(N) when N == 0 -> 1;

fac(N) when N > 0  -> N*fac(N-1).

¡Y esta función factorial ya está hecha! En realidad, es bastante similar a la definición matemática. Con la ayuda de la coincidencia de patrones, podemos acortar un poco la definición:

fac(0) -> 1;

fac(N) when N > 0 -> N*fac(N-1).

Una definición de recursividad podría abreviarse diciendo "una función que se llama a sí misma". Sin embargo, necesitamos tener una condición de parada (el término real es el caso base), porque de lo contrario haríamos un bucle infinito. En nuestro caso, la condición de detención es cuando n es igual a 0. En ese momento ya no le decimos a nuestra función que se llame a sí misma y detiene su ejecución allí mismo.

Recursión en Gleam

import gleam/io

pub fn main() {

  io.debug(factorial(5))

  io.debug(factorial(7))

}

// A recursive functions that calculates factorial

pub fn factorial(x: Int) -> Int {

  case x {

    // Base case

    0 -> 1

    1 -> 1

    // Recursive case

    _ -> x * factorial(x - 1)

  }

}

Gleam no tiene bucles, sino que la iteración se realiza mediante recursividad, es decir, mediante funciones de nivel superior que se llaman a sí mismas con diferentes argumentos.

Una función recursiva debe tener al menos un caso base y al menos un caso recursivo. Un caso base devuelve un valor sin volver a llamar a la función. Un caso recursivo vuelve a llamar a la función con diferentes entradas, volviendo a realizar un bucle.

La biblioteca estándar de Gleam tiene funciones para varios patrones de bucles comunes, algunos de los cuales se introducirán en lecciones posteriores; sin embargo, para bucles más complejos, la recursividad manual suele ser la forma más clara de escribirlo.

La recursividad puede parecer desalentadora o confusa al principio si estás más familiarizado con los lenguajes que tienen características especiales de bucle, ¡pero mantente firme! Con el tiempo, resultará tan familiar y cómodo como cualquier otra forma de iteración.