let _name: String = "Gleam"
let _is_cool: Bool = True
let _version: Int = 1
}
let se pueden escribir con una anotación de tipo después del nombre.
Las anotaciones de tipo pueden ser útiles para fines de documentación, pero no cambian la forma en que Gleam verifica el código más allá de garantizar que la anotación sea correcta.
Normalmente, el código Gleam no tendrá anotaciones de tipo para las asignaciones.
1> [ X || <<X>> <= <<1,2,3,4,5>>, X rem 2 == 0].
[2,4]
El único cambio en la sintaxis con respecto a las listas por comprensión normales es <- que se convirtió en <= y usa binarios (<<>>) en lugar de listas ([]). Anteriormente vimos un ejemplo en el que había un valor binario de muchos píxeles en el que utilizamos la coincidencia de patrones para capturar los valores RGB de cada píxel. Estaba bien, pero en estructuras más grandes, posiblemente sería más difícil de leer y mantener. El mismo ejercicio se puede hacer con una comprensión binaria de una línea, que es mucho más clara:
2> Pixels = <<213,45,132,64,76,32,76,0,0,234,32,15>>.
<<213,45,132,64,76,32,76,0,0,234,32,15>>
3> RGB = [ {R,G,B} || <<R:8,G:8,B:8>> <= Pixels ].
[{213,45,132},{64,76,32},{76,0,0},{234,32,15}]
Cambiando <- a <= usemos un flujo binario como generador. La comprensión binaria completa básicamente cambió los datos binarios a números enteros dentro de tuplas. Existe otra sintaxis de comprensión binaria que le permite hacer exactamente lo contrario:
4> << <<R:8, G:8, B:8>> || {R,G,B} <- RGB >>.
<<213,45,132,64,76,32,76,0,0,234,32,15>>
Los elementos del binario resultante requieren un tamaño claramente definido si el generador devolvió binarios:
5> << <<Bin>> || Bin <- [<<3,7,5,4,7>>] >>.
** exception error: bad argument
6> << <<Bin/binary>> || Bin <- [<<3,7,5,4,7>>] >>.
<<3,7,5,4,7>>
También es posible tener una comprensión binaria con un generador binario, siempre que se respete la regla de tamaño fijo anterior:
7> << <<(X+1)/integer>> || <<X>> <= <<3,7,5,4,7>> >>.
<<4,8,6,5,8>>
// This variable is never used
let _score = 1000
}
vector<string> v;
map<string, int> m;
copy(istream_iterator<string>(ifstream("words.txt")), istream_iterator<string>(), back_inserter(v));
for (auto vi = v.begin(); vi != v.end(); ++vi) ++m[*vi];
for (auto mi = m.begin(); mi != m.end(); ++mi)
cout << mi->first << ": " << mi->second << endl;
Y listo!
pub fn main() {
let x = "Original"
io.debug(x)
// Assign `y` to the value of `x`
let y = x
io.debug(y)
// Assign `x` to a new value
let x = "New"
io.debug(x)
// The `y` still refers to the original value
io.debug(y)
}
Se puede asignar un valor a una variable usando let.
Los nombres de las variables se pueden reutilizar mediante enlaces let posteriores, pero los valores a los que hacen referencia son inmutables, por lo que los valores en sí no se modifican ni mutan de ninguna manera.
Leamos una cantidad arbitraria de valores enteros (n>=1) del archivo “numbers.txt” y mostramos:
Con Stl sería así:
vector<int> v;
copy(istream_iterator<int>(ifstream("numbers.txt")), istream_iterator<int>(), back_inserter(v));
sort(v.begin(), v.end());
cout << "min/max: " << v.front() << " " << v.back() << endl;
cout << "median : " << *(v.begin() + (v.size()/2)) << endl;
cout << "average: " << accumulate(v.begin(), v.end(), 0.0) / v.size() << endl;
cout << "geomean: " << pow(accumulate(v.begin(),v.end(),1.0,multiplies<double>()), 1.0/v.size())
<< endl;
Y listo!
import gleam/io
import gleam/string
pub fn main() {
// String literals
io.debug("👩💻 こんにちは Gleam 🏳️🌈")
io.debug(
"multi
line
string",
)
io.debug("\u{1F600}")
// Double quote can be escaped
io.println("\"X\" marks the spot")
// String concatenation
io.debug("One " <> "Two")
// String functions
io.debug(string.reverse("1 2 3 4 5"))
io.debug(string.append("abc", "def"))
}
# Create workspaces and enter the directory
$ mkdir -p ~/workspace/api && cd ~/workspace/api
# Execute instructions generated demo service
$ goctl api new demo
Done.
Después de ejecutar la instrucción, se generará un directorio de demostración en el directorio actual que contiene un servicio HTTP minimizado, verificaremos la estructura del directorio del servicio.
$ cd ~/workspace/api/demo
$ ls
demo.api demo.go etc go.mod internal
$ tree
.
├── demo.api
├── demo.go
├── etc
│ └── demo-api.yaml
├── go.mod
└── internal
├── config
│ └── config.go
├── handler
│ ├── demohandler.go
│ └── routes.go
├── logic
│ └── demologic.go
├── svc
│ └── servicecontext.go
└── types
└── types.go
Después de completar la generación del código anterior, podemos encontrar los archivos ~/workspace/api/demo/internal/logic/demologic.go, y podemos completar el códigos entre las líneas 27 y 28:
resp = new(types.Response)
resp.Message = req.Name
Después de escribir el código anterior, podemos iniciar el servicio con las siguientes instrucciones:
# Enter service directory
$ cd ~/workspace/api/demo
# to organize dependencies
$ go mod tidy
# Run go program
$ go run demo.go
Cuando vea el siguiente resultado "Starting server at 0.0.0.0.0:888.." indica que el servicio se ha iniciado correctamente, entonces visitamos el servicio HTTP.
$ curl --request GET 'http://127.0.0.0.1:8888/from/me'
Cuando vea el resultado en la terminal {"message":"me"} en nombre de su servicio se inició con éxito.
Y listo!!
Dejo link: https://go-zero.dev/en/docs/tasks/cli/api-demo
import gleam/io
import gleam/bool
pub fn main() {
// Bool operators
io.debug(True && False)
io.debug(True && True)
io.debug(False || False)
io.debug(False || True)
// Bool functions
io.debug(bool.to_string(True))
io.debug(bool.to_int(False))
}
Me llego este mail de la gente de google y quería compartirlo:
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import gleam/io
pub fn main() {
io.debug(100 == 100)
io.debug(1.5 != 0.1)
}
Gleam tiene los operadores == y != para verificar la igualdad.
Los operadores se pueden utilizar con valores de cualquier tipo, pero ambos lados del operador deben ser del mismo tipo.
La igualdad se verifica estructuralmente, lo que significa que dos valores son iguales si tienen la misma estructura y no si están en la misma ubicación de memoria.
pub fn main() {
// Underscores
io.debug(1_000_000)
io.debug(10_000.01)
// Binary, octal, and hex Int literals
io.debug(0b00001111)
io.debug(0o17)
io.debug(0xF)
// Scientific notation Float literals
io.debug(7.0e7)
io.debug(3.0e-4)
}
Se pueden agregar guiones bajos a los números para mayor claridad. Por ejemplo, 1000000 puede ser complicado de leer rápidamente, mientras que 1_000_000 puede ser más fácil.
Los enteros se pueden escribir en formatos binario, octal o hexadecimal utilizando los prefijos 0b, 0o y 0x respectivamente.
Los flotantes se pueden escribir en notación científica.
import gleam/io
import gleam/float
pub fn main() {
// Float arithmetic
io.debug(1.0 +. 1.5)
io.debug(5.0 -. 1.5)
io.debug(5.0 /. 2.5)
io.debug(3.0 *. 3.5)
// Float comparisons
io.debug(2.2 >. 1.3)
io.debug(2.2 <. 1.3)
io.debug(2.2 >=. 1.3)
io.debug(2.2 <=. 1.3)
// Equality works for any type
io.debug(1.1 == 1.1)
io.debug(2.1 == 1.2)
// Division by zero is not an error
io.debug(3.14 /. 0.0)
// Standard library float functions
io.debug(float.max(2.0, 9.5))
io.debug(float.ceiling(5.4))
}
El tipo Float de Gleam representa números que no son enteros.
Los operadores numéricos de Gleam no están sobrecargados, por lo que existen operadores dedicados para trabajar con flotantes.
Los flotantes se representan como números de punto flotante de 64 bits tanto en Erlang como de JavaScript. El comportamiento del punto flotante es nativo de sus respectivos runtimes, por lo que su comportamiento exacto será ligeramente diferente en los dos runtimes.
En JavaScript, exceder el valor máximo (o mínimo) representable para un valor de punto flotante dará como resultado Infinity (o -Infinity). Si intentas dividir dos infinitos, obtendrás NaN como resultado.
Cuando se ejecuta en BEAM, cualquier desbordamiento generará un error. Por lo tanto, no hay ningún valor flotante NaN o Infinity en el tiempo de ejecución de Erlang.
La división por cero no se desbordará, sino que se define como cero.
El módulo de biblioteca estándar gleam/float contiene funciones para trabajar con flotantes.
La sintaxis de bits encierra datos binarios entre << y >>, los divide en segmentos legibles y cada segmento está separado por una coma. Un segmento es una secuencia de bits de un binario (no necesariamente en un límite de bytes, aunque este es el comportamiento predeterminado). Digamos que queremos almacenar un píxel naranja (24 bits). Si alguna vez comprobó los colores en Photoshop o en una hoja de estilos CSS para la web, sabrá que la notación hexadecimal tiene el formato #RRGGBB. Un tinte naranja es #F09A29 en esa notación, que podría ampliarse en Erlang a:
1> Color = 16#F09A29.
15768105
2> Pixel = <<Color:24>>.
<<240,154,41>>
Básicamente dice "Coloque los valores binarios de #F09A29 en 24 bits (rojo en 8 bits, verde en 8 bits y azul también en 8 bits) en la variable Píxel". Posteriormente se puede tomar el valor para escribirlo en un archivo. Esto no parece mucho, pero una vez escrito en un archivo, lo que obtendría al abrirlo en un editor de texto sería un montón de caracteres ilegibles. Cuando vuelva a leer el archivo, Erlang interpretará el binario en el bonito formato <<240,151,41>> nuevamente.
Lo que es más interesante es la capacidad de hacer coincidir patrones con archivos binarios para descomprimir contenido:
3> Pixels = <<213,45,132,64,76,32,76,0,0,234,32,15>>.
<<213,45,132,64,76,32,76,0,0,234,32,15>>
4> <<Pix1,Pix2,Pix3,Pix4>> = Pixels.
** exception error: no match of right hand side value <<213,45,132,64,76,32,76,
0,0,234,32,15>>
5> <<Pix1:24, Pix2:24, Pix3:24, Pix4:24>> = Pixels.
<<213,45,132,64,76,32,76,0,0,234,32,15>>
Lo que hicimos en el comando 3 fue declarar lo que serían exactamente 4 píxeles de colores RGB en binario.
En la expresión 4, intentamos descomprimir 4 valores del contenido binario. Lanza una excepción, porque tenemos más de 4 segmentos, ¡de hecho tenemos 12! Entonces, lo que hacemos es decirle a Erlang que cada variable del lado izquierdo contendrá 24 bits de datos. Eso es lo que significa Var:24. Luego podemos tomar el primer píxel y descomprimirlo en valores de un solo color:
6> <<R:8, G:8, B:8>> = <<Pix1:24>>.
<<213,45,132>>
7> R.
213
"Sí, eso es genial. ¿Y si solo quisiera el primer color desde el principio? ¿Tendré que descomprimir todos estos valores todo el tiempo?" ¡Ja! ¡No lo dudes! Erlang introduce más azúcar sintáctico y coincidencia de patrones para ayudarte con:
8> <<R:8, Rest/binary>> = Pixels.
<<213,45,132,64,76,32,76,0,0,234,32,15>>
9> R.
213
Bonito, ¿eh? Esto se debe a que Erlang acepta más de una forma de describir un segmento binario. Todos estos son válidos:
Value
Value:Size
Value/TypeSpecifierList
Value:Size/TypeSpecifierList
donde Tamaño representará bits o bytes (según el Tipo y Unidad a continuación) y TypeSpecifierList representa uno o más de los siguientes:
integer | float | binary | bytes | bitstring | bits | utf8 | utf16 | utf32
Esto representa el tipo de datos binarios utilizados. Tenga en cuenta que "bytes" es la abreviatura de "binario" y "bits" es la abreviatura de "cadena de bits". Cuando no se especifica ningún tipo, Erlang asume un tipo "entero".
Firma
Valores posibles: signed | unsigned
Solo importa para la coincidencia cuando el tipo es un número entero. El valor predeterminado es "sin firmar".
Endianidad
Valores posibles: big | little | native
La endianidad solo importa cuando el tipo es entero, utf16, utf32 o flotante. Esto tiene que ver con cómo el sistema lee los datos binarios. Como ejemplo, el formato de encabezado de imagen BMP mantiene el tamaño de su archivo como un número entero almacenado en 4 bytes. Para un archivo que tiene un tamaño de 72 bytes, un sistema little-endian lo representaría como <<72,0,0,0>> y uno big-endian como <<0,0,0,72>>. Uno se leerá como '72' mientras que el otro se leerá como '1207959552', así que asegúrese de utilizar el endianismo correcto. También existe la opción de usar 'nativo', que elegirá en tiempo de ejecución si la CPU usa little endianness o big endianness de forma nativa. De forma predeterminada, la endianidad está establecida en "grande".
Unidad
unidad unit:Integer
Este es el tamaño de cada segmento, en bits. El rango permitido es 1..256 y está establecido de forma predeterminada en 1 para números enteros, flotantes y cadenas de bits y en 8 para binarios. Los tipos utf8, utf16 y utf32 no requieren que se defina ninguna unidad. La multiplicación de Tamaño por Unidad es igual a la cantidad de bits que tomará el segmento y debe ser divisible por 8. El tamaño de la unidad generalmente se usa para garantizar la alineación de bytes.
TypeSpecifierList se construye separando los atributos por un '-'.
Algunos ejemplos pueden ayudar a digerir las definiciones:
10> <<X1/unsigned>> = <<-44>>.
<<"Ô">>
11> X1.
212
12> <<X2/signed>> = <<-44>>.
<<"Ô">>
13> X2.
-44
14> <<X2/integer-signed-little>> = <<-44>>.
<<"Ô">>
15> X2.
-44
16> <<N:8/unit:1>> = <<72>>.
<<"H">>
17> N.
72
18> <<N/integer>> = <<72>>.
<<"H">>
19> <<Y:4/little-unit:8>> = <<72,0,0,0>>.
<<72,0,0,0>>
20> Y.
72
Puede ver que hay más de una forma de leer, almacenar e interpretar datos binarios. Esto es un poco confuso, pero aún así es mucho más sencillo que utilizar las herramientas habituales que ofrecen la mayoría de los lenguajes.
Las operaciones binarias estándar (desplazamiento de bits a izquierda y derecha, 'y' binario, 'o', 'xor' o 'no') también existen en Erlang. Simplemente use las funciones bsl (Bit Shift Left), bsr (Bit Shift Right), band, bor, bxor y bnot.
2#00100 = 2#00010 bsl 1.
2#00001 = 2#00010 bsr 1.
2#10101 = 2#10001 bor 2#00101.
import gleam/int
pub fn main() {
// Int arithmetic
io.debug(1 + 1)
io.debug(5 - 1)
io.debug(5 / 2)
io.debug(3 * 3)
io.debug(5 % 2)
// Int comparisons
io.debug(2 > 1)
io.debug(2 < 1)
io.debug(2 >= 1)
io.debug(2 <= 1)
// Equality works for any type
io.debug(1 == 1)
io.debug(2 == 1)
// Standard library int functions
io.debug(int.max(42, 77))
io.debug(int.clamp(5, 10, 20))
}
Existen operadores aritméticos y de comparación para enteros, así como el operador de igualdad que funciona en todos los tipos.
Cuando se ejecuta en la máquina virtual Erlang, los ints no tienen un tamaño máximo ni mínimo. Cuando se ejecuta en JavaScript, los ints se representan utilizando números de punto flotante de 64 bits de JavaScript,
El módulo de biblioteca estándar gleam/int contiene funciones para trabajar con ints.
