pub fn main() {
io.println("Hello, Joe!")
io.println("Hello, Mike!")
}
La biblioteca estándar de Gleam es un paquete de Gleam normal que se ha publicado en el repositorio de paquetes Hex. Puede optar por no utilizarla si lo desea, aunque casi todos los proyectos de Gleam dependen de ella.
Todos los módulos importados que usamos, como gleam/io , son de la biblioteca estándar.
Toda la documentación de la biblioteca estándar está disponible en HexDocs.
pub fn main() {
// 8 bit int. In binary: 00000011
io.debug(<<3>>)
io.debug(<<3>> == <<3:size(8)>>)
// 16 bit int. In binary: 0001100000000011
io.debug(<<6147:size(16)>>)
// A bit array of UTF8 data
io.debug(<<"Hello, Joe!":utf8>>)
// Concatenation
let first = <<4>>
let second = <<2>>
io.debug(<<first:bits, second:bits>>)
}
Las matrices de bits representan una secuencia de 1 y 0, y son una sintaxis conveniente para construir y manipular datos binarios.
A cada segmento de una matriz de bits se le pueden dar opciones para especificar la representación utilizada para ese segmento.
Se pueden dar múltiples opciones a un segmento separándolas con un guion: x:unsigned-little-size(2).
Las matrices de bits tienen un soporte limitado al compilar en JavaScript, no se pueden usar todas las opciones. En el futuro se implementará un soporte completo para matrices de bits.
import gleam/io
pub fn main() {
let _ = io.debug(buy_pastry(10))
let _ = io.debug(buy_pastry(8))
let _ = io.debug(buy_pastry(5))
let _ = io.debug(buy_pastry(3))
}
pub type PurchaseError {
NotEnoughMoney(required: Int)
NotLuckyEnough
}
fn buy_pastry(money: Int) -> Result(Int, PurchaseError) {
case money >= 5 {
True ->
case int.random(4) == 0 {
True -> Error(NotLuckyEnough)
False -> Ok(money - 5)
}
False -> Error(NotEnoughMoney(required: 5))
}
}
Gleam no utiliza excepciones, sino que los cálculos que pueden tener éxito o fallar devuelven un valor del tipo Result(value, error). Tiene dos variantes:
El tipo es genérico con dos parámetros de tipo, uno para el valor de éxito y otro para el error. Con estos, el resultado puede contener cualquier tipo de éxito o fracaso.
Comúnmente, un programa o biblioteca de Gleam definirá un tipo personalizado con una variante para cada posible problema que pueda surgir, junto con cualquier información de error que pueda ser útil para el programador.
Esto es ventajoso sobre las excepciones, ya que puede ver inmediatamente qué errores puede devolver una función, si los hay, y el compilador se asegurará de que se gestionen. ¡No hay sorpresas desagradables con excepciones inesperadas!
Un valor de resultado se puede gestionar mediante la coincidencia de patrones con una expresión de case, pero dada la frecuencia con la que se devuelven los resultados, esto puede volverse difícil de manejar. El código Gleam comúnmente utiliza el módulo de biblioteca estándar gleam/result y utiliza expresiones cuando trabaja con resultados.
Hay dos tipos de excepciones exits: salidas "internas" y salidas "externas". Las salidas internas se activan llamando a la función exit/1 y hacen que el proceso actual detenga su ejecución. Las salidas externas se llaman con exit/2 y tienen que ver con múltiples procesos en el aspecto concurrente de Erlang; como tal, nos centraremos principalmente en las salidas internas y visitaremos el tipo externo más adelante.
Las salidas internas son bastante similares a los errores. De hecho, históricamente hablando, eran lo mismo y solo existía exit/1. Tienen aproximadamente los mismos casos de uso. Entonces, ¿cómo elegir uno? Bueno, la elección no es obvia. Para entender cuándo usar uno u otro, no hay más remedio que comenzar a mirar los conceptos de actores y procesos desde lejos.
En la introducción, comparé los procesos con personas que se comunican por correo. Por ejemplo, un proceso 'A' envia un mensaje a un proceso 'B'
Aquí los procesos pueden enviarse mensajes entre sí. Un proceso también puede escuchar mensajes, esperarlos. También puede elegir qué mensajes escuchar, descartar algunos, ignorar otros, dejar de escuchar después de un tiempo determinado, etc.
Un proceso 'A' enviando 'hola' a un proceso 'B', que a su vez envía un mensaje a C con 'A dice hola!'
Estos conceptos básicos permiten a los implementadores de Erlang utilizar un tipo especial de mensaje para comunicar excepciones entre procesos. Actúan un poco como el último aliento de un proceso; se envían justo antes de que un proceso muera y el código que contiene deje de ejecutarse. Otros procesos que estaban escuchando ese tipo específico de mensaje pueden entonces saber acerca del evento y hacer lo que quieran con él. Esto incluye el registro, el reinicio del proceso que murió, etc.
Un proceso muerto que envía "Estoy muerto" a un proceso "B"
Una vez explicado este concepto, la diferencia entre usar erlang:error/1 y exit/1 es más fácil de entender. Si bien ambos se pueden usar de una manera extremadamente similar, la verdadera diferencia está en la intención. Luego, puede decidir si lo que tiene es "simplemente" un error o una condición que amerita matar el proceso actual. Este punto se fortalece por el hecho de que erlang:error/1 devuelve un seguimiento de la pila y exit/1 no. Si tuviera un seguimiento de la pila bastante grande o muchos argumentos para la función actual, copiar el mensaje de salida a cada proceso que escucha significaría copiar los datos. En algunos casos, esto podría volverse poco práctico.
Hay tres tipos de excepciones en Erlang: errors, throws y exits. Todas tienen diferentes usos :
Errores: Llamar a erlang:error(Reason) finalizará la ejecución en el proceso actual e incluirá un seguimiento de la pila de las últimas funciones llamadas con sus argumentos cuando lo detecte. Estos son los tipos de excepciones que provocan los errores en tiempo de ejecución.
Los errores son los medios que utiliza una función para detener su ejecución cuando no puede esperar que el código que la llama maneje lo que acaba de suceder. Si recibe un error if_clause, ¿qué puede hacer? Cambiar el código y volver a compilar, eso es lo que puede hacer (además de mostrar un bonito mensaje de error).
También puedes definir tu propio tipo de errores:
1> erlang:error(badarith).
** exception error: bad argument in an arithmetic expression
2> erlang:error(custom_error).
** exception error: custom_error
Aquí, el shell Erlang no reconoce custom_error y no tiene una traducción personalizada como "argumento incorrecto en ...", pero se puede usar de la misma manera y el programador puede manejarlo de manera idéntica.
En post posteriores seguiremos con throws y exits.
Heredar de `abc.ABC` permite definir métodos abstractos utilizando el decorador `@abstractmethod`. Esto asegura que cualquier subclase debe implementar esos métodos, de lo contrario, se levantará una excepción `TypeError`.
Las clases que heredan de `abc.ABC` no pueden ser instanciadas directamente. Esto ayuda a evitar errores al intentar crear instancias de una clase que debería ser abstracta.
Utilizar `abc.ABC` fomenta un enfoque más formal y orientado a objetos en el diseño de software, haciendo que el código sea más mantenible y entendible.
Veamos un ejemplo:
from abc import ABC, abstractmethod
class Animal(ABC):
@abstractmethod
def hacer_sonido(self):
pass
# Intentar instanciar la clase abstracta resulta en un error
# animal = Animal() # Esto lanzará TypeError
# Definir una subclase concreta que implementa el método abstracto
class Perro(Animal):
def hacer_sonido(self):
return "Guau!"
class Gato(Animal):
def hacer_sonido(self):
return "Miau!"
# Instanciar las subclases concretas
perro = Perro()
gato = Gato()
print(perro.hacer_sonido()) # Salida: Guau!
print(gato.hacer_sonido()) # Salida: Miau!
Si decidimos no heredar de `abc.ABC`, puedes definir métodos que esperas que las subclases implementen, pero no tendrás las garantías estructurales que ofrece `abc.ABC`. Por ejemplo:
class Animal:
def hacer_sonido(self):
raise NotImplementedError("Este método debe ser implementado por subclases")
class Perro(Animal):
def hacer_sonido(self):
return "Guau!"
# Esto funcionará, pero no es tan estructurado como usar abc.ABC
perro = Perro()
print(perro.hacer_sonido()) # Salida: Guau!
Usar `abc.ABC` para definir clases abstractas en Python es una práctica recomendada porque proporciona una forma clara y estructurada de garantizar que las subclases implementen métodos abstractos y ayuda a prevenir errores al intentar instanciar clases abstractas directamente.
pub fn main() {
let x = Nil
io.debug(x)
let result = io.println("Hello!")
io.debug(result == Nil)
}
Nil es el tipo de unidad de Gleam. Es un valor que devuelven las funciones que no tienen nada más que devolver, ya que todas las funciones deben devolver algo.
Nil no es un valor válido de ningún otro tipo. Por lo tanto, los valores en Gleam no son nulos. Si el tipo de un valor es Nil, entonces es el valor Nil. Si es otro tipo, entonces el valor no es Nil.
Un procedimiento almacenado es un conjunto de instrucciones SQL que puedes guardar y ejecutar en el servidor de base de datos. Estos procedimientos pueden aceptar parámetros, realizar operaciones complejas y devolver resultados. Son útiles para encapsular lógica de negocios, mejorar el rendimiento y simplificar el mantenimiento del código.
Una función en PostgreSQL es similar a un procedimiento almacenado, pero generalmente se usa para devolver un valor o un conjunto de resultados. Las funciones pueden ser escalar (devolviendo un único valor) o de conjunto (devolviendo una tabla de resultados).
Vamos a crear una función simple que suma dos números.
CREATE OR REPLACE FUNCTION suma(a INTEGER, b INTEGER)
RETURNS INTEGER AS $$
BEGIN
RETURN a + b;
END;
$$ LANGUAGE plpgsql;
- **CREATE OR REPLACE FUNCTION**: Esta declaración crea una nueva función o reemplaza una existente.
- **RETURNS INTEGER**: Indica que la función devuelve un valor entero.
- **LANGUAGE plpgsql**: Especifica que la función está escrita en PL/pgSQL, el lenguaje de procedimientos de PostgreSQL.
Para ejecutar la función:
SELECT suma(3, 5); -- Devuelve 8
Vamos a crear una función que devuelve una lista de usuarios con su respectiva edad.
CREATE OR REPLACE FUNCTION obtener_usuarios()
RETURNS TABLE(nombre VARCHAR, edad INTEGER) AS $$
BEGIN
RETURN QUERY
SELECT nombre, edad FROM usuarios;
END;
$$ LANGUAGE plpgsql;
Para ejecutar la función:
SELECT * FROM obtener_usuarios();
A partir de PostgreSQL 11, se introdujo el soporte para procedimientos almacenados, que son similares a las funciones pero permiten realizar operaciones de control de transacciones (COMMIT y ROLLBACK) dentro del procedimiento.
Vamos a crear un procedimiento que inserta un nuevo usuario en la tabla `usuarios`.
CREATE OR REPLACE PROCEDURE insertar_usuario(nombre VARCHAR, edad INTEGER)
LANGUAGE plpgsql AS $$
BEGIN
INSERT INTO usuarios (nombre, edad) VALUES (nombre, edad);
END;
$$;
Para ejecutar el procedimiento:
CALL insertar_usuario('Juan', 30);
Los procedimientos almacenados y las funciones en PostgreSQL son herramientas poderosas para encapsular lógica de negocios y mejorar la eficiencia de las operaciones de base de datos. Con el uso adecuado, pueden simplificar el desarrollo y mantenimiento de aplicaciones, al tiempo que mejoran el rendimiento y la seguridad.
1> lists:sort([3,2,1]).
[1,2,3]
2> lists:sort(fffffff).
** exception error: no function clause matching lists:sort(fffffff)
Todas las cláusulas de protección de una función fallaron o ninguno de los patrones de las cláusulas de función coincidió.
3> case "Unexpected Value" of
3> expected_value -> ok;
3> other_expected_value -> 'also ok'
3> end.
** exception error: no case clause matching "Unexpected Value"
¡Parece que alguien olvidó un patrón específico en su caso, envió el tipo de datos incorrecto o necesitaba una cláusula general!
4> if 2 > 4 -> ok;
4> 0 > 1 -> ok
4> end.
** exception error: no true branch found when evaluating an if expression
No puede encontrar una rama que evalúe como verdadera. Es posible que lo que necesite sea asegurarse de tener en cuenta todos los casos o agregar la cláusula true para todo.
5> [X,Y] = {4,5}.
** exception error: no match of right hand side value {4,5}
Los errores de coincidencia incorrecta ocurren siempre que falla la coincidencia de patrones. Esto probablemente significa que estás intentando hacer coincidencias de patrones imposibles (como las anteriores), intentando vincular una variable por segunda vez o simplemente cualquier cosa que no sea igual en ambos lados del operador = (que es básicamente lo que hace que la vinculación de una variable falle). Ten en cuenta que este error a veces ocurre porque el programador cree que una variable de la forma _MyVar es lo mismo que _. Las variables con un guión bajo son variables normales, excepto que el compilador no se quejará si no se usan. No es posible vincularlas más de una vez.
6> erlang:binary_to_list("heh, already a list").
** exception error: bad argument
in function binary_to_list/1
called as binary_to_list("heh, already a list")
Trata sobre llamar a funciones con argumentos incorrectos. Este error generalmente lo genera el programador después de validar los argumentos desde dentro de la función, fuera de las cláusulas de protección.
7> lists:random([1,2,3]).
** exception error: undefined function lists:random/1
Esto sucede cuando llamas a una función que no existe. Asegúrate de que la función se exporte desde el módulo con la aridad correcta (si la estás llamando desde fuera del módulo) y vuelve a verificar que hayas escrito correctamente el nombre de la función y el nombre del módulo. Otra razón para recibir el mensaje es cuando el módulo no está en la ruta de búsqueda de Erlang. De manera predeterminada, la ruta de búsqueda de Erlang está configurada para estar en el directorio actual. Puedes agregar rutas usando code:add_patha/1 o code:add_pathz/1. Si esto aún no funciona, ¡asegúrate de haber compilado el módulo para comenzar!
8> 5 + llama.
** exception error: bad argument in an arithmetic expression in operator +/2 called as 5 + llama
Esto sucede cuando intentas realizar operaciones aritméticas que no existen, como divisiones por cero o entre átomos y números.
9> hhfuns:add(one,two).
** exception error: bad function one in function hhfuns:add/2
La razón más frecuente por la que se produce este error es cuando se utilizan variables como funciones, pero el valor de la variable no es una función. En el ejemplo anterior, estoy utilizando la función hhfuns y utilizando dos átomos como funciones. Esto no funciona y se genera badfun.
10> F = fun(_) -> ok end.
#Fun<erl_eval.6.13229925>
11> F(a,b).
** exception error: interpreted function with arity 1 called with two arguments
1. Definir el Lenguaje
Antes de empezar, necesitas definir tu lenguaje. Esto incluye:
Por ejemplo, podríamos definir un lenguaje simple con variables, operadores y estructuras de control.
2. Crear una Gramática
Usa ANTLR o una herramienta similar para definir la gramática de tu lenguaje. Esto implica escribir un archivo `.g4` (o el formato correspondiente) que describa la sintaxis de tu lenguaje.
Ejemplo de una gramática simple en ANTLR (`SimpleLang.g4`):
grammar SimpleLang;
program: statement+;
statement: assignment | expression ';';
assignment: ID '=' expression ';';
expression: ID | NUMBER | '(' expression ')' | expression '+' expression | expression '-' expression;
ID: [a-zA-Z_][a-zA-Z_0-9]*;
NUMBER: [0-9]+;
WS: [ \t\r\n]+ -> skip;
3. Generar el Lexer y el Parser
Usa ANTLR para generar el lexer y el parser a partir de tu gramática.
antlr4 SimpleLang.g4
4. Crear un Árbol de Sintaxis Abstracto (AST)
El parser generará un árbol de sintaxis. Sin embargo, es útil convertir esto en un Árbol de Sintaxis Abstracto (AST) que simplifica el manejo de la estructura del código.
5. Transformar el AST a Bytecode
Para convertir el AST a bytecode, necesitas:
Aquí hay un ejemplo simple de cómo podrías generar bytecode para una calculadora en Java:
public class BytecodeGenerator extends SimpleLangBaseVisitor<Void> {
private final StringBuilder bytecode = new StringBuilder();
@Override
public Void visitAssignment(SimpleLangParser.AssignmentContext ctx) {
String id = ctx.ID().getText();
visit(ctx.expression());
bytecode.append("STORE ").append(id).append("\n");
return null;
}
@Override
public Void visitExpression(SimpleLangParser.ExpressionContext ctx) {
if (ctx.ID() != null) {
bytecode.append("LOAD ").append(ctx.ID().getText()).append("\n");
} else if (ctx.NUMBER() != null) {
bytecode.append("PUSH ").append(ctx.NUMBER().getText()).append("\n");
} else if (ctx.op != null) {
visit(ctx.expression(0));
visit(ctx.expression(1));
switch (ctx.op.getType()) {
case SimpleLangParser.PLUS:
bytecode.append("ADD\n");
break;
case SimpleLangParser.MINUS:
bytecode.append("SUB\n");
break;
}
}
return null;
}
public String getBytecode() {
return bytecode.toString();
}
}
6. Compilar el Bytecode
Si estás utilizando una máquina virtual existente como la JVM, deberás generar bytecode en el formato adecuado. Si estás creando tu propia máquina virtual, tendrás que diseñar un mecanismo para ejecutar el bytecode.
7. Probar y Depurar
Pruebar el compilador con varios programas de ejemplo para asegurarte de que se comporta como se espera. Depura cualquier problema que encuentres en el proceso de generación de bytecode.
Este es un enfoque básico y simplificado para ilustrar cómo podrías comenzar a construir un compilador. En un compilador real, deberás gestionar muchas más cosas, como el manejo de errores, la optimización del bytecode y la implementación de una máquina virtual completa si no estás utilizando una existente.
MongoDB es una base de datos NoSQL que se ha convertido en una de las favoritas de los desarrolladores debido a su flexibilidad, escalabilidad y facilidad de uso. A diferencia de las bases de datos SQL tradicionales, MongoDB no soporta procedimientos almacenados de la misma manera. Sin embargo, podemos lograr funcionalidades similares utilizando JavaScript y el shell de MongoDB.
Un procedimiento almacenado es un conjunto de instrucciones SQL que puedes guardar y reutilizar. En bases de datos SQL tradicionales, los procedimientos almacenados permiten encapsular lógica de negocios en el servidor de base de datos, lo que puede mejorar el rendimiento y facilitar el mantenimiento del código.
Aunque MongoDB no soporta procedimientos almacenados como SQL, puedes usar funciones JavaScript para lograr un comportamiento similar. MongoDB permite almacenar y ejecutar funciones JavaScript en el lado del servidor, lo que puede emular los procedimientos almacenados hasta cierto punto.
Puedes definir funciones directamente en el shell de MongoDB usando JavaScript. Veamos un ejemplo de una función que suma dos números:
function sumar(a, b) {
return a + b;
}
Para almacenar una función en MongoDB, puedes usar la colección `system.js`:
db.system.js.save({
_id: "sumar",
value: function (a, b) { return a + b; }
});
Esto guarda la función `sumar` en la colección `system.js`.
Puedes ejecutar la función almacenada usando `db.eval` (aunque `db.eval` está desaconsejado en versiones recientes debido a problemas de rendimiento y seguridad):
db.eval("sumar(3, 5)");
Una alternativa es usar la función almacenada directamente desde el shell:
db.loadServerScripts();
sumar(3, 5);
Supongamos que tienes una colección de `orders` y deseas crear una función para calcular el precio total de una orden incluyendo impuestos.
db.system.js.save({
_id: "calcularPrecioTotal",
value: function (orderId) {
var order = db.orders.findOne({ _id: orderId });
var total = 0;
order.items.forEach(function (item) {
total += item.price * item.quantity;
});
return total * 1.15; // Asumiendo un impuesto del 15%
}
});
db.loadServerScripts();
var precioTotal = calcularPrecioTotal(ObjectId("60b8d295f1e6f8b5d1c29b0c"));
print("Precio Total: " + precioTotal);
Ejecutar JavaScript en el servidor puede tener implicaciones de seguridad. Asegúrate de validar y sanitizar cualquier entrada del usuario que pueda ejecutarse en el servidor.
Las funciones JavaScript en el servidor pueden afectar el rendimiento de tu base de datos. Evalúa cuidadosamente su impacto y considera otras opciones si experimentas problemas de rendimiento.
Aunque MongoDB no soporta procedimientos almacenados de la misma manera que las bases de datos SQL tradicionales, puedes usar funciones JavaScript para implementar lógica de negocios en el servidor. Este enfoque puede ser útil en ciertos escenarios, pero es importante considerar las implicaciones de seguridad y rendimiento. Como siempre, evalúa cuidadosamente tus necesidades y elige la mejor solución para tu aplicación.
Some(inner)
None
}
// An option of string
pub const name: Option(String) = Some("Annah")
// An option of int
pub const level: Option(Int) = Some(10)
Al igual que las funciones, los tipos personalizados también pueden ser genéricos y tomar los tipos contenidos como parámetros.
Aquí se define un tipo Option genérico, que se utiliza para representar un valor que está presente o ausente. ¡Este tipo es bastante útil! El módulo gleam/option lo define para que puedas usarlo en tus proyectos Gleam.
Hay muchos tipos de errores: errores en tiempo de compilación, errores lógicos, errores en tiempo de ejecución y errores generados. Nos centraremos en los errores en tiempo de compilación en esta sección y revisaré los demás en las siguientes secciones.
Los errores en tiempo de compilación suelen ser errores sintácticos: debemos verificar los nombres de sus funciones, los tokens del lenguaje (corchetes, paréntesis, puntos, comas), la aridad de sus funciones, etc. Aquí hay una lista de algunos de los mensajes de error comunes en tiempo de compilación. y posibles soluciones en caso de que las encuentre:
module.beam: Module name 'madule' does not match file name 'module'
El nombre del módulo que ingresó en el atributo -module no coincide con el nombre del archivo.
./module.erl:2: Warning: function some_function/0 is unused
No has exportado una función, o el lugar donde se usa tiene el nombre o aridad incorrectos. También es posible que haya escrito una función que ya no es necesaria. ¡Comprueba tu código!
./module.erl:2: function some_function/1 undefined
La función no existe. Ha escrito el nombre o la aridad incorrectos en el atributo -export o al declarar la función. Este error también se genera cuando la función dada no se pudo compilar, generalmente debido a un error de sintaxis, como olvidar finalizar una función con un punto.
./module.erl:5: syntax error before: 'SomeCharacterOrWord'
Esto sucede por diversas razones, a saber, paréntesis no cerrados, tuplas o terminación de expresión incorrecta (como cerrar la última rama de un caso con una coma). Otras razones pueden incluir el uso de un átomo reservado en su código o caracteres Unicode que se convierten de manera extraña entre diferentes codificaciones (¡lo he visto suceder!)
./module.erl:5: syntax error before:
¡Muy bien, ese ciertamente no es tan descriptivo! Esto suele ocurrir cuando la terminación de su línea no es correcta. Este es un caso específico del error anterior, así que mantente atento.
./module.erl:5: Warning: this expression will fail with a 'badarith' exception
Erlang tiene que ver con la escritura dinámica, pero recuerde que los tipos son fuertes. En este caso, el compilador es lo suficientemente inteligente como para descubrir que una de sus expresiones aritméticas fallará (digamos, llama + 5). Sin embargo, no encontrará errores tipográficos mucho más complejos que eso.
./module.erl:5: Warning: variable 'Var' is unused
Declaraste una variable y nunca la usaste después. Esto podría ser un error en su código, así que verifique lo que ha escrito. De lo contrario, es posible que desee cambiar el nombre de la variable a _ o simplemente anteponerle un guión bajo (algo como _Var) si cree que el nombre ayuda a que el código sea legible.
./module.erl:5: Warning: a term is constructed, but never used
En una de tus funciones, estás haciendo algo como construir una lista, declarar una tupla o una función anónima sin vincularla a una variable ni devolverla. Esta advertencia te indica que estás haciendo algo inútil o que has cometido algún error.
./module.erl:5: head mismatch
Es posible que tu función tenga más de un encabezado y cada uno de ellos tenga una aridad diferente. No olvide que una aridad diferente significa funciones diferentes y no puede intercalar declaraciones de funciones de esa manera. Este error también aparece cuando inserta una definición de función entre las cláusulas principales de otra función.
./module.erl:5: Warning: this clause cannot match because a previous clause at line 4 always matches
Una función definida en el módulo tiene una cláusula específica definida después de una general. Como tal, el compilador puede advertirle que ni siquiera necesitará ir a la otra rama.
./module.erl:9: variable 'A' unsafe in 'case' (line 5)
Estás usando una variable declarada dentro de una de las ramas de un caso... o fuera de él. Esto se considera inseguro. Si desea utilizar dichas variables, sería mejor que hiciera MyVar = case... of...
Esto debería cubrir la mayoría de los errores que obtiene en tiempo de compilación en este momento. No hay demasiados y la mayoría de las veces la parte más difícil es encontrar qué error causó una enorme cascada de errores enumerados en otras funciones. Es mejor resolver los errores del compilador en el orden en que fueron reportados para evitar ser engañado por errores que en realidad pueden no ser errores.
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.
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.
