Casting en Rust

Rust no tiene conversiones de tipos implícitas, pero admite conversiones explícitas con as. 

fn main() {

    let value: i64 = 1000;

    println!("as u16: {}", value as u16);

    println!("as i16: {}", value as i16);

    println!("as u8: {}", value as u8);

}

Los resultados de as siempre están definidos en Rust y son consistentes en todas las plataformas. Es posible que esto no coincida con su intuición para cambiar el signo o transformar a un tipo más pequeño; debemos consultar la documentación.

Generalmente se desaconseja el uso de as en casos en los que se puedan perder datos, o al menos merece un comentario explicativo.

Función para filtrar valores de una lista en lisp

Vamos a hacer rápidamente una función que permita filtrar valores de una lista según una función. Veamos el código : 

(defun filtrar (lista fx) 

  (cond 

     ((null lista) lista) 

     ((funcall fx (first lista)) 

         (cons (first lista) (filtrar (rest lista) fx)))

     (T (filtrar (rest lista) fx))

  )

) 

Si la lista esta vacía la retorna, sino se fija si ese elemento cumple el criterio y si lo cumple construye una nueva lista con este elemento y el resto filtrado. Y si no retorna el resto de la lista filtrado. 

Veamos si funciona: 

> (filtrar '(1 2 3 4 5) (lambda (a) (> a 5)))

NIL

> (filtrar '(1 2 3 4 5) (lambda (a) (> a 2)))

(3 4 5)

> (filtrar '(1 2 3 4 5) (lambda (a) (< a 2)))

(1)

Traits From y Into de Rust

Los tipos que implementan From y Into facilitan las conversiones de tipos:

fn main() {

    let s = String::from("hello");

    let addr = std::net::Ipv4Addr::from([127, 0, 0, 1]);

    let one = i16::from(true);

    let bigger = i32::from(123i16);

    println!("{s}, {addr}, {one}, {bigger}");

}

Into se implementa automáticamente cuando se implementa From:

fn main() {

    let s: String = "hello".into();

    let addr: std::net::Ipv4Addr = [127, 0, 0, 1].into();

    let one: i16 = true.into();

    let bigger: i32 = 123i16.into();

    println!("{s}, {addr}, {one}, {bigger}");

}

Es por eso que es común implementar solo From, ya que su tipo también entrará en la implementación de Into.

Al declarar un tipo de entrada de argumento de función como "cualquier cosa que pueda convertirse en una cadena", la regla es la opuesta, debes usar Into. Su función aceptará tipos que implementen From y aquellos que solo implementen Into.

Testear endpoints en go con echo

Supongamos que tenemos unos endpoints hechos con echo:

package handler

import (

    "net/http"

    "github.com/labstack/echo/v4"

)

type (

    User struct {

        Name  string `json:"name" form:"name"`

        Email string `json:"email" form:"email"`

    }

    handler struct {

        db map[string]*User

    }

)

func (h *handler) createUser(c echo.Context) error {

    u := new(User)

    if err := c.Bind(u); err != nil {

        return err

    }

    return c.JSON(http.StatusCreated, u)

}

func (h *handler) getUser(c echo.Context) error {

    email := c.Param("email")

    user := h.db[email]

    if user == nil {

        return echo.NewHTTPError(http.StatusNotFound, "user not found")

    }

    return c.JSON(http.StatusOK, user)

}

Lo que queremos hacer es un test de unidad que testee este comportamiento, y podemos hacerlo así: 

package handler

import (

    "net/http"

    "net/http/httptest"

    "strings"

    "testing"

    "github.com/labstack/echo/v4"

    "github.com/stretchr/testify/assert"

)

var (

    mockDB = map[string]*User{

        "jon@labstack.com": &User{"Jon Snow", "jon@labstack.com"},

    }

    userJSON = `{"name":"Jon Snow","email":"jon@labstack.com"}`

)

func TestCreateUser(t *testing.T) {

    // Setup

    e := echo.New()

    req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(userJSON))

    req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)

    rec := httptest.NewRecorder()

    c := e.NewContext(req, rec)

    h := &handler{mockDB}

    // Assertions

    if assert.NoError(t, h.createUser(c)) {

        assert.Equal(t, http.StatusCreated, rec.Code)

        assert.Equal(t, userJSON, rec.Body.String())

    }

}

func TestGetUser(t *testing.T) {

    // Setup

    e := echo.New()

    req := httptest.NewRequest(http.MethodGet, "/", nil)

    rec := httptest.NewRecorder()

    c := e.NewContext(req, rec)

    c.SetPath("/users/:email")

    c.SetParamNames("email")

    c.SetParamValues("jon@labstack.com")

    h := &handler{mockDB}

    // Assertions

    if assert.NoError(t, h.getUser(c)) {

        assert.Equal(t, http.StatusOK, rec.Code)

        assert.Equal(t, userJSON, rec.Body.String())

    }

}

Y listo!! 

Dejo link: https://echo.labstack.com/docs/testing

Unir dos listas en lisp

Vamos a unir dos listas en Lisp. Si la primera lista es vacia, retornamos la otra lista y si no lo es, costruimos una nueva lista con el primer elemento de la primera lista y la union del resto de la primera lista (porque al primero ya lo sacamos) con la otra lista. 

(defun unir (lista1 lista2) 

  (cond 

    ((null lista1) lista2)

    (T (cons (first lista1) (unir (rest lista1) lista2)))

  )

)

Si probamos : 

> (unir '(1 2 3) '(4 5 6))

(1 2 3 4 5 6)

> (unir '(1 2 3) '(4))

(1 2 3 4)

Sobrecarga de operadores por medio de traits en Rust

 La sobrecarga del operador se implementa mediante rasgos en std::ops:

#[derive(Debug, Copy, Clone)]

struct Point { x: i32, y: i32 }

impl std::ops::Add for Point {

    type Output = Self;

    fn add(self, other: Self) -> Self {

        Self {x: self.x + other.x, y: self.y + other.y}

    }

}

fn main() {

    let p1 = Point { x: 10, y: 20 };

    let p2 = Point { x: 100, y: 200 };

    println!("{:?} + {:?} = {:?}", p1, p2, p1 + p2);

}

Si lo ejecutamos : 

cargo run main.rs

   Compiling hello_cargo v0.1.0 

    Finished dev [unoptimized + debuginfo] target(s) in 0.58s

     Running `target/debug/hello_cargo main.rs`

Point { x: 10, y: 20 } + Point { x: 100, y: 200 } = Point { x: 110, y: 220 }

Podrías implementar Add para &Point. Si el tipo T para el cual está sobrecargando el operador no implementa Copy, debería considerar sobrecargar también el operador para &T. Esto evita clonaciones innecesarias.

Se podría implementar Add para dos tipos diferentes, p. impl Add<(i32, i32)> for Point agregaría una tupla a un Point.

Sería así :

impl std::ops::Add<(i32, i32)>  for Point {

    type Output = Self;

    fn add(self, other: (i32, i32)) -> Self {

        Self {x: self.x + other.0, y: self.y + other.1}

    }

}

fn main() {

    let p1 = Point { x: 10, y: 20 };

    let tuple= (100, 200);

    println!("{:?} + {:?} = {:?}", p1, tuple, p1 + tuple);

}

Y la salida va a ser : 

Point { x: 10, y: 20 } + (100, 200) = Point { x: 110, y: 220 }

Buscando el mayor y el menor en lisp

Ahora lo que vamos a hacer es buscar el menor o el mayor de una lista. El algoritmo es similar, por lo tanto vamos a utilizar una función general que busque según una función y luego escribimos el mayor o menor pasando un lambda que busque eso (con eso me refiero al menor o al mayor) : 

(defun buscar (lista fx)

  (cond

    ((null (rest lista)) (first lista))

    ((funcall fx (first lista) (buscar (rest lista) fx)) (first lista))

    (T (buscar (rest lista) fx))

  )

)

(defun menor (lista)

  (buscar lista (lambda (a b) (< a b)))

)

(defun mayor (lista)

  (buscar lista (lambda (a b) (> a b)))

)

El algoritmo buscar lo que hace es si la lista tiene un solo elemento, ya esta ese es el menor o el mayor. Si no compara el primero con el buscar del resto, por ejemplo para el menor, compara el primero con el menor del resto, si es verdadero ese es el menor y si no el menor es el menor del resto. 

Y listo! 

Comenten si quieren más algoritmos así. 

Quicksort in lisp

Un Algoritmo que me gusta mucho es el quicksort, porque es un algoritmo por demás claro. Ya he escrito lo fácil que es implementarlo en haskell 

Ahora le toca a lisp. Básicamente el algoritmo toma un pivot y agrupa los menores del pivot al principio y los mayores al final y aplica quicksort a estos 2 grupos. Y si la lista es vacia, ya esta ordenada. 

Vamos al código: 

(defun qso (l) 

   (cond 

     ((null l) l)

     (T (append 

         (qso (remove-if (lambda (a) (> a (first l))) (rest l)))

         (cons 

           (first l)

           (qso (remove-if (lambda (a) (<= a (first l))) (rest l)))

         )

        )

     )

   )

)

El Trait Default

 

El Trait Default produce un valor predeterminado para un tipo.

#[derive(Debug, Default)]

struct Derived {

    x: u32,

    y: String,

    z: Implemented,

}

#[derive(Debug)]

struct Implemented(String);

impl Default for Implemented {

    fn default() -> Self {

        Self("John Smith".into())

    }

}

fn main() {

    let default_struct = Derived::default();

    println!("{default_struct:#?}");

    let almost_default_struct = Derived {

        y: "Y is set!".into(),

        ..Derived::default()

    };

    println!("{almost_default_struct:#?}");

    let nothing: Option<Derived> = None;

    println!("{:#?}", nothing.unwrap_or_default());

}

• Se puede implementar directamente o se puede derivar mediante #[derive(Default)].
• Una implementación derive producirá un valor en el que todos los campos se establecerán en sus valores por defecto.
• Esto significa que todos los tipos de la estructura también deben implementar Default.
• Los tipos estándar de Rust a menudo implementan el valor predeterminado con valores razonables (por ejemplo, 0, "", etc.).
• La copia parcial de la estructura funciona bien de forma predeterminada.
• La biblioteca estándar de Rust es consciente de que los tipos pueden implementar el valor predeterminado y proporciona métodos convenientes para usarlo.
• la .. sintaxis se llama sintaxis de actualización de estructura

El Trait Drop en Rust

Los valores que implementan Drop pueden especificar el código que se ejecutará cuando salgan del alcance:

struct Droppable {

    name: &'static str,

}

impl Drop for Droppable {

    fn drop(&mut self) {

        println!("Dropping {}", self.name);

    }

}

fn main() {

    let a = Droppable { name: "a" };

    {

        let b = Droppable { name: "b" };

        {

            let c = Droppable { name: "c" };

            let d = Droppable { name: "d" };

            println!("Exiting block B");

        }

        println!("Exiting block A");

    }

    drop(a);

    println!("Exiting main");

}

Si ejecutamos esto tenemos: 

Exiting block B

Dropping d

Dropping c

Exiting block A

Dropping b

Dropping a

Exiting main

• Tenga en cuenta que std::mem::drop no es lo mismo que std::ops::Drop::drop.
• Los valores se eliminan automáticamente cuando salen del alcance.
• Cuando se elimina un valor, si implementa std::ops::Drop, se llamará a su implementación Drop::drop.
• Todos sus campos también se eliminarán, ya sea que implemente Drop o no.

std::mem::drop es solo una función vacía que toma cualquier valor. La importancia es que se apropia del valor, por lo que al final de su alcance se elimina. Esto lo convierte en una forma conveniente de eliminar valores explícitamente antes de que, de otro modo, saldrían del alcance.

Esto puede ser útil para objetos que realizan algún trabajo al soltarlos: liberar bloqueos, cerrar archivos, etc.

La función reduce en lisp

Vamos a hacer una función reduce o reducir en lisp. La función reduce nos permite acumular una lista de números por ejemplo o concatenar una lista de string. 

Es decir toma un valor inicial y va acumulando los valores que tiene una lista con una función que se pasa por parámetros. Veamos esto en lisp : 

(defun reducir(inicial lista fx) 

    (cond 

        ((Null lista) inicial)

        (T (reducir (Funcall fx inicial (first lista)) (rest lista) fx))

    )

) 

Si la lista esta vacía, retornamos el acumulador. Si no volvemos a llamar a la función con el valor de la acumulación del primer elemento como valor inicial y el resto del la lista. 

Y podemos llamarlo de la siguiente manera: 

 > (reducir 0 '(1 2 3 4 5) (LAMBDA (a b) (+ a b))) 

15

> (reducir "" '("hola " "Mundo") (LAMBDA (a b) (concatenate 'string a b)))

