domingo, 17 de marzo de 2024

Anotaciones de tipo en gleam



pub fn main() {

  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.


sábado, 16 de marzo de 2024

Comprensiones binarias en Erlang


 Las comprensiones binarias son para la sintaxis de bits lo que las listas por comprensión son para las listas: una forma de hacer que el código sea breve y conciso. Son relativamente nuevos en el mundo de Erlang como lo fueron en revisiones anteriores de Erlang, pero requirieron un módulo que los implementara para usar un indicador de compilación especial para poder funcionar. Desde las revisiones R13B (las que se usan aquí), se han convertido en estándar y se pueden usar en cualquier lugar, incluido el shell:


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


miércoles, 13 de marzo de 2024

Discard patterns o underscore o guion bajo en Gleam

 


pub fn main() {

  // This variable is never used

  let _score = 1000

}

Si se asigna una variable pero no se utiliza, Gleam emitirá una advertencia.

Si se pretende que una variable no se utilice, el nombre puede tener como prefijo un guión bajo, silenciando la advertencia.

Si al ejemplo le quitamos el _ vamos a obtener el siguiente warning : 

warning: Unused variable
  ┌─ /src/main.gleam:3:7
  │
  │   let score = 1000
  │       ^^^^^ This variable is never used

Hint: You can ignore it with an underscore: `_score`.


sábado, 9 de marzo de 2024

Otro ejemplo de Stl de C++


Escribamos un programa que muestre las palabras y la cantidad de veces que aparecen dentro de un archivo de texto. 

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!

Asignaciones en Gleam


import gleam/io


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.

viernes, 8 de marzo de 2024

Un ejemplo utilizando STL de C++


Voy hacer unos post con ejemplos de utilización de la Stl de C++. Vamos con el primero: 

Leamos una cantidad arbitraria de valores enteros (n>=1) del archivo “numbers.txt” y mostramos:

  • Mínimo, máximo
  • Media
  • Promedio
  • Media geométrica ((y1 * y2 * … yn)^(1/n))

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!

miércoles, 6 de marzo de 2024

Strings en Gleam



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

}


En Gleam, las cadenas se escriben como texto entre comillas dobles, pueden abarcar varias líneas y contener caracteres Unicode.

El operador <> se puede utilizar para concatenar cadenas.

Se admiten varias secuencias de escape:

\" - comillas dobles
\\ - barra invertida
\f - avance de formulario
\n - nueva línea
\r - retorno de carro
\t - pestaña
\u{xxxxxx} - punto de código Unicode

El módulo de biblioteca estándar gleam/string contiene funciones para trabajar con cadenas.

Primera API con Go-zero


Después de completar la instalación de goctl, podemos crear un servicio HTTP mínimo para obtener una descripción general del servicio API go-zero de goctl.


# 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


Bools en Gleam



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

}


Un Bool es Verdadero o Falso.

El ||, &&, y ! Los operadores se pueden utilizar para manipular bools.

El || y los operadores && están en cortocircuito, lo que significa que si el lado izquierdo del operador es Verdadero para || o False para && entonces no se evaluará el lado derecho del operador.

El módulo de biblioteca estándar gleam/bool contiene funciones para trabajar con bools.

Ponte al día con la IA generativa

 Me llego este mail de la gente de google y quería compartirlo: 


martes, 5 de marzo de 2024

Igualdad en Gleam

 



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.

lunes, 4 de marzo de 2024

Formatos de números en Gleam


import gleam/io


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.