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/
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
}
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!!
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.
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);
}
}
}
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, ...) }.
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!)
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, ...) }.
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.
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.
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.
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.
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/
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
}
Los atributos del módulo son metadatos que describen el módulo en sí. ¿Dónde podemos encontrar estos metadatos cuando no tenemos acceso a la fuente? Bueno, al compilar un módulo, recogerá la mayoría de los atributos del módulo y los almacenará (junto con otra información) en una función module_info/0. Puedes ver los metadatos del módulo useless de la siguiente manera:
9> useless:module_info().
[{exports,[{add,2},
{hello,0},
{greet_and_add_two,1},
{module_info,0},
{module_info,1}]},
{imports,[]},
{attributes,[{vsn,[174839656007867314473085021121413256129]}]},
{compile,[{options,[]},
{version,"4.6.2"},
{time,{2009,9,9,22,15,50}},
{source,"/home/ferd/learn-you-some-erlang/useless.erl"}]}]
10> useless:module_info(attributes).
[{vsn,[174839656007867314473085021121413256129]}]
El fragmento anterior también muestra una función adicional, module_info/1, que le permitirá obtener una información específica. Puede ver funciones exportadas, funciones importadas, atributos (aquí es donde irían sus metadatos personalizados) y opciones e información.
vsn es un valor único generado automáticamente que es diferente en cada versión del código, excluyendo los comentarios. Se utiliza en la carga en caliente de código (actualización de una aplicación mientras se ejecuta, sin detenerla) y en algunas herramientas relacionadas con el manejo de versiones. También podemos especificar un valor vsn: simplemente agregando -vsn(VersionNumber) al módulo.
Otro punto que sería bueno abordar con respecto al diseño general del módulo: ¡evite las dependencias circulares! Un módulo A no debe llamar a un módulo B que también llama al módulo A. Estas dependencias suelen terminar dificultando el mantenimiento del código. De hecho, depender de demasiados módulos, incluso si no están en una dependencia circular, puede dificultar el mantenimiento. Lo último que desea es despertarse en medio de la noche y encontrar a un ingeniero de software o informático maníaco tratando de arrancarle los ojos debido al terrible código que ha escrito.
Por motivos similares (mantenimiento y miedo a la vista), suele considerarse una buena práctica reagrupar funciones que tienen funcionamiento similar.
