Argumentos etiquetados en Gleam

import gleam/io

pub fn main() {

  // Without using labels

  io.debug(calculate(1, 2, 3))

  // Using the labels

  io.debug(calculate(1, add: 2, multiply: 3))

  // Using the labels in a different order

  io.debug(calculate(1, multiply: 3, add: 2))

}

fn calculate(value: Int, add addend: Int, multiply multiplier: Int) {

  value * multiplier + addend

}

Cuando las funciones toman varios argumentos, puede resultar difícil recordar cuáles son los argumentos y en qué orden se esperan.

Para ayudar con esto, Gleam admite argumentos etiquetados, donde los argumentos de función reciben una etiqueta externa además de su nombre interno. Estas etiquetas se escriben antes del nombre del argumento en la definición de la función.

Cuando se utilizan argumentos etiquetados, el orden de los argumentos no importa, pero todos los argumentos no etiquetados deben ir antes que los argumentos etiquetados.

No hay costo de rendimiento por el uso de argumentos etiquetados, no asigna un diccionario ni realiza ningún otro trabajo en tiempo de ejecución.

Las etiquetas son opcionales al llamar a una función, corresponde al programador decidir qué es lo más claro en su código.

Queres probar código y no queres instalar nada? paiza.io

Queres probar código y no queres instalar nada? 

Bueno podes utilizar paiza. Que es una pagina donde podemos correr código en diferentes lenguajes: 

Bash, C, C#, C++, Clojure, Cobol, CoffeeScript, D, Elixir, Erlang, F#, Go, Haskell, Java, JavaScript, Kotlin, MySQL, Nadesiko, Objective-C, Perl, PHP, Python2, Python3, R, Ruby, Rust, Scala, Scheme, Swift, TypeScript, VB

Dejo link: https://paiza.io/

Pipelines en Gleam

 import gleam/io

import gleam/string

pub fn main() {

  // Without the pipe operator

  io.debug(string.drop_left(string.drop_right("Hello, Joe!", 1), 7))

  // With the pipe operator

  "Hello, Mike!"

  |> string.drop_right(1)

  |> string.drop_left(7)

  |> io.debug

  // Changing order with function capturing

  "1"

  |> string.append("2")

  |> string.append("3", _)

  |> io.debug

}

Es común querer llamar a una serie de funciones, pasando el resultado de una a la siguiente. Con la sintaxis de llamada a función normal, esto puede resultar un poco difícil de leer, ya que hay que leer el código de adentro hacia afuera.

El operador de tubería de Gleam |> ayuda con este problema permitiéndole escribir código de arriba a abajo. Es como el | en consolas unix. Es decir,  toma el resultado de la expresión de su izquierda y lo pasa como argumento a la función de su derecha.

Primero comprobará si el valor de la izquierda podría usarse como primer argumento de la llamada. Por ejemplo, a |> b(1, 2) se convertiría en b(a, 1, 2). De lo contrario, se recurre a llamar al resultado del lado derecho como una función, por ejemplo, b(1, 2)(a)

El código Gleam generalmente se escribe con el "asunto" de la función como primer argumento, para que sea más fácil de canalizar. Si desea canalizar a una posición diferente, puede utilizar una función de captura "_" para insertar el argumento en la posición deseada.

Correr todos los métodos main de un paquete en C#

Supongamos que tenemos un conjunto de clases que tienen un método main o se puede llamar como quiera y nosotros queremos pasar por parámetro el nombre de la clase y si no pasamos ningun nombre se ejecutan todos los métodos:

 using System;

using System.Linq;

using System.Reflection;

namespace Example

{

    class Program

    {

        static void Main(string[] args)

        {

            if (args[0] != null)

            {

                Run(args[0]);

            }

            else

            {

                var types = AppDomain.CurrentDomain.GetAssemblies()

                    .SelectMany(assembly => assembly.GetTypes())

                    .Where(type => "Example".Equals(type.Namespace)

                                   && !"Program".Equals(type.Name)).OrderBy(type => type.Name);

                foreach (var type in types)

                {

                    Run("Example."+type.Name);

                }

            }

        }