"hola Mundo"

 > (reducir "" '("uno" "dos" "tres" "super tranquilo") (LAMBDA (a b) (concatenate 'string a " " b)))

" uno dos tres super tranquilo"

Read y Write en Rust

Usando Read y BufRead, nos podemos abstraer a un vector de u8

use std::io::{BufRead, BufReader, Read, Result};

fn count_lines<R: Read>(reader: R) -> usize {

    let buf_reader = BufReader::new(reader);

    buf_reader.lines().count()

}

fn main() -> Result<()> {

    let slice: &[u8] = b"foo\nbar\nbaz\n";

    println!("lines in slice: {}", count_lines(slice));

    let file = std::fs::File::open(std::env::current_exe()?)?;

    println!("lines in file: {}", count_lines(file));

    Ok(())

}

De manera similar, Write nos permite abstraernos de igual forma:

use std::io::{Result, Write};

fn log<W: Write>(writer: &mut W, msg: &str) -> Result<()> {

    writer.write_all(msg.as_bytes())?;

    writer.write_all("\n".as_bytes())

}

fn main() -> Result<()> {

    let mut buffer = Vec::new();

    log(&mut buffer, "Hello")?;

    log(&mut buffer, "World")?;

    println!("Logged: {:?}", buffer);

    Ok(())

}