        private static void Run(string className)

        {

            var classType = Type.GetType(className);

            var declaredMethods = (classType as System.Reflection.TypeInfo)?.DeclaredMethods;

            if (declaredMethods == null) return;

            var mainMethod = declaredMethods.FirstOrDefault(method => method.Name == "Main");

            if (mainMethod == null)

            {

                return;

            }

            mainMethod.Invoke(null, null);

        }

    }

}

El método Run corre el metodo main de la clase pasada por parametros. Si no tiene este método, no hace nada. 

Listo!!  

Funciones genéricas en Gleam

import gleam/io

pub fn main() {

  let add_one = fn(x) { x + 1 }

  let exclaim = fn(x) { x <> "!" }

  // Invalid, Int and String are not the same type

  // twice(10, exclaim)

  // Here the type variable is replaced by the type Int

  io.debug(twice(10, add_one))

  // Here the type variable is replaced by the type String

  io.debug(twice("Hello", exclaim))

}

// The name `value` refers to the same type multiple times

fn twice(argument: value, my_function: fn(value) -> value) -> value {

  my_function(my_function(argument))

}

Gleam admite genéricos, también conocidos como polimorfismo paramétrico.

Esto funciona utilizando una variable de tipo en lugar de especificar un tipo concreto. Reemplaza cualquier tipo específico que se utilice cuando se llama a la función. Estas variables de tipo se escriben con un nombre en minúscula.

Las variables de tipo no son como cualquier tipo, se reemplazan con un tipo específico cada vez que se llama a la función. 

Usando Roslyn ScriptEngine

La idea es correr C# como un lenguaje script y esto lo podemos hacer con Roslyn. 

Primero, instalamos las dependencias: 

dotnet add package Microsoft.CodeAnalysis.Scripting --version 4.9.2

dotnet add package Microsoft.CodeAnalysis.CSharp.Scripting --version 4.9.2

Y con eso ya estamos, podemos hacer esto: 

using System;

using Microsoft.CodeAnalysis.CSharp.Scripting;

using Microsoft.CodeAnalysis.Scripting;

class Program

{

    static async System.Threading.Tasks.Task Main(string[] args)

    {

        try

        {

            // Creamos el script

            string code = @"

                using System;

                public class MyClass

                {

                    public void MyMethod()

                    {

                        Console.WriteLine(""Hello from C#!"");

                    }

                }";

            // Creamos las opciones (usamos las por defecto) 

            ScriptOptions options = ScriptOptions.Default;

            // Creamos el motor que ejecuta el script

            var script = CSharpScript.Create(code, options);

            // corremos el script

            var result = await script.RunAsync();

            // Y chequeamos si hubo error. 

            if (result.Exception != null)

            {

                Console.WriteLine("Script execution failed: " + result.Exception.Message);

            }

        }

        catch (Exception ex)

        {

            Console.WriteLine("Error executing script: " + ex.Message);

        }

    }

}

Y listo! 

Lo unico malo es que este lenguaje C# no es completo, por ejemplo no se pueden utiliza namespace. Pero para hacer cosas chicas, esta bueno. 

Dejo link: 

https://github.com/dotnet/roslyn/tree/main

Más sobre funciones anónimas en Gleam

import gleam/io

pub fn main() {

  // These two statements are equivalent

  let add_one_v1 = fn(x) { add(1, x) }

  let add_one_v2 = add(1, _)

  io.debug(add_one_v1(10))

  io.debug(add_one_v2(10))

}

fn add(a: Int, b: Int) -> Int {

  a + b

}

Gleam tiene una sintaxis abreviada para crear funciones anónimas que toman un argumento e inmediatamente llaman a otra función con ese argumento: la sintaxis de captura de función.

La función anónima fn(a) { some_function(..., a, ...) } se puede escribir como some_function(..., _, ...), con cualquier número de otros argumentos pasados directamente a la función interna . El guión bajo _ es un marcador de posición para el argumento, equivalente a a en fn(a) { some_function(..., a, ...) }.

Guards en Erlang

Guards son cláusulas adicionales que pueden ir en la cabeza de una función para hacer pattern matching más expresivo. Como se mencionó anteriormente, el pattern matching es algo limitado ya que no puede expresar cosas como un rango de valores o ciertos tipos de datos. 

Por ejemplo, esto con Pattern matching : 

old_enough(0) -> false;

old_enough(1) -> false;

old_enough(2) -> false;

...

old_enough(14) -> false;

old_enough(15) -> false;

old_enough(_) -> true.

Es muy trabajoso pero si utilizamos guards : 

old_enough(X) when X >= 16 -> true;

old_enough(_) -> false.

Tenga en cuenta que Guards deben devolver verdadero para tener éxito. Guards fallará si devuelve falso o si genera una excepción. Supongamos que ahora prohibimos conducir a las personas mayores de 104 años. Nuestras edades válidas para conductores ahora son desde 16 años hasta 104 años. Tenemos que ocuparnos de eso, pero ¿cómo? Agreguemos una segunda cláusula de protección:

right_age(X) when X >= 16, X =< 104 -> true;

right_age(_)  -> false.

La coma (,) actúa de manera similar al operador and y el punto y coma (;) actúa un poco como or. Ambas expresiones deben tener éxito para que retorne verdadero. También podríamos representar la función al revés:

wrong_age(X) when X < 16; X > 104 -> true;

wrong_age(_) -> false.

Con punto y coma, si la primera condición falla, intenta con la segunda y luego con la siguiente, hasta que una tenga éxito o todas fallen.

Un punto negativo de los guards es que no aceptan funciones definidas por el usuario debido a los efectos secundarios. Erlang no es un lenguaje de programación puramente funcional (como lo es Haskell) porque depende mucho de los efectos secundarios: puedes realizar E/S, enviar mensajes entre actores o generar errores como quieras y cuando quieras. No existe una forma trivial de determinar si una función que usaría en una protección imprimiría o no texto o detectaría errores importantes cada vez que se prueba en muchas cláusulas de función. Entonces, en cambio, Erlang simplemente no confía en usted (¡y puede que sea correcto hacerlo!)

Capturas de funciones de Gleam

 

import gleam/io

pub fn main() {

  // These two statements are equivalent

  let add_one_v1 = fn(x) { add(1, x) }

  let add_one_v2 = add(1, _)

  io.debug(add_one_v1(10))

  io.debug(add_one_v2(10))

}

fn add(a: Int, b: Int) -> Int {

  a + b

}

Gleam tiene una sintaxis abreviada para crear funciones anónimas que toman un argumento e inmediatamente llaman a otra función con ese argumento: la sintaxis de captura de función.

La función anónima fn(a) { some_function(..., a, ...) } se puede escribir como some_function(..., _, ...), con cualquier cantidad de otros argumentos pasados directamente a la función interna . El guión bajo _ es un marcador de posición para el argumento, equivalente a a en fn(a) { some_function(..., a, ...) }.

Pattern Matching en Erlang parte 2

Iniciemos un nuevo módulo llamado funciones en el que escribiremos un montón de funciones para explorar Pattern Matching:

-module(functions).

-compile(export_all). %% replace with -export() later, for God's sake!

La primera función que escribiremos es head/1, que actúa exactamente como erlang:hd/1, que toma una lista como argumento y devuelve su primer elemento. Se hará con la ayuda del operador | :

head([H|_]) -> H.

Para obtener el segundo elemento de una lista crearíamos la función:

second([_,X|_]) -> X.

Erlang simplemente deconstruirá la lista con Pattern Matching

1> c(functions).

{ok, functions}

2> functions:head([1,2,3,4]).

1

3> functions:second([1,2,3,4]).

2

Crearemos una función same/2 que toma dos argumentos y dice si son idénticos:

same(X,X) ->

true;

same(_,_) ->

false.

Y es así de simple. Antes de explicar cómo funciona la función, repasaremos nuevamente el concepto de variables vinculadas y no vinculadas, por si acaso.

Las variables independientes son variables sin ningún valor asociado. Vincular una variable es simplemente adjuntar un valor a una variable independiente. En el caso de Erlang, cuando se desea asignar un valor a una variable que ya está vinculada, se produce un error a menos que el nuevo valor sea el mismo que el anterior. 

Volviendo a nuestro código: lo que sucede cuando llamas a Same(a,a) es que la primera X se ve como independiente: automáticamente toma el valor a. Luego, cuando Erlang pasa al segundo argumento, ve que X ya está vinculado. Luego lo compara con el a pasado como segundo argumento y mira para ver si coincide. La coincidencia de patrones se realiza correctamente y la función devuelve verdadero. Si los dos valores no son iguales, esto fallará y pasará a la segunda cláusula de función, a la que no le importan sus argumentos (cuando eres el último en elegir, ¡no puedes ser exigente!) y en su lugar lo hará. falso retorno. Tenga en cuenta que esta función puede aceptar cualquier tipo de argumento. Funciona para cualquier tipo de datos, no solo listas o variables individuales. Como ejemplo bastante avanzado, la siguiente función imprime una fecha, pero sólo si tiene el formato correcto:

valid_time({Date = {Y,M,D}, Time = {H,Min,S}}) ->