Slices en golang

Los Slices envuelven matrices para brindar una interfaz más general, poderosa y conveniente para secuencias de datos. Excepto por elementos con dimensiones explícitas, como matrices de transformación, la mayor parte de la programación de matrices en Go se realiza con Slices en lugar de simples arrays.

Los Slices contienen referencias a una matriz subyacente y, si asigna un Slice a otro, ambos se refieren a la misma matriz. Si una función toma un argumento de tipo Slice, los cambios que realice en los elementos del segmento serán visibles para quien llama, de forma análoga a pasar un puntero a la matriz subyacente. Por lo tanto, una función de lectura puede aceptar un argumento de tipo Slice en lugar de un puntero y una dimensión; la longitud dentro del segmento establece un límite superior de la cantidad de datos que se leerán. Aquí está la firma del método de lectura del tipo de archivo en el paquete os:

func (f *File) Read(buf []byte) (n int, err error)

El método devuelve el número de bytes leídos y un valor de error, si lo hubiera. Para leer los primeros 32 bytes hacemos: 

  n, err := f.Read(buf[0:32])

Este Slice es común y eficiente. De hecho, dejando de lado la eficiencia por el momento, el siguiente fragmento también leería los primeros 32 bytes del búfer.

    var n int

    var err error

    for i := 0; i < 32; i++ {

        nbytes, e := f.Read(buf[i:i+1])  // Read one byte.

        n += nbytes

        if nbytes == 0 || e != nil {

            err = e

            break

        }

    }