    io:format("The Date tuple (~p) says today is: ~p/~p/~p,~n",[Date,Y,M,D]),

    io:format("The time tuple (~p) indicates: ~p:~p:~p.~n", [Time,H,Min,S]);

valid_time(_) ->

   io:format("Stop feeding me wrong data!~n").

Tenga en cuenta que es posible utilizar el operador = en el encabezado de la función, lo que nos permite hacer coincidir tanto el contenido dentro de una tupla ({Y,M,D}) como la tupla en su conjunto. La función se puede probar de la siguiente manera:

4> c(functions).

{ok, functions}

5> functions:valid_time({{2011,09,06},{09,04,43}}).

The Date tuple ({2011,9,6}) says today is: 2011/9/6,

The time tuple ({9,4,43}) indicates: 9:4:43.

ok

6> functions:valid_time({{2011,09,06},{09,04}}).

Stop feeding me wrong data!

ok

¡Sin embargo hay un problema! Esta función podría tomar cualquier valor como valor, incluso texto o átomos, siempre que las tuplas tengan la forma {{A,B,C}, {D,E,F}}. Esto denota uno de los límites de Pattern Matching: puede especificar valores realmente precisos, como un número conocido de átomos, o valores abstractos, como el head o tail de una lista, una tupla de N elementos o cualquier cosa _ , etc. Para solucionar este problema utilizamos Guards.

Funciones anónimas en Gleam

 import gleam/io

pub fn main() {

  // Assign an anonymous function to a variable

  let add_one = fn(a) { a + 1 }

  io.debug(twice(1, add_one))

  // Pass an anonymous function as an argument

  io.debug(twice(1, fn(a) { a * 2 }))

}

fn twice(argument: Int, my_function: fn(Int) -> Int) -> Int {

  my_function(my_function(argument))

}

Además de las funciones con nombre a nivel de módulo, Gleam tiene literales de funciones anónimas, escritas con la sintaxis fn() { ... }.

Las funciones anónimas se pueden utilizar indistintamente con funciones con nombre.

Pattern Matching en Erlang

La primera función que escribiremos deberá saludar a alguien de manera diferente según el género. En la mayoría de los lenguajes necesitarías escribir algo similar a esto:

function greet(Gender,Name)

if Gender == male then