La longitud de un segmento se puede cambiar siempre que todavía se ajuste dentro de los límites de la matriz subyacente; simplemente asígnalo a una Slice de sí mismo. La capacidad de un Slice es accesible mediante una función incorporada, informa la longitud máxima que puede asumir el segmento. Aquí hay una función para agregar datos a un slice. Si los datos exceden la capacidad, se reasigna el slice y se devuelve el slice resultante. La función utiliza el hecho de que len y cap son legales cuando se aplican a segmentos nulos y devuelven 0.

func Append(slice, data []byte) []byte {

    l := len(slice)

    if l + len(data) > cap(slice) {  // reallocate

        // Allocate double what's needed, for future growth.

        newSlice := make([]byte, (l+len(data))*2)

        // The copy function is predeclared and works for any slice type.

        copy(newSlice, slice)

        slice = newSlice

    }

    slice = slice[0:l+len(data)]

    copy(slice[l:], data)

    return slice

}

Debemos devolver el slice después porque, aunque Append puede modificar los elementos del slice, el slice en sí (la estructura de datos en tiempo de ejecución que contiene el puntero, la longitud y la capacidad) se pasa por valor.

La idea de agregar un elemento a un slice es tan util que tenemos una función para hacerlo:  append. Sin embargo, para comprender el diseño de esa función necesitamos un poco más de información, por lo que volveremos a ello más adelante.

Función map en lisp

Vamos a hacer una función transformar o map en lisp que lo que haga es tome una lista y una función y aplique esa función a cada elemento de la lista. 

Para esto vamos a analizar los casos si la lista esta vacía, ya esta retornamos la lista vacía. Si no esta vacía, creamos una nueva lista aplicando esa función al primer elemento y llamando de forma recursiva la función transformar para el resto. 

Sería así : 

(defun transformar (l fx)

   (cond 

      ((Null l) Nil)

      (T (cons (Funcall fx (first l)) 

           (transformar (rest l) fx)))

    )

) 

Y la podemos llamar de esta manera : 

> (transformar '(1 2 3) (LAMBDA (a) (* a 2)))

(2 4 6)

o

 > (transformar '(1 2 3) (LAMBDA (a) (+ a 1)))

(2 3 4)

From y Into de Rust

 Los tipos implementan From y Into facilitan las conversiones de tipos:

fn main() {

    let s = String::from("hello");

    let addr = std::net::Ipv4Addr::from([127, 0, 0, 1]);

    let one = i16::from(true);

    let bigger = i32::from(123i16);

    println!("{s}, {addr}, {one}, {bigger}");

}

Into se implementa automáticamente cuando se implementa From:

fn main() {

    let s: String = "hello".into();

    let addr: std::net::Ipv4Addr = [127, 0, 0, 1].into();

    let one: i16 = true.into();

    let bigger: i32 = 123i16.into();

    println!("{s}, {addr}, {one}, {bigger}");

}

Es por eso que es común implementar solo From.

Al declarar un tipo de entrada de argumento de función como "cualquier cosa que pueda convertirse en una cadena", la regla es la opuesta, debes usar Into. Su función aceptará tipos que implementen From y aquellos que solo implementen Into.