    print("Hello, Mr. %s!", Name)

else if Gender == female then

    print("Hello, Mrs. %s!", Name)

else

    print("Hello, %s!", Name)

end

Con Pattern Matching, Erlang le ahorra una gran cantidad de código repetitivo. Una función similar en Erlang se vería así:

greet(male, Name) ->

    io:format("Hello, Mr. ~s!", [Name]);

greet(female, Name) ->

    io:format("Hello, Mrs. ~s!", [Name]);

greet(_, Name) ->

    io:format("Hello, ~s!", [Name]).

La principal diferencia aquí es que usamos Pattern Matching para definir qué partes de una función deben usarse y vincular los valores que necesitamos al mismo tiempo. ¡No era necesario vincular primero los valores y luego compararlos! Entonces en lugar de:

function(X) ->

    Expression;

function(Y) ->

    Expression;

function(_) ->

    Expression.

para obtener resultados similares, pero en un estilo mucho más declarativo. Cada una de estas declaraciones de funciones se denomina cláusula de función. Las cláusulas de función deben estar separadas por punto y coma (;) y juntas forman una declaración de función. Una declaración de función cuenta como una declaración más grande y es por eso que la cláusula de función final termina con un punto. 

Funciones de primer orden en Gleam

 

import gleam/io

pub fn main() {

  // Call a function with another function

  io.debug(twice(1, add_one))

  // Functions can be assigned to variables

  let my_function = add_one

  io.debug(my_function(100))

}

fn twice(argument: Int, passed_function: fn(Int) -> Int) -> Int {

  passed_function(passed_function(argument))

}

fn add_one(argument: Int) -> Int {

  argument + 1

}

En Gleam las funciones son valores. Se pueden asignar a variables, pasar a otras funciones y cualquier otra cosa que pueda hacer con valores.

Aquí la función add_one se pasa como argumento a la función dos veces.

Observe que la palabra clave fn también se usa para describir el tipo de función que toma dos veces como segundo argumento.

ClearScript

ClearScript es una librería que permite ejecutar javascript o VBScript en .NET. Actualmente es compatible con JavaScript (a través de V8 y JScript) y VBScript.

Vamos con un ejemplo:

Primero agregamos la dependencia: 

dotnet add package Microsoft.ClearScript --version 7.4.5

Y bueno, ahora podemos ejecutar javascript por ejemplo: 

using Microsoft.ClearScript;

using Microsoft.ClearScript.V8;

public class Example

{

    static void Main()

    {

        // Create a new V8ScriptEngine

        using var engine = new V8ScriptEngine();

        try

        {

            // Execute JavaScript code

            engine.Execute("var x = 10; var y = 20; var z = x + y;");

            // Get the value of a JavaScript variable

            var zValue = engine.Script.z;

            Console.WriteLine("The value of z is: " + zValue);

        }

        catch (ScriptEngineException ex)

        {

            Console.WriteLine("Error executing JavaScript: " + ex.Message);

        }

    }

}

Y si todo fue bien el resultado es: 

The value of z is: 30

Y listo! 

Dejo link: https://microsoft.github.io/ClearScript/

Funciones en Gleam

import gleam/io

pub fn main() {

  io.debug(double(10))

}

fn double(a: Int) -> Int {

  multiply(a, 2)

}

fn multiply(a: Int, b: Int) -> Int {

  a * b

}

La palabra clave fn se utiliza para definir nuevas funciones.

Las funciones double y multiply se definen sin la palabra clave pub. Esto las convierte en funciones privadas, solo se pueden utilizar dentro de este módulo. Si otro módulo intentara usarlos, se produciría un error del compilador.

Al igual que con las asignaciones, las anotaciones de tipo son opcionales para los argumentos de funciones y los valores de retorno. Se considera una buena práctica utilizar anotaciones tipográficas para funciones, para mayor claridad y para fomentar un diseño intencional y reflexivo.